java面试算法总结_面试10大算法汇总——Java篇

问题导读

1 字符串和数组

2 链表

3 树

4 图

5 排序

6 递归 vs 迭代

7 动态规划

8 位操作

9 概率问题

10 排列组合

11 其他 -- 寻找规律

1. 字符串和数组

字符串和数组是最常见的面试题目类型，应当分配最大的时间。关于字符串，首先需要注意的是和C++不同，Java字符串不是char数组。没有IDE代码自动补全功能，应该记住下面的这些常用的方法。

1、toCharArray() //获得字符串对应的char数组

2、Arrays.sort() //数组排序

3、Arrays.toString(char[] a) //数组转成字符串

4、charAt(int x) //获得某个索引处的字符

5、length() //字符串长度

6、length //数组大小

7、substring(intbeginIndex)8、substring(int beginIndex, intendIndex)9、Integer.valueOf() //string to integer

10、String.valueOf() /integer to string

1 classNode {2

3 intval;4

5 Node next;6

7 Node(intx) {8 val =x;9

10 next = null;11

12 }13

14 }

1 classTreeNode{2 intvalue;3

4 TreeNode left;5

6 TreeNode right;7

8 }

1 public classGraphTest {2

3 public static void breathFirstSearch(GraphNode root, intx){4

5 if(root.val ==x)6

7 System.out.println("find in root");8

9 Queue queue = newQueue();10 root.visited = true;11

12 queue.enqueue(root);13

14 while(queue.first != null){15

16 GraphNode c =(GraphNode) queue.dequeue();17

18 for(GraphNode n: c.neighbors){19

20 if(!n.visited){21

22 System.out.print(n + " ");23

24 n.visited = true;25

26 if(n.val ==x)27

28 System.out.println("Find "+n);29

30 queue.enqueue(n);31

32 }33

34 }35

36 }37

38 }39

40 }

经典题目：

复制图(Clone Graph)

5. 排序

下面是不同排序算法的时间复杂度，你可以去wiki看一下这些算法的基本思想。

Algorithm

Average Time

Worst Time

Space

冒泡排序(Bubble sort)

n^2

n^2

1

选择排序(Selection sort)

n^2

n^2

1

插入排序(Insertion sort)

n^2

n^2

快速排序(Quick sort)

n log(n)

n^2

归并排序(Merge sort)

n log(n)

n log(n)

depends

* 另外还有BinSort, RadixSort和CountSort 三种比较特殊的排序。

经典题目： Mergesort, Quicksort, InsertionSort.

6. 递归 vs. 迭代

对程序员来说，递归应该是一个与生俱来的思想(a built-in thought)，可以通过一个简单的例子来说明。问题：

有n步台阶，一次只能上1步或2步，共有多少种走法。

步骤1:找到走完前n步台阶和前n-1步台阶之间的关系。为了走完n步台阶，只有两种方法：从n-1步台阶爬1步走到或从n-2步台阶处爬2步走到。如果f(n)是爬到第n步台阶的方法数，那么f(n) = f(n-1) + f(n-2)。步骤2: 确保开始条件是正确的。f(0) = 0;f(1) = 1;

1 public static int f(intn){2 if(n <= 2) returnn;3

4 int x = f(n-1) + f(n-2);5

6 returnx;7

8 }

递归方法的时间复杂度是指数级，因为有很多冗余的计算：

f(5)f(4) + f(3)f(3) + f(2) + f(2) + f(1)f(2) + f(1) + f(1) + f(0) + f(1) + f(0) + f(1)f(1) + f(0) + f(1) + f(1) + f(0) + f(1) + f(0) + f(1)

直接的想法是将递归转换为迭代：

1 public static int f(intn) {2

3 if (n <= 2){4

5 returnn;6

7 }8

9 int first = 1, second = 2;10 int third = 0;11

12 for (int i = 3; i <= n; i++) {13

14 third = first +second;15

16 first =second;17

18 second =third;19

20 }21

22 returnthird;23

24 }

这个例子迭代花费的时间更少，你可能复习一个两者的区别Recursion vs Iteration。

7. 动态规划

动态规划是解决下面这些性质类问题的技术：

一个问题可以通过更小子问题的解决方法来解决，或者说问题的最优解包含了其子问题的最优解

有些子问题的解可能需要计算多次

子问题的解存储在一张表格里，这样每个子问题只用计算一次

需要额外的空间以节省时间

爬台阶问题完全符合上面的四条性质，因此可以用动态规划法来解决。

1 public static int[] A = new int[100];2

3 public static int f3(intn) {4 if (n <= 2)5

6 A[n]=n;7

8 if(A[n] > 0)9

10 returnA[n];11

12 else

13

14 A[n] = f3(n-1) + f3(n-2);//store results so only calculate once!

15

16 returnA[n];17

18 }

OR (|)

AND (&)

XOR (^)

Left Shift (<

Right Shift (>>)

Not (~)

1|0=1

1&0=0

1^0=1

0010<<2=1000

1100>>2=0011

~1=0

用一个题目来理解这些操作 －

获得给定数字n的第i位：(i从0计数并从右边开始)

1 public static boolean getBit(int num, inti){2

3 int result = num & (1<

5 if(result == 0){6 return false;7

8 }else{9

10 return true;11

12 }

例如，获得数字10的第2位：i=1, n=101<<1= 101010&10=1010 is not 0, so return true;

9. 概率问题

解决概率相关的问题通常需要先分析问题，下面是一个这类问题的简单例子：

一个房间里有50个人，那么至少有两个人生日相同的概率是多少？(忽略闰年的事实，也就是一年365天)

计算某些事情的概率很多时候都可以转换成先计算其相对面。在这个例子里，我们可以计算所有人生日都互不相同的概率，也就是：365/365 * 364/365 * 363/365 * … * (365-49)/365，这样至少两个人生日相同的概率就是1 – 这个值。

1 public static double caculateProbability(intn){2

3 double x = 1;4

5 for(int i=0; i

8 }9

10 double pro = Math.round((1-x) * 100);11

12 return pro/100;13

14 }15

16 calculateProbability(50) = 0.97

经典题目：桶中取球

10. 排列组合

组合和排列的区别在于次序是否关键。例1：

1、2、3、4、5这5个数字，用java写一个方法，打印出所有不同的排列， 如：51234、41235等。要求："4"不能在第三位，"3"与"5"不能相连。

例2：

5个香蕉，4个梨子，3个苹果。同一种水果都是一样的，这个些水果排列成不同的组合有多少情况？

11. 其他类型的题目

主要是不能归到上面10大类的。需要寻找规律，然后解决问题的。 经典题目: Reverse Integer