经典算法整理（java实现）

客官°小女子只卖身不卖艺 2022-06-15 08:28 234阅读 0赞

以下从Java角度解释面试常见的算法和数据结构：字符串，链表，树，图，排序，递归 vs. 迭代，动态规划，位操作，概率问题，排列组合，以及一些需要寻找规律的题目。

1. 字符串和数组

字符串和数组是最常见的面试题目类型，应当分配最大的时间。

关于字符串，首先需要注意的是和C++不同，Java字符串不是char数组。没有IDE代码自动补全功能，应该记住下面的这些常用的方法。

**\[java\]** [view plain][][copy][view plain][![在CODE上查看代码片][CODE]][CODE_CODE][![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  toCharArray() //获得字符串对应的char数组  
2.  Arrays.sort()  //数组排序  
3.  Arrays.toString(**char**\[\] a) //数组转成字符串  
4.  charAt(**int** x) //获得某个索引处的字符  
5.  length() //字符串长度  
6.  length //数组大小  
7.  substring(**int** beginIndex)   
8.  substring(**int** beginIndex, **int** endIndex)  
9.  Integer.valueOf() //string to integer  
10. String.valueOf() /integer to string

字符串和数组本身很简单，但是相关的题目需要更复杂的算法来解决。比如说动态规划，搜索，等等。

经典题目：  
[0) Rotate Array][0_ Rotate Array]  
[1) Evaluate Reverse Polish Notation (Stack)][1_ Evaluate Reverse Polish Notation _Stack]  
[2) Longest Palindromic Substring (DP)][2_ Longest Palindromic Substring _DP]  
[3) Word Break (DP)][3_ Word Break _DP]  
[3) Word Break II (DP, DFS)][3_ Word Break II _DP_ DFS]  
[4) Word Ladder (Queue, BFS)][4_ Word Ladder _Queue_ BFS]  
[5) Median of Two Sorted Arrays][5_ Median of Two Sorted Arrays]  
[6) Regular Expression Matching][6_ Regular Expression Matching]  
[7) Merge Intervals][7_ Merge Intervals]  
[8) Insert Interval][8_ Insert Interval]  
[9) Two Sum][9_ Two Sum]  
[9) Two Sum II – Input array is sorted][9_ Two Sum II _ Input array is sorted]  
[9) Two Sum III - Data structure design][9_ Two Sum III - Data structure design]  
[9) 3Sum][9_ 3Sum]  
[9) 4Sum][9_ 4Sum]  
[10) 3Sum Closest][10_ 3Sum Closest]  
[11) String to Integer][11_ String to Integer]  
[12) Merge Sorted Array][12_ Merge Sorted Array]  
[13) Valid Parentheses][13_ Valid Parentheses]  
[14) Implement strStr()][14_ Implement strStr]  
[15) Set Matrix Zeroes][15_ Set Matrix Zeroes]  
[16) Search Insert Position][16_ Search Insert Position]  
[17) Longest Consecutive Sequence][17_ Longest Consecutive Sequence]  
[18) Valid Palindrome][18_ Valid Palindrome]  
[19) Spiral Matrix][19_ Spiral Matrix]  
[20) Search a 2D Matrix][20_ Search a 2D Matrix]  
[21) Rotate Image][21_ Rotate Image] \[Palantir\]  
[22) Triangle][22_ Triangle]  
[23) Distinct Subsequences Total][23_ Distinct Subsequences Total]  
[24) Maximum Subarray][24_ Maximum Subarray] \[Palantir, LinkedIn\]  
[24) Maximum Product Subarray][24_ Maximum Product Subarray] \[LinkedIn\]  
[25) Remove Duplicates from Sorted Array][25_ Remove Duplicates from Sorted Array]  
[26) Remove Duplicates from Sorted Array II][26_ Remove Duplicates from Sorted Array II]  
[27) Longest Substring Without Repeating Characters][27_ Longest Substring Without Repeating Characters]  
[28) Longest Substring that contains 2 unique characters ][28_ Longest Substring that contains 2 unique characters]\[Google\]  
[29) Palindrome Partitioning][29_ Palindrome Partitioning]  
[29) Palindrome Partitioning II ][29_ Palindrome Partitioning II]  
[30) Reverse Words in a String ][30_ Reverse Words in a String]  
[31) Find Minimum in Rotated Sorted Array ][31_ Find Minimum in Rotated Sorted Array]  
[31) Find Minimum in Rotated Sorted Array II][31_ Find Minimum in Rotated Sorted Array II]  
[32) Find Peak Element][32_ Find Peak Element]  
[33) Min Stack][33_ Min Stack]  
[34) Majority Element][34_ Majority Element]  
[35) Combination Sum (DFS)][35_ Combination Sum _DFS]  
[35) Combination Sum II (DFS)][35_ Combination Sum II _DFS]  
[36) Best Time to Buy and Sell Stock ][36_ Best Time to Buy and Sell Stock]  
[36) Best Time to Buy and Sell Stock II][36_ Best Time to Buy and Sell Stock II]  
[36) Best Time to Buy and Sell Stock III (DP)][36_ Best Time to Buy and Sell Stock III _DP]  
[36) Best Time to Buy and Sell Stock IV (DP)][36_ Best Time to Buy and Sell Stock IV _DP]  
[37) Longest Common Prefix ][37_ Longest Common Prefix]\[Google\]  
[38) Largest Number][38_ Largest Number]  
[39) Combinations (DFS)][39_ Combinations _DFS]  
[40) Compare Version Numbers][40_ Compare Version Numbers]  
[41) Gas Station][41_ Gas Station]  
[42) Candy ][42_ Candy]\[Google\]  
[43) Jump Game][43_ Jump Game]  
[44) Pascal's Triangle][44_ Pascal_s Triangle]  
[44) Pascal’s Triangle II ][44_ Pascal_s Triangle II]  
[45) Container With Most Water][45_ Container With Most Water]  
[46) Count and Say][46_ Count and Say]  
[47) Repeated DNA Sequences][47_ Repeated DNA Sequences]  
[48) House Robber ][48_ House Robber]  
[49) Dungeon Game (DP) ][49_ Dungeon Game _DP]  
[50) Number of Islands (DFS/BFS)][50_ Number of Islands _DFS_BFS]  
[51) Surrounded Regions (BFS)][51_ Surrounded Regions _BFS]  
[52) Max Points on a Line][52_ Max Points on a Line]  
[53) Letter Combinations of a Phone Number (DFS)][53_ Letter Combinations of a Phone Number _DFS]  
[54) Remove Element ][54_ Remove Element]  
[55) Anagrams][55_ Anagrams]  
[56) Search for a Range][56_ Search for a Range]  
[57) Simplify Path][57_ Simplify Path]  
[58) Isomorphic Strings][58_ Isomorphic Strings]  
[59) Minimum Size Subarray Sum][59_ Minimum Size Subarray Sum]  
[60) Minimum Path Sum (DP)][60_ Minimum Path Sum _DP]  
[61) Unique Paths (DP)][61_ Unique Paths _DP]

2. 链表

在Java中，链表的实现非常简单，每个节点Node都有一个值val和指向下个节点的链接next。

**\[java\]** [view plain][][copy][view plain][![在CODE上查看代码片][CODE]][CODE_CODE][![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **class** Node \{  
2.      **int** val;  
3.      Node next;  
4.     
5.      Node(**int** x) \{  
6.          val = x;  
7.          next = **null**;  
8.      \}  
9.  \}

链表两个著名的应用是栈Stack和队列Queue。在Java标准库都都有实现，一个是Stack,另一个是LinkedList(Queue是它实现的接口)。

经典题目：

[1) Add Two Numbers][1_ Add Two Numbers]  
[2) Reorder List][2_ Reorder List]  
[3) Linked List Cycle][3_ Linked List Cycle]  
[4) Copy List with Random Pointer][4_ Copy List with Random Pointer]  
[5) Merge Two Sorted Lists][5_ Merge Two Sorted Lists]  
[6) Merge k Sorted Lists \*][6_ Merge k Sorted Lists]  
[7) Remove Duplicates from Sorted List][7_ Remove Duplicates from Sorted List]  
[8) Partition List][8_ Partition List]  
[9) LRU Cache][9_ LRU Cache]  
[10) Intersection of Two Linked Lists][10_ Intersection of Two Linked Lists]  
[11) Remove Linked List Elements][11_ Remove Linked List Elements]  
[12) Swap Nodes in Pairs][12_ Swap Nodes in Pairs]  
[13) Reverse Linked List][13_ Reverse Linked List]

3. 树

这里的树通常是指二叉树，每个节点都包含一个左孩子节点和右孩子节点，像下面这样：

**\[java\]** [view plain][][copy][view plain][![在CODE上查看代码片][CODE]][CODE_CODE][![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **class** TreeNode\{  
2.      **int** value;  
3.      TreeNode left;  
4.      TreeNode right;  
5.  \}

下面是与树相关的一些概念：

二叉搜索树：左结点 <= 中结点 <= 右结点  
平衡 vs. 非平衡：平衡二叉树中，每个节点的左右子树的深度相差至多为1（1或0）。  
满二叉树（Full Binary Tree）：除叶子节点以为的每个节点都有两个孩子。  
完美二叉树（Perfect Binary Tree）：是具有下列性质的满二叉树：所有的叶子节点都有相同的深度或处在同一层次，且每个父节点都必须有两个孩子。  
完全二叉树（Complete Binary Tree）：二叉树中，可能除了最后一个，每一层都被完全填满，且所有节点都必须尽可能想左靠。

经典题目：

[1) Binary Tree Preorder Traversal ][1_ Binary Tree Preorder Traversal]  
[2) Binary Tree Inorder Traversal][2_ Binary Tree Inorder Traversal] \[Palantir\]  
[3) Binary Tree Postorder Traversal][3_ Binary Tree Postorder Traversal]  
[4) Binary Tree Level Order Traversal][4_ Binary Tree Level Order Traversal]  
[4) Binary Tree Level Order Traversal II][4_ Binary Tree Level Order Traversal II]  
[5) Validate Binary Search Tree][5_ Validate Binary Search Tree]  
[6) Flatten Binary Tree to Linked List][6_ Flatten Binary Tree to Linked List]  
[7) Path Sum (DFS or BFS)][7_ Path Sum _DFS or BFS]  
[7) Path Sum II (DFS) ][7_ Path Sum II _DFS]  
[8) Construct Binary Tree from Inorder and Postorder Traversal][8_ Construct Binary Tree from Inorder and Postorder Traversal]  
[9) Convert Sorted Array to Binary Search Tree][9_ Convert Sorted Array to Binary Search Tree]  
[10) Convert Sorted List to Binary Search Tree][10_ Convert Sorted List to Binary Search Tree]  
[11) Minimum Depth of Binary Tree][11_ Minimum Depth of Binary Tree]  
[12) Binary Tree Maximum Path Sum \*][12_ Binary Tree Maximum Path Sum]  
[13) Balanced Binary Tree][13_ Balanced Binary Tree]  
[14) Symmetric Tree][14_ Symmetric Tree]  
[15) Binary Search Tree Iterator ][15_ Binary Search Tree Iterator]  
[16) Binary Tree Right Side View][16_ Binary Tree Right Side View]  
[17) Implement Trie (Prefix Tree)][17_ Implement Trie _Prefix Tree]  
[18) Add and Search Word - Data structure design (DFS)][18_ Add and Search Word - Data structure design _DFS]

4. 图

图相关的问题主要集中在深度优先搜索（depth first search）和广度优先搜索（breath first search）。深度优先搜索很简单，广度优先要注意使用queue. 下面是一个简单的用队列Queue实现广度优先搜索。

**\[java\]** [view plain][][copy][view plain][![在CODE上查看代码片][CODE]][CODE_CODE][![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **public** **class** GraphTest \{  
2.      **public** **static** **void** breathFirstSearch(GraphNode root, **int** x)\{  
3.          **if**(root.val == x)  
4.              System.out.println("find in root");  
5.     
6.          Queue queue = **new** Queue();  
7.          root.visited = **true**;  
8.          queue.enqueue(root);  
9.     
10.         **while**(queue.first != **null**)\{  
11.             GraphNode c = (GraphNode) queue.dequeue();  
12.             **for**(GraphNode n: c.neighbors)\{  
13.    
14.                 **if**(!n.visited)\{  
15.                     System.out.print(n + " ");  
16.                     n.visited = **true**;  
17.                     **if**(n.val == x)  
18.                         System.out.println("Find "\+n);  
19.                     queue.enqueue(n);  
20.                 \}  
21.             \}  
22.         \}  
23.     \}  
24. \}

经典题目：

[1) Clone Graph][1_ Clone Graph]  
[2) Course Schedule (DFS/BFS)][2_ Course Schedule _DFS_BFS]

5. 排序

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

<table> 
 <tbody> 
  <tr> 
   <td>Algorithm</td> 
   <td>Average Time</td> 
   <td>Worst Time</td> 
   <td>Space</td> 
  </tr> 
  <tr> 
   <td>冒泡排序(Bubble sort)</td> 
   <td>n^2</td> 
   <td>n^2</td> 
   <td>1</td> 
  </tr> 
  <tr> 
   <td>选择排序(Selection sort)</td> 
   <td>n^2</td> 
   <td>n^2</td> 
   <td>1</td> 
  </tr> 
  <tr> 
   <td>插入排序(Insertion sort)</td> 
   <td>n^2</td> 
   <td>n^2</td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td>快速排序(Quick sort)</td> 
   <td>n log(n)</td> 
   <td>n^2</td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td>归并排序(Merge sort)</td> 
   <td>n log(n)</td> 
   <td>n log(n)</td> 
   <td>depends</td> 
  </tr> 
 </tbody> 
</table>

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

经典题目：

[1) Mergesort][1_ Mergesort]  
[2) Quicksort][2_ Quicksort]  
[3) InsertionSort][3_ InsertionSort].  
[4) Maximum Gap (Bucket Sort)][4_ Maximum Gap _Bucket Sort]

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;

**\[java\]** [view plain][][copy][view plain][![在CODE上查看代码片][CODE]][CODE_CODE][![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **public** **static** **int** f(**int** n)\{  
2.      **if**(n <= 2) **return** n;  
3.      **int** x = f(n-1) + f(n-2);  
4.      **return** x;  
5.  \}

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

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)

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

**\[java\]** [view plain][][copy][view plain][![在CODE上查看代码片][CODE]][CODE_CODE][![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **public** **static** **int** f(**int** n) \{  
2.      **if** (n <= 2)\{  
3.          **return** n;  
4.      \}  
5.     
6.      **int** first = 1, second = 2;  
7.      **int** third = 0;  
8.      **for** (**int** i = 3; i <= n; i++) \{  
9.          third = first + second;  
10.         first = second;  
11.         second = third;  
12.     \}  
13.     **return** third;  
14. \}

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

7. 动态规划

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

1.  一个问题可以通过更小子问题的解决方法来解决，或者说问题的最优解包含了其子问题的最优解
2.  有些子问题的解可能需要计算多次
3.  子问题的解存储在一张表格里，这样每个子问题只用计算一次
4.  需要额外的空间以节省时间

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

**\[java\]** [view plain][][copy][view plain][![在CODE上查看代码片][CODE]][CODE_CODE][![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **public** **static** **int**\[\] A = **new** **int**\[100\];  
2.     
3.  **public** **static** **int** f3(**int** n) \{  
4.      **if** (n <= 2)  
5.          A\[n\]= n;  
6.     
7.      **if**(A\[n\] > 0)  
8.          **return** A\[n\];  
9.      **else**  
10.         A\[n\] = f3(n-1) + f3(n-2);//store results so only calculate once!  
11.     **return** A\[n\];  
12. \}

经典题目：

[1) Edit Distance][1_ Edit Distance]  
[2) Longest Palindromic Substring][2_ Longest Palindromic Substring _DP]  
[3) Word Break][3_ Word Break _DP]  
[3) Word Break II][3_ Word Break II _DP_ DFS]  
[4) Maximum Subarray][24_ Maximum Subarray]  
[4) Maximum Product Subarray][24_ Maximum Product Subarray]  
[5) Palindrome Partitioning][29_ Palindrome Partitioning]  
[5) Palindrome Partitioning II ][29_ Palindrome Partitioning II]  
[6) Candy ][42_ Candy]\[Google\]  
[7) Jump Game][43_ Jump Game]  
[8) Best Time to Buy and Sell Stock III (DP)][36_ Best Time to Buy and Sell Stock III _DP]  
[8) Best Time to Buy and Sell Stock IV (DP)][36_ Best Time to Buy and Sell Stock IV _DP]  
[9) Dungeon Game (DP) ][49_ Dungeon Game _DP]  
[10) Minimum Path Sum (DP)][60_ Minimum Path Sum _DP]  
[11) Unique Paths (DP)][61_ Unique Paths _DP]

8. 位操作

常用位操作符：

<table> 
 <tbody> 
  <tr> 
   <td>OR (|)</td> 
   <td>AND (&amp;)</td> 
   <td>XOR (^)</td> 
   <td>Left Shift (&lt;&lt;)</td> 
   <td>Right Shift (&gt;&gt;)</td> 
   <td>Not (~)</td> 
  </tr> 
  <tr> 
   <td>1|0=1</td> 
   <td>1&amp;0=0</td> 
   <td>1^0=1</td> 
   <td>0010&lt;&lt;2=1000</td> 
   <td>1100&gt;&gt;2=0011</td> 
   <td>~1=0</td> 
  </tr> 
 </tbody> 
</table>

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

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

**\[java\]** [view plain][][copy][view plain][![在CODE上查看代码片][CODE]][CODE_CODE][![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **public** **static** **boolean** getBit(**int** num, **int** i)\{  
2.      **int** result = num & (1<<i);  
3.     
4.      **return** (result == 0)；  
5.  \}

*例如，获得数字10的第2位：*

i=1, n=10  
1<<1= 10  
1010&10=10  
10 is not 0, so return true;

经典题目：

[1) Single Number][1_ Single Number]  
[1) Single Number II][1_ Single Number II]  
[2) Maximum Binary Gap][2_ Maximum Binary Gap]  
[3) Number of 1 Bits ][3_ Number of 1 Bits]  
[4) Reverse Bits ][4_ Reverse Bits]  
[5) Repeated DNA Sequences][47_ Repeated DNA Sequences]  
[6) Bitwise AND of Numbers Range][6_ Bitwise AND of Numbers Range]

9. 概率问题

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

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

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

**\[java\]** [view plain][][copy][view plain][![在CODE上查看代码片][CODE]][CODE_CODE][![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **public** **static** **double** caculateProbability(**int** n)\{  
2.      **double** x = 1;   
3.     
4.      **for**(**int** i=0; i<n; i++)\{  
5.          x \*=  (365.0\-i)/365.0;  
6.      \}  
7.     
8.      **double** pro = Math.round((1\-x) \* 100);  
9.      **return** pro/100;  
10. \}

calculateProbability(50) = 0.97

经典题目：

[桶中取球][Link 1]

10. 排列组合

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

例1：

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

例2：

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

经典题目：

[1) Permutations][1_ Permutations]  
[2) Permutations II ][2_ Permutations II]  
[3) Permutation Sequence][3_ Permutation Sequence]  
[4) Generate Parentheses][4_ Generate Parentheses]

11. 其他类型的题目

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

经典题目:

[1) Reverse Integer][1_ Reverse Integer]  
[2) Palindrome Number][2_ Palindrome Number]  
[3) Pow(x,n)][3_ Pow_x_n]  
[4) Subsets][4_ Subsets]  
[5) Subsets II][5_ Subsets II]  
[6) Fraction to Recurring Decimal][6_ Fraction to Recurring Decimal] \[Google\]  
[7) Excel Sheet Column Number][7_ Excel Sheet Column Number]  
[8) Excel Sheet Column Title ][8_ Excel Sheet Column Title]  
[9) Factorial Trailing Zeroes][9_ Factorial Trailing Zeroes]  
[10) Happy Number][10_ Happy Number]

[11) Count Primes][11_ Count Primes]

http://blog.csdn.net/duanjiefei/article/details/46461049

> ## 欢迎关注公众号： ##
> 
> # ![70][] #

[view plain]: http://blog.csdn.net/hnulwt/article/details/45822517#
[CODE]: https://code.csdn.net/assets/CODE_ico.png
[CODE_CODE]: https://code.csdn.net/snippets/669332
[ico_fork.svg]: https://code.csdn.net/assets/ico_fork.svg
[ico_fork.svg 1]: https://code.csdn.net/snippets/669332/fork
[0_ Rotate Array]: http://www.programcreek.com/2015/03/rotate-array-in-java/
[1_ Evaluate Reverse Polish Notation _Stack]: http://www.programcreek.com/2012/12/leetcode-evaluate-reverse-polish-notation/
[2_ Longest Palindromic Substring _DP]: http://www.programcreek.com/2013/12/leetcode-solution-of-longest-palindromic-substring-java/
[3_ Word Break _DP]: http://www.programcreek.com/2012/12/leetcode-solution-word-break/
[3_ Word Break II _DP_ DFS]: http://www.programcreek.com/2014/03/leetcode-word-break-ii-java/
[4_ Word Ladder _Queue_ BFS]: http://www.programcreek.com/2012/12/leetcode-word-ladder/
[5_ Median of Two Sorted Arrays]: http://www.programcreek.com/2012/12/leetcode-median-of-two-sorted-arrays-java/
[6_ Regular Expression Matching]: http://www.programcreek.com/2012/12/leetcode-regular-expression-matching-in-java/
[7_ Merge Intervals]: http://www.programcreek.com/2012/12/leetcode-merge-intervals/
[8_ Insert Interval]: http://www.programcreek.com/2012/12/leetcode-insert-interval/
[9_ Two Sum]: http://www.programcreek.com/2012/12/leetcode-solution-of-two-sum-in-java/
[9_ Two Sum II _ Input array is sorted]: http://www.programcreek.com/2014/03/two-sum-ii-input-array-is-sorted-java/
[9_ Two Sum III - Data structure design]: http://www.programcreek.com/2014/03/two-sum-iii-data-structure-design-java/
[9_ 3Sum]: http://www.programcreek.com/2012/12/leetcode-3sum/
[9_ 4Sum]: http://www.programcreek.com/2013/02/leetcode-4sum-java/
[10_ 3Sum Closest]: http://www.programcreek.com/2013/02/leetcode-3sum-closest-java/
[11_ String to Integer]: http://www.programcreek.com/2012/12/leetcode-string-to-integer-atoi/
[12_ Merge Sorted Array]: http://www.programcreek.com/2012/12/leetcode-merge-sorted-array-java/
[13_ Valid Parentheses]: http://www.programcreek.com/2012/12/leetcode-valid-parentheses-java/
[14_ Implement strStr]: http://www.programcreek.com/2012/12/leetcode-implement-strstr-java/
[15_ Set Matrix Zeroes]: http://www.programcreek.com/2012/12/leetcode-set-matrix-zeroes-java/
[16_ Search Insert Position]: http://www.programcreek.com/2013/01/leetcode-search-insert-position/
[17_ Longest Consecutive Sequence]: http://www.programcreek.com/2013/01/leetcode-longest-consecutive-sequence-java/
[18_ Valid Palindrome]: http://www.programcreek.com/2013/01/leetcode-valid-palindrome-java/
[19_ Spiral Matrix]: http://www.programcreek.com/2013/01/leetcode-spiral-matrix-java/
[20_ Search a 2D Matrix]: http://www.programcreek.com/2013/01/leetcode-search-a-2d-matrix-java/
[21_ Rotate Image]: http://www.programcreek.com/2013/01/leetcode-rotate-image-java/
[22_ Triangle]: http://www.programcreek.com/2013/01/leetcode-triangle-java/
[23_ Distinct Subsequences Total]: http://www.programcreek.com/2013/01/leetcode-distinct-subsequences-total-java/
[24_ Maximum Subarray]: http://www.programcreek.com/2013/02/leetcode-maximum-subarray-java/
[24_ Maximum Product Subarray]: http://www.programcreek.com/2014/03/leetcode-maximum-product-subarray-java/
[25_ Remove Duplicates from Sorted Array]: http://www.programcreek.com/2013/01/leetcode-remove-duplicates-from-sorted-array-java/
[26_ Remove Duplicates from Sorted Array II]: http://www.programcreek.com/2013/01/leetcode-remove-duplicates-from-sorted-array-ii-java/
[27_ Longest Substring Without Repeating Characters]: http://www.programcreek.com/2013/02/leetcode-longest-substring-without-repeating-characters-java/
[28_ Longest Substring that contains 2 unique characters]: http://www.programcreek.com/2013/02/longest-substring-which-contains-2-unique-characters/
[29_ Palindrome Partitioning]: http://www.programcreek.com/2013/03/leetcode-palindrome-partitioning-java/
[29_ Palindrome Partitioning II]: http://www.programcreek.com/2014/04/leetcode-palindrome-partitioning-ii-java/
[30_ Reverse Words in a String]: http://www.programcreek.com/2014/02/leetcode-reverse-words-in-a-string-java/
[31_ Find Minimum in Rotated Sorted Array]: http://www.programcreek.com/2014/02/leetcode-find-minimum-in-rotated-sorted-array/
[31_ Find Minimum in Rotated Sorted Array II]: http://www.programcreek.com/2014/03/leetcode-find-minimum-in-rotated-sorted-array-ii-java/
[32_ Find Peak Element]: http://www.programcreek.com/2014/02/leetcode-find-peak-element/
[33_ Min Stack]: http://www.programcreek.com/2014/02/leetcode-min-stack-java/
[34_ Majority Element]: http://www.programcreek.com/2014/02/leetcode-majority-element-java/
[35_ Combination Sum _DFS]: http://www.programcreek.com/2014/02/leetcode-combination-sum-java/
[35_ Combination Sum II _DFS]: http://www.programcreek.com/2014/04/leetcode-combination-sum-ii-java/
[36_ Best Time to Buy and Sell Stock]: http://www.programcreek.com/2014/02/leetcode-best-time-to-buy-and-sell-stock-java/
[36_ Best Time to Buy and Sell Stock II]: http://www.programcreek.com/2014/02/leetcode-best-time-to-buy-and-sell-stock-ii-java/
[36_ Best Time to Buy and Sell Stock III _DP]: http://www.programcreek.com/2014/02/leetcode-best-time-to-buy-and-sell-stock-iii-java/
[36_ Best Time to Buy and Sell Stock IV _DP]: http://www.programcreek.com/2014/03/leetcode-best-time-to-buy-and-sell-stock-iv-java/
[37_ Longest Common Prefix]: http://www.programcreek.com/2014/02/leetcode-longest-common-prefix-java/
[38_ Largest Number]: http://www.programcreek.com/2014/02/leetcode-largest-number-java/
[39_ Combinations _DFS]: http://www.programcreek.com/2014/03/leetcode-combinations-java/
[40_ Compare Version Numbers]: http://www.programcreek.com/2014/03/leetcode-compare-version-numbers-java/
[41_ Gas Station]: http://www.programcreek.com/2014/03/leetcode-gas-station-java/
[42_ Candy]: http://www.programcreek.com/2014/03/leetcode-candy-java/
[43_ Jump Game]: http://www.programcreek.com/2014/03/leetcode-jump-game-java/
[44_ Pascal_s Triangle]: http://www.programcreek.com/2014/03/leetcode-pascals-triangle-java/
[44_ Pascal_s Triangle II]: http://www.programcreek.com/2014/04/leetcode-pascals-triangle-ii-java/
[45_ Container With Most Water]: http://www.programcreek.com/2014/03/leetcode-container-with-most-water-java/
[46_ Count and Say]: http://www.programcreek.com/2014/03/leetcode-count-and-say-java/
[47_ Repeated DNA Sequences]: http://www.programcreek.com/2014/03/leetcode-repeated-dna-sequences-java/
[48_ House Robber]: http://www.programcreek.com/2014/03/leetcode-house-robber-java/
[49_ Dungeon Game _DP]: http://www.programcreek.com/2014/03/leetcode-dungeon-game-java/
[50_ Number of Islands _DFS_BFS]: http://www.programcreek.com/2014/04/leetcode-number-of-islands-java/
[51_ Surrounded Regions _BFS]: http://www.programcreek.com/2014/04/leetcode-surrounded-regions-java/
[52_ Max Points on a Line]: http://www.programcreek.com/2014/04/leetcode-max-points-on-a-line-java/
[53_ Letter Combinations of a Phone Number _DFS]: http://www.programcreek.com/2014/04/leetcode-letter-combinations-of-a-phone-number-java/
[54_ Remove Element]: http://www.programcreek.com/2014/04/leetcode-remove-element-java/
[55_ Anagrams]: http://www.programcreek.com/2014/04/leetcode-anagrams-java/
[56_ Search for a Range]: http://www.programcreek.com/2014/04/leetcode-search-for-a-range-java/
[57_ Simplify Path]: http://www.programcreek.com/2014/04/leetcode-simplify-path-java/
[58_ Isomorphic Strings]: http://www.programcreek.com/2014/05/leetcode-isomorphic-strings-java/
[59_ Minimum Size Subarray Sum]: http://www.programcreek.com/2014/05/leetcode-minimum-size-subarray-sum-java/
[60_ Minimum Path Sum _DP]: http://www.programcreek.com/2014/05/leetcode-minimum-path-sum-java/
[61_ Unique Paths _DP]: http://www.programcreek.com/2014/05/leetcode-unique-paths-java/
[1_ Add Two Numbers]: http://www.programcreek.com/2012/12/add-two-numbers/
[2_ Reorder List]: http://www.programcreek.com/2013/12/in-place-reorder-a-singly-linked-list-in-java/
[3_ Linked List Cycle]: http://www.programcreek.com/2012/12/leetcode-linked-list-cycle/
[4_ Copy List with Random Pointer]: http://www.programcreek.com/2012/12/leetcode-copy-list-with-random-pointer/
[5_ Merge Two Sorted Lists]: http://www.programcreek.com/2012/12/leetcode-merge-two-sorted-lists-java/
[6_ Merge k Sorted Lists]: http://www.programcreek.com/2013/02/leetcode-merge-k-sorted-lists-java/
[7_ Remove Duplicates from Sorted List]: http://www.programcreek.com/2013/01/leetcode-remove-duplicates-from-sorted-list/
[8_ Partition List]: http://www.programcreek.com/2013/02/leetcode-partition-list-java/
[9_ LRU Cache]: http://www.programcreek.com/2013/03/leetcode-lru-cache-java/
[10_ Intersection of Two Linked Lists]: http://www.programcreek.com/2014/02/leetcode-intersection-of-two-linked-lists-java/
[11_ Remove Linked List Elements]: http://www.programcreek.com/2014/04/leetcode-remove-linked-list-elements-java/
[12_ Swap Nodes in Pairs]: http://www.programcreek.com/2014/04/leetcode-swap-nodes-in-pairs-java/
[13_ Reverse Linked List]: http://www.programcreek.com/2014/05/leetcode-reverse-linked-list-java/
[1_ Binary Tree Preorder Traversal]: http://www.programcreek.com/2012/12/leetcode-solution-for-binary-tree-preorder-traversal-in-java/
[2_ Binary Tree Inorder Traversal]: http://www.programcreek.com/2012/12/leetcode-solution-of-binary-tree-inorder-traversal-in-java/
[3_ Binary Tree Postorder Traversal]: http://www.programcreek.com/2012/12/leetcode-solution-of-iterative-binary-tree-postorder-traversal-in-java/
[4_ Binary Tree Level Order Traversal]: http://www.programcreek.com/2014/04/leetcode-binary-tree-level-order-traversal-java/
[4_ Binary Tree Level Order Traversal II]: http://www.programcreek.com/2014/04/leetcode-binary-tree-level-order-traversal-ii-java/
[5_ Validate Binary Search Tree]: http://www.programcreek.com/2012/12/leetcode-validate-binary-search-tree-java/
[6_ Flatten Binary Tree to Linked List]: http://www.programcreek.com/2013/01/leetcode-flatten-binary-tree-to-linked-list/
[7_ Path Sum _DFS or BFS]: http://www.programcreek.com/2013/01/leetcode-path-sum/
[7_ Path Sum II _DFS]: http://www.programcreek.com/2014/05/leetcode-path-sum-ii-java/
[8_ Construct Binary Tree from Inorder and Postorder Traversal]: http://www.programcreek.com/2013/01/construct-binary-tree-from-inorder-and-postorder-traversal/
[9_ Convert Sorted Array to Binary Search Tree]: http://www.programcreek.com/2013/01/leetcode-convert-sorted-array-to-binary-search-tree-java/
[10_ Convert Sorted List to Binary Search Tree]: http://www.programcreek.com/2013/01/leetcode-convert-sorted-list-to-binary-search-tree-java/
[11_ Minimum Depth of Binary Tree]: http://www.programcreek.com/2013/02/leetcode-minimum-depth-of-binary-tree-java/
[12_ Binary Tree Maximum Path Sum]: http://www.programcreek.com/2013/02/leetcode-binary-tree-maximum-path-sum-java/
[13_ Balanced Binary Tree]: http://www.programcreek.com/2013/02/leetcode-balanced-binary-tree-java/
[14_ Symmetric Tree]: http://www.programcreek.com/2014/03/leetcode-symmetric-tree-java/
[15_ Binary Search Tree Iterator]: http://www.programcreek.com/2014/04/leetcode-binary-search-tree-iterator-java/
[16_ Binary Tree Right Side View]: http://www.programcreek.com/2014/04/leetcode-binary-tree-right-side-view-java/
[17_ Implement Trie _Prefix Tree]: http://www.programcreek.com/2014/05/leetcode-implement-trie-prefix-tree-java/
[18_ Add and Search Word - Data structure design _DFS]: http://www.programcreek.com/2014/05/leetcode-add-and-search-word-data-structure-design-java/
[1_ Clone Graph]: http://www.programcreek.com/2012/12/leetcode-clone-graph-java/
[2_ Course Schedule _DFS_BFS]: http://www.programcreek.com/2014/05/leetcode-course-schedule-java/
[1_ Mergesort]: http://www.programcreek.com/2012/11/leetcode-solution-merge-sort-linkedlist-in-java/
[2_ Quicksort]: http://www.programcreek.com/2012/11/quicksort-array-in-java/
[3_ InsertionSort]: http://www.programcreek.com/2012/11/leetcode-solution-sort-a-linked-list-using-insertion-sort-in-java/
[4_ Maximum Gap _Bucket Sort]: http://www.programcreek.com/2014/03/leetcode-maximum-gap-java/
[Recursion vs Iteration]: http://www.programcreek.com/2012/10/iteration-vs-recursion-in-java/
[1_ Edit Distance]: http://www.programcreek.com/2013/12/edit-distance-in-java/
[1_ Single Number]: http://www.programcreek.com/2012/12/leetcode-solution-of-single-number-in-java/
[1_ Single Number II]: http://www.programcreek.com/2014/03/leetcode-single-number-ii-java/
[2_ Maximum Binary Gap]: http://www.programcreek.com/2013/02/twitter-codility-problem-max-binary-gap/
[3_ Number of 1 Bits]: http://www.programcreek.com/2014/03/leetcode-number-of-1-bits-java/
[4_ Reverse Bits]: http://www.programcreek.com/2014/03/leetcode-reverse-bits-java/
[6_ Bitwise AND of Numbers Range]: http://www.programcreek.com/2014/04/leetcode-bitwise-and-of-numbers-range-java/
[Link 1]: http://blog.csdn.net/u012333003/article/details/17262923
[1_ Permutations]: http://www.programcreek.com/2013/02/leetcode-permutations-java/
[2_ Permutations II]: http://www.programcreek.com/2013/02/leetcode-permutations-ii-java/
[3_ Permutation Sequence]: http://www.programcreek.com/2013/02/leetcode-permutation-sequence-java/
[4_ Generate Parentheses]: http://www.programcreek.com/2014/01/leetcode-generate-parentheses-java/
[1_ Reverse Integer]: http://www.programcreek.com/2012/12/leetcode-reverse-integer/
[2_ Palindrome Number]: http://www.programcreek.com/2013/02/leetcode-palindrome-number-java/
[3_ Pow_x_n]: http://www.programcreek.com/2012/12/leetcode-powx-n/
[4_ Subsets]: http://www.programcreek.com/2013/01/leetcode-subsets-java/
[5_ Subsets II]: http://www.programcreek.com/2013/01/leetcode-subsets-ii-java/
[6_ Fraction to Recurring Decimal]: http://www.programcreek.com/2014/03/leetcode-fraction-to-recurring-decimal-java/
[7_ Excel Sheet Column Number]: http://www.programcreek.com/2014/03/leetcode-excel-sheet-column-number-java/
[8_ Excel Sheet Column Title]: http://www.programcreek.com/2014/03/leetcode-excel-sheet-column-title-java/
[9_ Factorial Trailing Zeroes]: http://www.programcreek.com/2014/04/leetcode-factorial-trailing-zeroes-java/
[10_ Happy Number]: http://www.programcreek.com/2014/04/leetcode-happy-number-java/
[11_ Count Primes]: http://www.programcreek.com/2014/04/leetcode-count-primes-java/
[70]: /images/20220615/7c4a50d6496c4e9094fc1c15a05bd84b.png