Java面试题集（136-150）

摘要：这一部分主要是数据结构和算法相关的面试题目，虽然只有15道题目，但是包含的信息量还是很大的，很多题目背后的解题思路和算法是非常值得玩味的。

136、给出下面的二叉树先序、中序、后序遍历的序列？

答：先序序列：ABDEGHCF；中序序列：DBGEHACF；后序序列：DGHEBFCA。

补充：二叉树也称为二分树，它是树形结构的一种，其特点是每个结点至多有二棵子树，并且二叉树的子树有左右之分，其次序不能任意颠倒。二叉树的遍历序列按照访问根节点的顺序分为先序（先访问根节点，接下来先序访问左子树，再先序访问右子树）、中序（先中序访问左子树，然后访问根节点，最后中序访问右子树）和后序（先后序访问左子树，再后序访问右子树，最后访问根节点）。如果知道一棵二叉树的先序和中序序列或者中序和后序序列，那么也可以还原出该二叉树。

例如，已知二叉树的先序序列为：xefdzmhqsk，中序序列为：fezdmxqhks，那么还原出该二叉树应该如下图所示：

 

137、你知道的排序算法都哪些？用Java写一个排序系统。

答：稳定的排序算法有：插入排序、选择排序、冒泡排序、鸡尾酒排序、归并排序、二叉树排序、基数排序等；不稳定排序算法包括：希尔排序、堆排序、快速排序等。

下面是关于排序算法的一个列表：

下面按照策略模式给出一个排序系统，实现了冒泡、归并和快速排序。

Sorter.java

[java]  ​​view plain​​​  ​​​copy​​

1. package com.jackfrued.util;
2. 
   
3. import java.util.Comparator;
4. 
   
5. /**
6. * 排序器接口(策略模式: 将算法封装到具有共同接口的独立的类中使得它们可以相互替换)
7. * @author骆昊
8. *
9. */
10. public interface Sorter {
11. 
    
12. /**
13. * 排序
14. * @param list 待排序的数组
15. */
16. public <T extends Comparable<T>> void sort(T[] list);
17. 
    
18. /**
19. * 排序
20. * @param list 待排序的数组
21. * @param comp 比较两个对象的比较器
22. */
23. public <T> void sort(T[] list, Comparator<T> comp);
24. }

 

BubbleSorter.java

[java]  ​​view plain​​​  ​​​copy​​

1. package com.jackfrued.util;
2. 
   
3. import java.util.Comparator;
4. 
   
5. /**
6. * 冒泡排序
7. * @author骆昊
8. *
9. */
10. public class BubbleSorter implements Sorter {
11. 
    
12. @Override
13. public <T extends Comparable<T>> void sort(T[] list) {
14. boolean swapped = true;
15. for(int i = 1; i < list.length && swapped;i++) {
16. false;
17. for(int j = 0; j < list.length - i; j++) {
18. if(list[j].compareTo(list[j+ 1]) > 0 ) {
19. T temp = list[j];
20. 1];
21. 1] = temp;
22. true;
23. }
24. }
25. }
26. }
27. 
    
28. @Override
29. public <T> void sort(T[] list,Comparator<T> comp) {
30. boolean swapped = true;
31. for(int i = 1; i < list.length && swapped; i++) {
32. false;
33. for(int j = 0; j < list.length - i; j++) {
34. if(comp.compare(list[j], list[j + 1]) > 0 ) {
35. T temp = list[j];
36. 1];
37. 1] = temp;
38. true;
39. }
40. }
41. }
42. }
43. }

 

MergeSorter.java

[java]  ​​view plain​​​  ​​​copy​​

1. package com.jackfrued.util;
2. 
   
3. import java.util.Comparator;
4. 
   
5. /**
6. * 归并排序
7. * 归并排序是建立在归并操作上的一种有效的排序算法。
8. * 该算法是采用分治法（divide-and-conquer）的一个非常典型的应用，
9. * 先将待排序的序列划分成一个一个的元素，再进行两两归并，
10. * 在归并的过程中保持归并之后的序列仍然有序。
11. * @author骆昊
12. *
13. */
14. public class MergeSorter implements Sorter {
15. 
    
16. @Override
17. public <T extends Comparable<T>> void sort(T[] list) {
18. new Comparable[list.length];
19. 0, list.length- 1);
20. }
21. 
    
22. private <T extends Comparable<T>> void mSort(T[] list, T[] temp, int low, int high) {
23. if(low == high) {
24. return ;
25. }
26. else {
27. int mid = low + ((high -low) >> 1);
28. mSort(list,temp, low, mid);
29. 1, high);
30. 1, high);
31. }
32. }
33. 
    
34. private <T extends Comparable<T>> void merge(T[] list, T[] temp, int left, int right, int last) {
35. int j = 0;
36. int lowIndex = left;
37. int mid = right - 1;
38. int n = last - lowIndex + 1;
39. while (left <= mid && right <= last){
40. if (list[left].compareTo(list[right]) < 0){
41. temp[j++] = list[left++];
42. else {
43. temp[j++] = list[right++];
44. }
45. }
46. while (left <= mid) {
47. temp[j++] = list[left++];
48. }
49. while (right <= last) {
50. temp[j++] = list[right++];
51. }
52. for (j = 0; j < n; j++) {
53. list[lowIndex + j] = temp[j];
54. }
55. }
56. 
    
57. @Override
58. public <T> void sort(T[] list, Comparator<T> comp) {
59. new Comparable[list.length];
60. 0, list.length- 1, comp);
61. }
62. 
    
63. private <T> void mSort(T[] list, T[] temp, int low, int high, Comparator<T> comp) {
64. if(low == high) {
65. return ;
66. }
67. else {
68. int mid = low + ((high -low) >> 1);
69. mSort(list,temp, low, mid, comp);
70. 1, high, comp);
71. 1, high, comp);
72. }
73. }
74. 
    
75. private <T> void merge(T[] list, T[]temp, int left, int right, int last, Comparator<T> comp) {
76. int j = 0;
77. int lowIndex = left;
78. int mid = right - 1;
79. int n = last - lowIndex + 1;
80. while (left <= mid && right <= last){
81. if (comp.compare(list[left], list[right]) <0) {
82. temp[j++] = list[left++];
83. else {
84. temp[j++] = list[right++];
85. }
86. }
87. while (left <= mid) {
88. temp[j++] = list[left++];
89. }
90. while (right <= last) {
91. temp[j++] = list[right++];
92. }
93. for (j = 0; j < n; j++) {
94. list[lowIndex + j] = temp[j];
95. }
96. }
97. 
    
98. }

 

QuickSorter.java

[java]  ​​view plain​​​  ​​​copy​​

1. package com.jackfrued.util;
2. 
   
3. import java.util.Comparator;
4. 
   
5. /**
6. * 快速排序
7. * 快速排序是使用分治法（divide-and-conquer）依选定的枢轴
8. * 将待排序序列划分成两个子序列，其中一个子序列的元素都小于枢轴，
9. * 另一个子序列的元素都大于或等于枢轴，然后对子序列重复上面的方法，
10. * 直到子序列中只有一个元素为止
11. * @author Hao
12. *
13. */
14. public class QuickSorter implements Sorter {
15. 
    
16. @Override
17. public <T extends Comparable<T>> void sort(T[] list) {
18. 0, list.length- 1);
19. }
20. 
    
21. @Override
22. public <T> void sort(T[] list, Comparator<T> comp) {
23. 0, list.length- 1, comp);
24. }
25. 
    
26. private <T extends Comparable<T>> void quickSort(T[] list, int first, int last) {
27. if (last > first) {
28. int pivotIndex = partition(list, first, last);
29. 1);
30. quickSort(list, pivotIndex, last);
31. }
32. }
33. 
    
34. private <T> void quickSort(T[] list, int first, int last,Comparator<T> comp) {
35. if (last > first) {
36. int pivotIndex = partition(list, first, last, comp);
37. 1, comp);
38. quickSort(list, pivotIndex, last, comp);
39. }
40. }
41. 
    
42. private <T extends Comparable<T>> int partition(T[] list, int first, int last) {
43. T pivot = list[first];
44. int low = first + 1;
45. int high = last;
46. 
    
47. while (high > low) {
48. while (low <= high && list[low].compareTo(pivot) <= 0) {
49. low++;
50. }
51. while (low <= high && list[high].compareTo(pivot) >= 0) {
52. high--;
53. }
54. if (high > low) {
55. T temp = list[high];
56. list[high]= list[low];
57. list[low]= temp;
58. }
59. }
60. 
    
61. while (high > first&& list[high].compareTo(pivot) >= 0) {
62. high--;
63. }
64. if (pivot.compareTo(list[high])> 0) {
65. list[first]= list[high];
66. list[high]= pivot;
67. return high;
68. }
69. else {
70. return low;
71. }
72. }
73. 
    
74. private <T> int partition(T[] list, int first, int last, Comparator<T> comp) {
75. T pivot = list[first];
76. int low = first + 1;
77. int high = last;
78. 
    
79. while (high > low) {
80. while (low <= high&& comp.compare(list[low], pivot) <= 0) {
81. low++;
82. }
83. while (low <= high&& comp.compare(list[high], pivot) >= 0) {
84. high--;
85. }
86. if (high > low) {
87. T temp = list[high];
88. list[high] = list[low];
89. list[low]= temp;
90. }
91. }
92. 
    
93. while (high > first&& comp.compare(list[high], pivot) >= 0) {
94. high--;
95. }
96. if (comp.compare(pivot,list[high]) > 0) {
97. list[first]= list[high];
98. list[high]= pivot;
99. return high;
100. }
101. else {
102. return low;
103. }
104. }
105. 
     
106. }

 

138、写一个二分查找（折半搜索）的算法。

答：折半搜索，也称二分查找算法、二分搜索，是一种在有序数组中查找某一特定元素的​​搜索算法​​。搜素过程从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜素过程结束；如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。如果在某一步骤数组为空，则代表找不到。这种搜索算法每一次比较都使搜索范围缩小一半。

[java]  ​​view plain​​​  ​​​copy​​

1. package com.jackfrued.util;
2. 
   
3. import java.util.Comparator;
4. 
   
5. public class MyUtil {
6. 
   
7. public static <T extends Comparable<T>> int binarySearch(T[] x, T key) {
8. return binarySearch(x, 0, x.length- 1, key);
9. }
10. 
    
11. public static <T> int binarySearch(T[] x, T key, Comparator<T> comp) {
12. int low = 0;
13. int high = x.length - 1;
14. while (low <= high) {
15. int mid = (low + high) >>> 1;
16. int cmp = comp.compare(x[mid], key);
17. if (cmp < 0) {
18. 1;
19. }
20. else if (cmp > 0) {
21. 1;
22. }
23. else {
24. return mid;
25. }
26. }
27. return -1;
28. }
29. 
    
30. private static <T extends Comparable<T>> int binarySearch(T[] x, int low, int high, T key) {
31. if(low <= high) {
32. int mid = low + ((high -low) >> 1);
33. if(key.compareTo(x[mid]) == 0) {
34. return mid;
35. }
36. else if(key.compareTo(x[mid])< 0) {
37. return binarySearch(x,l ow, mid - 1, key);
38. }
39. else {
40. return binarySearch(x, mid + 1, high, key);
41. }
42. }
43. return -1;
44. }
45. }

说明：两个版本一个用递归实现，一个用循环实现。需要注意的是计算中间位置时不应该使用(high+ low) / 2的方式，因为加法运算可能导致整数越界，这里应该使用一下三种方式之一：low+ (high – low) / 2或low + (high – low) >> 1或（low + high） >>> 1（注：>>>是逻辑右移，不带符号位的右移）

 

139、统计一篇英文文章中单词个数。

答：

[java]  ​​view plain​​​  ​​​copy​​

1. import java.io.FileReader;
2. 
   
3. public class WordCounting {
4. 
   
5. public static void main(String[] args) {
6. try(FileReader fr = new FileReader("a.txt")) {
7. int counter = 0;
8. boolean state = false;
9. int currentChar;
10. while((currentChar= fr.read()) != -1) {
11. if(currentChar== ' ' || currentChar == '\n'
12. '\t' || currentChar == '\r') {
13. false;
14. }
15. else if(!state) {
16. true;
17. counter++;
18. }
19. }
20. System.out.println(counter);
21. }
22. catch(Exceptione) {
23. e.printStackTrace();
24. }
25. }
26. }

补充：这个程序可能有很多种写法，这里选择的是Dennis M. Ritchie和Brian W. Kernighan老师在他们不朽的著作《The C Programming Language》中给出的代码，向两位老师致敬。下面的代码也是如此。

 

140、输入年月日，计算该日期是这一年的第几天。

答：

[java]  ​​view plain​​​  ​​​copy​​

1. import java.util.Scanner;
2. 
   
3. public class DayCounting {
4. 
   
5. public static void main(String[] args) {
6. int[][] data = {
7. 31,28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
8. 31,29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}
9. };
10. Scanner sc = newScanner(System.in);
11. "请输入年月日(1980 11 28): ");
12. int year = sc.nextInt();
13. int month = sc.nextInt();
14. int date = sc.nextInt();
15. int[] daysOfMonth = data[(year % 4 == 0 && year % 100 != 0 || year % 400 == 0)?1 : 0];
16. int sum = 0;
17. for(int i = 0; i < month -1; i++) {
18. sum += daysOfMonth[i];
19. }
20. sum += date;
21. System.out.println(sum);
22. sc.close();
23. }
24. }

 

141、约瑟夫环：15个基督教徒和15个非教徒在海上遇险，必须将其中一半的人投入海中，其余的人才能幸免于难，于是30个人围成一圈，从某一个人开始从1报数，报到9的人就扔进大海，他后面的人继续从1开始报数，重复上面的规则，直到剩下15个人为止。结果由于上帝的保佑，15个基督教徒最后都幸免于难，问原来这些人是怎么排列的，哪些位置是基督教徒，哪些位置是非教徒。

答：

[java]  ​​view plain​​​  ​​​copy​​

1. public class Josephu {
2. private static final int DEAD_NUM = 9;
3. 
   
4. public static void main(String[] args) {
5. boolean[] persons = new boolean[30];
6. for(int i = 0; i < persons.length; i++) {
7. true;
8. }
9. 
   
10. int counter = 0;
11. int claimNumber = 0;
12. int index = 0;
13. while(counter < 15) {
14. if(persons[index]) {
15. claimNumber++;
16. if(claimNumber == DEAD_NUM) {
17. counter++;
18. 0;
19. false;
20. }
21. }
22. index++;
23. if(index >= persons.length) {
24. 0;
25. }
26. }
27. for(boolean p : persons) {
28. if(p) {
29. "基");
30. }
31. else {
32. "非");
33. }
34. }
35. }
36. }

 

142、回文素数：所谓回文数就是顺着读和倒着读一样的数(例如：11，121，1991…)，回文素数就是既是回文数又是素数(只能被1和自身整除的数)的数。编程找出11～9999之间的回文素数。

答：

[java]  ​​view plain​​​  ​​​copy​​

1. public class PalindromicPrimeNumber {
2. 
   
3. public static void main(String[] args) {
4. for(int i = 11; i <= 9999; i++) {
5. if(isPrime(i) && isPalindromic(i)) {
6. System.out.println(i);
7. }
8. }
9. }
10. 
    
11. public static boolean isPrime(int n) {
12. for(int i = 2; i <= Math.sqrt(n); i++) {
13. if(n % i == 0) {
14. return false;
15. }
16. }
17. return true;
18. }
19. 
    
20. public static boolean isPalindromic(int n) {
21. int temp = n;
22. int sum = 0;
23. while(temp > 0) {
24. 10 + temp % 10;
25. 10;
26. }
27. return sum == n;
28. }
29. }

 

143、全排列：给出五个数字12345的所有排列。

答：

[java]  ​​view plain​​​  ​​​copy​​

1. public class FullPermutation {
2. 
   
3. public static void perm(int[] list) {
4. 0);
5. }
6. 
   
7. private static void perm(int[] list, int k) {
8. if (k == list.length) {
9. for (int i = 0; i < list.length; i++) {
10. System.out.print(list[i]);
11. }
12. System.out.println();
13. else{
14. for (int i = k; i < list.length; i++) {
15. swap(list, k, i);
16. 1);
17. swap(list, k, i);
18. }
19. }
20. }
21. 
    
22. private static void swap(int[] list, int pos1, int pos2) {
23. int temp = list[pos1];
24. list[pos1] = list[pos2];
25. list[pos2] = temp;
26. }
27. 
    
28. public static void main(String[] args) {
29. int[] x = {1, 2, 3, 4, 5};
30. perm(x);
31. }
32. }
33. 
    

144、对于一个有N个整数元素的一维数组，找出它的子数组（数组中下标连续的元素组成的数组）之和的最大值。

答：下面给出几个例子（最大子数组用粗体表示）：

1) 数组：{ 1, -2, 3,5, -3, 2 }，结果是：8

2) 数组：{ 0, -2, 3, 5, -1, 2 }，结果是：9

3) 数组：{ -9, -2,-3, -5, -3 }，结果是：-2

可以使用动态规划的思想求解：

[java]  ​​view plain​​​  ​​​copy​​

1. public class MaxSum {
2. 
   
3. private static int max(int x, int y) {
4. return x > y? x: y;
5. }
6. 
   
7. public static int maxSum(int[] array) {
8. int n = array.length;
9. int[] start = new int[n];
10. int[] all = new int[n];
11. 1] = start[n - 1] = array[n - 1];
12. for(int i = n - 2; i >= 0;i--) {
13. 1]);
14. 1]);
15. }
16. return all[0];
17. }
18. 
    
19. public static void main(String[] args) {
20. int[] x1 = { 1, -2, 3, 5,-3, 2 };
21. int[] x2 = { 0, -2, 3, 5,-1, 2 };
22. int[] x3 = { -9, -2, -3,-5, -3 };
23. // 8
24. // 9
25. //-2
26. }
27. }

 

145、用递归实现字符串倒转

答：

[java]  ​​view plain​​​  ​​​copy​​

1. public class StringReverse {
2. 
   
3. public static String reverse(String originStr) {
4. if(originStr == null || originStr.length()== 1) {
5. return originStr;
6. }
7. return reverse(originStr.substring(1))+ originStr.charAt(0);
8. }
9. 
   
10. public static void main(String[] args) {
11. "hello"));
12. }
13. }
14. 
    

146、输入一个正整数，将其分解为素数的乘积。

答：

[java]  ​​view plain​​​  ​​​copy​​

1. public class DecomposeInteger {
2. 
   
3. private static List<Integer> list = newArrayList<Integer>();
4. 
   
5. public static void main(String[] args) {
6. "请输入一个数: ");
7. Scanner sc = newScanner(System.in);
8. int n = sc.nextInt();
9. decomposeNumber(n);
10. " = ");
11. for(int i = 0; i < list.size() - 1; i++) {
12. " * ");
13. }
14. 1));
15. }
16. 
    
17. public static void decomposeNumber(int n) {
18. if(isPrime(n)) {
19. list.add(n);
20. 1);
21. }
22. else {
23. int)Math.sqrt(n));
24. }
25. }
26. 
    
27. public static void doIt(int n, int div) {
28. if(isPrime(div) && n % div == 0) {
29. list.add(div);
30. decomposeNumber(n / div);
31. }
32. else {
33. 1);
34. }
35. }
36. 
    
37. public static boolean isPrime(int n) {
38. for(int i = 2; i <= Math.sqrt(n);i++) {
39. if(n % i == 0) {
40. return false;
41. }
42. }
43. return true;
44. }
45. }

 

147、一个有n级的台阶，一次可以走1级、2级或3级，问走完n级台阶有多少种走法。

答：可以通过递归求解。

[java]  ​​view plain​​​  ​​​copy​​

1. public class GoSteps {
2. 
   
3. public static int countWays(int n) {
4. if(n < 0) {
5. return 0;
6. }
7. else if(n == 0) {
8. return 1;
9. }
10. else {
11. return countWays(n - 1) + countWays(n - 2) + countWays(n -3);
12. }
13. }
14. 
    
15. public static void main(String[] args) {
16. 5));   // 13
17. }
18. }

 

148、写一个算法判断一个英文单词的所有字母是否全都不同（不区分大小写）。

答：

[java]  ​​view plain​​​  ​​​copy​​

1. public class AllNotTheSame {
2. 
   
3. public static boolean judge(String str) {
4. String temp = str.toLowerCase();
5. int[] letterCounter = new int[26];
6. for(int i = 0; i <temp.length(); i++) {
7. int index = temp.charAt(i)- 'a';
8. letterCounter[index]++;
9. if(letterCounter[index] > 1) {
10. return false;
11. }
12. }
13. return true;
14. }
15. 
    
16. public static void main(String[] args) {
17. "hello"));
18. "smile"));
19. }
20. }

149、有一个已经排好序的整数数组，其中存在重复元素，请将重复元素删除掉，例如，A= [1, 1, 2, 2, 3]，处理之后的数组应当为A= [1, 2, 3]。

答：

[java]  ​​view plain​​​  ​​​copy​​

1. import java.util.Arrays;
2. 
   
3. public class RemoveDuplication {
4. 
   
5. public static int[] removeDuplicates(int a[]) {
6. if(a.length <= 1) {
7. return a;
8. }
9. int index = 0;
10. for(int i = 1; i < a.length; i++) {
11. if(a[index] != a[i]) {
12. a[++index] = a[i];
13. }
14. }
15. int[] b = new int[index + 1];
16. 0, b, 0, b.length);
17. return b;
18. }
19. 
    
20. public static void main(String[] args) {
21. int[] a = {1, 1, 2, 2, 3};
22. a = removeDuplicates(a);
23. System.out.println(Arrays.toString(a));
24. }
25. }

 

150、给一个数组，其中有一个重复元素占半数以上，找出这个元素。

答：

[java]  ​​view plain​​​  ​​​copy​​

1. public class FindMost {
2. 
   
3. public static <T> T find(T[] x){
4. null;
5. for(int i = 0, nTimes = 0; i< x.length;i++) {
6. if(nTimes == 0) {
7. temp= x[i];
8. 1;
9. }
10. else {
11. if(x[i].equals(temp)) {
12. nTimes++;
13. }
14. else {
15. nTimes--;
16. }
17. }
18. }
19. return temp;
20. }
21. 
    
22. public static void main(String[] args) {
23. "hello","kiss","hello","hello","maybe"};
24. System.out.println(find(strs));
25. }
26. }
27. 
    
28.