20190318

code/lc104.java

@@ -19,8 +19,7 @@ public class lc104 {
         TreeNode(int x) { val = x; }
     }
     public int maxDepth(TreeNode root) {
-        if(root==null)
-            return 0;
+        if(root==null) return 0;
         return Math.max(maxDepth(root.left),maxDepth(root.right)) + 1;
     }
 

code/lc113.java

@@ -8,7 +8,7 @@ import java.util.List;
  * 难度：Medium
  * 分类：Tree, Depth-first Search
  * 思路：回溯，注意因为节点上可能正值，可能负值，所以不能剪枝
- * Tips：
+ * Tips：lc124
  */
 public class lc113 {
     public class TreeNode {

code/lc124.java

@@ -6,6 +6,7 @@ package code;
  * 分类：Tree, Depth-first Search
  * 思路：因为二叉树只有两个节点，一条路径可以想象成倒V字，从低层的某个节点一路向上，到达一个顶点，再一路向下，理解了这一点，整道题就好解了。
  * Tips：用了一个全局变量存储最后结果，因为函数返回的是直线路径上的最优解，而不是V字路径最优解
+ *      lc133
  */
 public class lc124 {
     public class TreeNode {

code/lc127.java

@@ -6,6 +6,7 @@ package code;
  * 分类：Breadth-first Search
  * 思路：bfs, 利用双向bfs可以加快搜索https://leetcode.com/problems/word-ladder/discuss/40711/Two-end-BFS-in-Java-31ms.
  * Tips：拓扑排序，很经典的BFS，好好看看
+ *      lc207
  */
 import java.util.ArrayDeque;
 import java.util.List;

code/lc139.java

@@ -6,6 +6,7 @@ package code;
  * 分类：Dynamic Programming
  * 思路：动态规划
  * Tips：巧妙的方法，防止了复杂的操作，通过遍历之前计算出来的结果
+ *       lc140
  */
 import java.util.List;
 

code/lc141.java

@@ -5,6 +5,7 @@ package code;
  * 难度：Easy
  * 分类：Linked List, Two Pointers
  * 思路：快慢指针
+ *      lc142
  */
 public class lc141 {
     public class ListNode {

code/lc162.java

@@ -4,7 +4,7 @@ package code;
  * 题意：找出数组中任意一个山顶点，时间复杂度O(lg(n))，山顶点指该数左右两边都的数都小于他
  * 难度：Medium
  * 分类：Array, Binary Search
- * 思路：二分查找，想好左右两边递归判断。只有nums[mid]<nums[mid+1]，说名右半边就存在峰值
+ * 思路：二分查找，想好左右两边递归判断。只要nums[mid]<nums[mid+1]，说明右半边就存在峰值
  * Tips：
  */
 public class lc162 {

code/lc169.java

@@ -4,14 +4,14 @@ package code;
  * 题意：数组中有一个元素出现次数 >len/2 ,找出这个数
  * 难度：Easy
  * 分类：Array, Divide and Conquer, Bit Maniputation
- * 思路：很多种方法， Hashmap 是 O(n), O(n)的。 快排是O(log(n)), O(1)的。最巧妙的办法是  O(n), O(1) 的如下。
+ * 思路：很多种方法， Hashmap 是 O(n), O(n)的。 快排是O(n), O(1)的。最巧妙的办法是  O(n), O(1) 的如下。
  * Tips：之所以能够 O(n), O(1) 是因为题目已经给定了数组中一定能找到这个数，该方法充分利用了这一点
  */
 public class lc169 {
     public int majorityElement(int[] nums) {
         int res = nums[0];
         int count = 1;
-        for (int i = 1; i < nums.length ; i++) {
+        for (int i = 1; i < nums.length ; i++) {    // 摩尔投票法，看这个数出现了几次
             if(nums[i]!=res)    // 不是这个数就 --， ==0就用当前数替换res
                 count--;
             else

code/lc189.java

@@ -4,7 +4,7 @@ package code;
  * 题意：数组向后移几位，超出末尾的补到前边
  * 难度：Easy
  * 分类：Array
- * 思路：一种换状替换，别忘了可能是多个环。
+ * 思路：一种环状替换，别忘了可能是多个环。
  *      reverse 的方法，先整体反转，再按照k划分成两个数组分别反转
  * Tips：
  */

code/lc198.java

@@ -6,6 +6,7 @@ package code;
  * 分类：Dynamic Programming
  * 思路：经典的dp题，记一下
  * Tips：时间复杂度为 O(n)
+ *       lc213
  */
 public class lc198 {
     public int rob(int[] nums) {

code/lc207.java

@@ -9,6 +9,7 @@ import java.util.*;
  * 分类：Depth-first Search, Breadth-first Search, Graph, Topology Sort
  * 思路：两种方法，一种BFS拓扑排序(每个节点，先求出入度)，另一种DFS找是否有环
  * Tips：很经典的题，拓扑排序，判断图是否有环的DFS
+ *       lc127 lc210
  */
 public class lc207 {
     public static void main(String[] args) {

code/lc215.java

@@ -29,11 +29,8 @@ public class lc215 {
             nums[right] = nums[left];
         }
         nums[left] = cur;
-        if(left==k-1)
-            return cur;
-        else if(left>k-1)
-            return quickSort(nums, origin_l, left-1, k);
-        else
-            return quickSort(nums, left+1, origin_r, k);
+        if(left==k-1) return cur;
+        else if(left>k-1) return quickSort(nums, origin_l, left-1, k);
+        else return quickSort(nums, left+1, origin_r, k);
     }
 }

code/lc227.java

@@ -7,7 +7,7 @@ import java.util.Stack;
  * 题意：表达式计算
  * 难度：Medium
  * 分类：String
- * 思路：很巧妙的方法，每次遍历到下一个符号的时候，计算前一个符号的运算，泥面膜了复杂的逻辑。
+ * 思路：很巧妙的方法，每次遍历到下一个符号的时候，计算前一个符号的运算，避免了复杂的逻辑。
  *      + - 运算直接入栈，* / 运算则计算后将结果入栈，实现了 * / 优先运算
  * Tips：自己想的方法会非常麻烦。这个解法非常聪明。
  */

code/lc234.java

@@ -4,7 +4,7 @@ package code;
  * 题意：判断链表是否是回文的
  * 难度：Easy
  * 分类：LinkedList, Two Pointers
- * 思路：反转一般就行了，避免了空间开销
+ * 思路：反转一半就行了，避免了空间开销
  * Tips：很好的题，考了 Two Pointers, 还考了链表反转
  */
 public class lc234 {

code/lc84.java

@@ -11,7 +11,6 @@ import java.util.Stack;
  * Tips：和lc42做比较，都可以用栈或者dp来做. 很难，栈的操作很难想到.
  *       和lc42 dp作比较 和lc32栈做比较
  *       lc85
- *
  */
 public class lc84 {
     public static void main(String[] args) {