Java求職面試準備之常見算法

時間 2019-11-10

標籤 java 求職面試準備常見算法欄目 Java 简体版

原文原文鏈接

最近在求職面試，整理一下常見面試算法：java

對TestAlgorithms.java中方法的測試見JunitTestAlgorithms.java(引入了junit4)面試

1.TestAlgorithms.java算法

  1 package carl;
  2 
  3 import org.junit.Test;
  4 
  5 /**
  6  * 本類中總結了經常使用的幾種算法
  7  * @author Administrator
  8  *
  9  */
 10 public class TestAlgorithms {
 11 
 12     /**
 13      * 插入排序
 14      * 插入排序的基本思想是：每步將一個待排序的紀錄，按其關鍵碼值的大小
 15      * 插入前面已經排序的文件中適當位置上，直到所有插入完爲止。
 16      * @param list
 17      * @return
 18      */
 19     public void insertSort(int[] list){
 20         for(int i=1;i<list.length;i++){
 21             int tmp = list[i];
 22             int j=i-1;
 23             for(; j>=0 && list[j] >tmp; j--){
 24                 list[j+1]=list[j];
 25             }
 26             list[j+1]=tmp;
 27         }
 28         
 29     }
 30     
 31     
 32      /**
 33       * 希爾排序:dk爲1的時候就是插入排序
 34       * 希爾排序是把記錄按下標的必定增量分組，對每組使用直接插入排序算法排序；
 35       * 隨着增量逐漸減小，每組包含的關鍵詞愈來愈多，當增量減至1時，整個文件恰被分紅一組，算法便終止。
 36       * @param list
 37       * @param start
 38       * @param dk
 39       */
 40     public void shellInsert(int[] list, int start, int dk) {
 41         int i,j;
 42         for(i = start+dk; i < list.length;  i = i + dk){
 43             j = i-dk;
 44             int tmp = list[i];
 45             
 46             for (;j >= 0 && list[j] > tmp;j -= dk) {
 47                 list[j + dk] = list[j];
 48             }
 49             list[j + dk] = tmp;
 50         }
 51         
 52      }
 53     
 54     
 55      /**
 56       * 冒泡排序
 57       * 它重複地走訪過要排序的數列，一次比較兩個元素，
 58       * 若是他們的順序錯誤就把他們交換過來。走訪數列的工做是
 59       * 重複地進行直到沒有再須要交換，也就是說該數列已經排序完成。
 60       * 這個算法的名字由來是由於越大的元素會經由交換慢慢「浮」到數列的頂端，故名。
 61       * @param list
 62       */
 63     public void bubbleSort(int[] list) {
 64         for (int i = 0; i < list.length; i++) {
 65             for (int j = 0; j < list.length - i - 1; j++) {
 66                 if (list[j] > list[j + 1]) {
 67                  int temp = list[j];
 68                  list[j] = list[j + 1];
 69                  list[j + 1] = temp;
 70                 }
 71             }
 72         }
 73      }
 74     
 75      // 字符串反轉
 76      public String reverse(String str) {
 77          String str1 = "";
 78          for (int i = str.length(); i > 0; i--) {
 79              str1 += str.substring(i - 1, i);
 80          }
 81           return str1;
 82      }
 83      
 84      /**
 85       * 編碼實現字符串轉整型的函數（實現函數atoi的功能）。
 86       * 如將字符串」+123」->123, 」-0123」->-123,「123CS45」->123,「123.45CS」->123, 「CS123.45」->0
 87       * @param str1
 88       * @return
 89       */
 90     public int str2Int(String str1) {
 91       char[] str = str1.toCharArray();
 92       int i = 0, sign = 1, value = 0;
 93       if (str != null && str[0] > '9' && str[0] < '0') {
 94        value = 0; // 若是第一個元素爲字母，直接賦值零
 95       } else {
 96        if (str != null && str[0] == '-' || str[0] == '+') {
 97         // 判斷是否存在符號位
 98         i = 1;
 99         sign = (str[0] == '-' ? -1 : 1);
100        }
101        for (; str[i] >= '0' && str[i] <= '9'; i++)
102         value = value * 10 + (str[i] - '0');
103       }
104       return sign * value;
105      }
106     
107     /**
108      * 根據字節對字符串拆分，要注意如果GBK編碼，則中文字符佔用兩個字節
109      * 如「123我是誰」，拆分4個字節，程序要求的結果爲「123我」，而不是「123?」
110      * @param str
111      */
112     public String splitChinese(String str,int index){
113         String tmp = "";
114         for(int i=1;i<=str.length();i++){
115             tmp = str.substring(0, i);
116             if(tmp.getBytes().length >= index){
117                 return tmp;
118             }
119         }
120         System.out.println(tmp.getBytes().length);
121         
122         return "";
123     }
124     
125 }

2.JunitTestAlgorithms.javashell

 1 package carl;
 2 
 3 import java.io.UnsupportedEncodingException;
 4 
 5 import org.junit.Test;
 6 
 7 public class JunitTestAlgorithms {
 8     TestAlgorithms ta = new TestAlgorithms();
 9     
10     public void pintList(int[] target){
11         int len = target.length;
12         System.out.println("length:"+len);
13         for(int i = 0; i < len; i++){
14             System.out.print(target[i]+ (i==(len-1)?"":","));
15         }    
16     }
17     
18     @Test
19     public void insertSortTest(){
20         int[] list = {1,2,3,4,7,5,6,10,22};
21         ta.insertSort(list);
22         System.out.println("\n------------insertSortTest-----------");
23         this.pintList(list);            
24     }
25     
26     @Test
27     public void shellInsertTest(){
28         int[] list = {1,2,3,4,7,5,6,10,22};
29         int i = 0, w = 2;
30         while (i < w) {
31            ta.shellInsert(list, i, w);
32            i++;
33         }
34         ta.shellInsert(list, 0, 1);
35         System.out.println("\n-----------shellInsertTest-----------");
36         this.pintList(list);
37     }
38     
39     @Test
40     public void bubbleSortTest(){
41         int[] list = {1,2,3,4,7,5,6,10,22};
42         ta.bubbleSort(list);
43         System.out.println("\n------------bubbleSortTest---------");
44         this.pintList(list);
45     }
46     
47     @Test
48     public void reverseTest(){
49         String str = "abcdefg";
50         String tmp = ta.reverse(str);
51         System.out.println("\n----------reverseTest------------");
52         System.out.println(tmp);
53     }
54     
55     @Test
56     public void str2IntTest(){
57         int str2Int = ta.str2Int("-123.4CS4546");
58         System.out.println("\n----------str2IntTest------------");
59         System.out.println(str2Int);
60     }
61     
62     @Test
63     public void splitChineseTest(){
64         String str="123我是誰";
65         System.out.println("\n----------splitChineseTest------------");
66         try {
67             //由於個人java文件編碼是GBK，因此getBytes()默認的編碼是GBK
68             System.out.println("\"123我是誰\".getBytes(\"GBK\").length:"+str.getBytes("GBK").length);
69             System.out.println("\"123我是誰\".getBytes().length:"+str.getBytes().length);
70         } catch (UnsupportedEncodingException e) {
71             e.printStackTrace();
72         }
73         String resultStr = ta.splitChinese(str,4);
74         System.out.println(resultStr);
75     }
76     
77 
78 
79 }