Java面试中经常会被问到的一些算法的问题，而大部分算法的理论及思想，我们曾经都能倒背如流，并且也能用开发语言来实现过，可是很多由于可能在项目开发中应用的比较少，久而久之就很容易被忘记了，在此我分享一下在面试中经常被问到的一些基本的算法，也当做一次知识的巩固。
一、冒泡排序
1. package
2.
3. import
4. /**
5. * 依次比较相邻的两个数，将小数放在前面，大数放在后面
6. * 冒泡排序，具有稳定性
7. * 时间复杂度为O（n^2）
8. * 不及堆排序，快速排序O（nlogn，底数为2）
9. * @author liangge
10. *
11. */
12. public class
13. public static void
14. new
15. int[] sort = new int[10];
16. for(int i = 0 ; i < 10
17. 50);
18. }
19. “排序前的数组为”);
20. for(int
21. “ ”);
22. }
23. buddleSort(sort);
24. System.out.println();
25. “排序后的数组为”);
26. for(int
27. “ ”);
28. }
29. }
30.
31. /**
32. * 冒泡排序
33. * @param sort
34. */
35. private static void buddleSort(int[] sort){
36. for(int i=1;i<sort.length;i++){
37. for(int j=0;j<sort.length-i;j++){
38. if(sort[j]>sort[j+1]){
39. int temp = sort[j+1];
40. 1] = sort[j];
41. sort[j] = temp;
42. }
43. }
44. }
45. }
46. }
二、选择排序
1. package
2.
3. import
4.
5. /**
6. * 选择排序
7. * 每一趟从待排序的数据元素中选出最小（或最大）的一个元素，
8. * 顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。
9. * 选择排序是不稳定的排序方法。
10. * @author liangge
11. *
12. */
13. public class
14. public static void
15. new
16. int[] sort = new int[10];
17. for (int i = 0; i < 10; i++) {
18. 50);
19. }
20. “排序前的数组为”);
21. for (int
22. “ ”);
23. }
24. selectSort(sort);
25. System.out.println();
26. “排序后的数组为”);
27. for (int
28. “ ”);
29. }
30. }
31.
32. /**
33. * 选择排序
34. * @param sort
35. */
36. private static void selectSort(int[] sort){
37. for(int i =0;i<sort.length-1;i++){
38. for(int j = i+1;j<sort.length;j++){
39. if(sort[j]<sort[i]){
40. int
41. sort[j] = sort[i];
42. sort[i] = temp;
43. }
44. }
45. }
46. }
47. }
三、快速排序
1. package
2.
3. /**
4. * 快速排序 通过一趟排序将要排序的数据分割成独立的两部分， 其中一部分的所有数据都比另外一部分的所有数据都要小，
5. * 然后再按此方法对这两部分数据分别进行快速排序， 整个排序过程可以递归进行，以此达到整个数据变成有序序列。
6. * @author liangge
7. *
8. */
9. public class
10. public static void
11. int[] sort = { 54, 31, 89, 33, 66, 12, 68, 20
12. “排序前的数组为：”);
13. for (int
14. “ ”);
15. }
16. System.out.println();
17. 0, sort.length - 1);
18. “排序后的数组为：”);
19. for (int
20. “ ”);
21. }
22. }
23.
24. /**
25. * 快速排序
26. * @param sort 要排序的数组
27. * @param start 排序的开始座标
28. * @param end 排序的结束座标
29. */
30. public static void quickSort(int[] sort, int start, int
31. // 设置关键数据key为要排序数组的第一个元素，
32. // 即第一趟排序后，key右边的数全部比key大，key左边的数全部比key小
33. int
34. // 设置数组左边的索引，往右移动判断比key大的数
35. int
36. // 设置数组右边的索引，往左移动判断比key小的数
37. int
38. // 如果左边索引比右边索引小，则还有数据没有排序
39. while
40. while
41. j–;
42. }
43. while
44. i++;
45. }
46. if
47. int
48. sort[i] = sort[j];
49. sort[j] = temp;
50. }
51. }
52. // 如果左边索引比右边索引要大，说明第一次排序完成，将sort[j]与key对换，
53. // 即保持了key左边的数比key小，key右边的数比key大
54. if
55. int
56. sort[j] = sort[start];
57. sort[start] = temp;
58. }
59. //递归调用
60. if
61. 1);
62. 1, end);
63. }
64. }
65. }
四、插入排序
1. package
2.
3. /**
4. * 直接插入排序
5. * 将一个数据插入到已经排好序的有序数据中,从而得到一个新的、个数加一的有序数据
6. * 算法适用于少量数据的排序，时间复杂度为O(n^2)。是稳定的排序方法。
7. */
8. import
9.
10. public class
11. public static void
12. new
13. int[] sort = new int[10];
14. for (int i = 0; i < 10; i++) {
15. 50);
16. }
17. “排序前的数组为”);
18. for (int
19. “ ”);
20. }
21. directInsertSort(sort);
22. System.out.println();
23. “排序后的数组为”);
24. for (int
25. “ ”);
26. }
27. }
28.
29. /**
30. * 直接插入排序
31. *
32. * @param sort
33. */
34. private static void directInsertSort(int[] sort) {
35. for (int i = 1; i < sort.length; i++) {
36. int index = i - 1;
37. int
38. while (index >= 0
39. 1] = sort[index];
40. index–;
41. }
42. 1] = temp;
43.
44. }
45. }
46. }
二分搜索法
1. package
2.
3. public class
4. public static void
5. int[] sort = {1,2,3,4,5,6,7,8,9,10};
6. int mask = binarySearch(sort,6);
7. System.out.println(mask);
8.
9. }
10.
11.
12. /**
13. * 二分搜索法，返回座标，不存在返回-1
14. * @param sort
15. * @return
16. */
17. private static int binarySearch(int[] sort,int
18. if(data<sort[0] || data>sort[sort.length-1]){
19. return -1;
20. }
21. int begin = 0;
22. int
23. int mid = (begin+end)/2;
24. while(begin <= end){
25. 2;
26. if(data > sort[mid]){
27. 1;
28. else if(data < sort[mid]){
29. 1;
30. else{
31. return
32. }
33. }
34. return -1;
35.
36. }
37. }
尤其是冒泡算法，我建议面试者都能背下来，因为面试中被提到的概率是比较多的。
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
