diff --git a/code/lc104.java b/code/lc104.java
index 681240c6918bacbe3b43c48e9830d731d9b938ba..866811b214b850ab306ebc6b16eef326df9dea73 100644
--- a/code/lc104.java
+++ b/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;
     }
 
diff --git a/code/lc113.java b/code/lc113.java
index 5cfbc7de90b778ea7a29ae665d94e129393abe0b..6d555e292c352163b5f038ecef7984dc3c1f753b 100644
--- a/code/lc113.java
+++ b/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 {
diff --git a/code/lc124.java b/code/lc124.java
index ebe3c686e07cadfdaa70df033bb724675d56ce1a..3546ba7cc8bebcc564c65813f4ed29875f72d416 100644
--- a/code/lc124.java
+++ b/code/lc124.java
@@ -6,6 +6,7 @@ package code;
  * 分类：Tree, Depth-first Search
  * 思路：因为二叉树只有两个节点，一条路径可以想象成倒V字，从低层的某个节点一路向上，到达一个顶点，再一路向下，理解了这一点，整道题就好解了。
  * Tips：用了一个全局变量存储最后结果，因为函数返回的是直线路径上的最优解，而不是V字路径最优解
+ *      lc133
  */
 public class lc124 {
     public class TreeNode {
diff --git a/code/lc127.java b/code/lc127.java
index a13e958f0decf75416e577d4fddea88a49e4d798..4d0d365b7f1dffd04d3431abd17e9727cf047b87 100644
--- a/code/lc127.java
+++ b/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;
diff --git a/code/lc139.java b/code/lc139.java
index 520669cc5336ae6e78559dae75ad30d0bf257442..1e056637d7fb341c9c8263c93de942eb87fd3bb0 100644
--- a/code/lc139.java
+++ b/code/lc139.java
@@ -6,6 +6,7 @@ package code;
  * 分类：Dynamic Programming
  * 思路：动态规划
  * Tips：巧妙的方法，防止了复杂的操作，通过遍历之前计算出来的结果
+ *       lc140
  */
 import java.util.List;
 
diff --git a/code/lc141.java b/code/lc141.java
index a7f9a5237adc3b71e1c9f8a5a16d7239106eef8e..1f8bf71edf569dace8539060faa1ee5d4cc03b67 100644
--- a/code/lc141.java
+++ b/code/lc141.java
@@ -5,6 +5,7 @@ package code;
  * 难度：Easy
  * 分类：Linked List, Two Pointers
  * 思路：快慢指针
+ *      lc142
  */
 public class lc141 {
     public class ListNode {
diff --git a/code/lc162.java b/code/lc162.java
index 66389e641aad60ca791189a98cea546e690757e6..7f699c778c0b176c70820876e4bdc6aa73df882d 100644
--- a/code/lc162.java
+++ b/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 {
diff --git a/code/lc169.java b/code/lc169.java
index 68c456bba3106f19702b06777d1b97c46551750c..c9f43c37343e32e46a3f65a222b990ae5ed7704b 100644
--- a/code/lc169.java
+++ b/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
diff --git a/code/lc189.java b/code/lc189.java
index 26e351923d0b776ff7a02522c7c6a514cbe5b9e9..80fc95cea1cb1881f05b22229caf09789b616ba3 100644
--- a/code/lc189.java
+++ b/code/lc189.java
@@ -4,7 +4,7 @@ package code;
  * 题意：数组向后移几位，超出末尾的补到前边
  * 难度：Easy
  * 分类：Array
- * 思路：一种换状替换，别忘了可能是多个环。
+ * 思路：一种环状替换，别忘了可能是多个环。
  *      reverse 的方法，先整体反转，再按照k划分成两个数组分别反转
  * Tips：
  */
diff --git a/code/lc198.java b/code/lc198.java
index eda86fe3dda557c5edaefeecb19f230fc256aa49..499a7767f0725bbc18e162918e055bf4d84cb23f 100644
--- a/code/lc198.java
+++ b/code/lc198.java
@@ -6,6 +6,7 @@ package code;
  * 分类：Dynamic Programming
  * 思路：经典的dp题，记一下
  * Tips：时间复杂度为 O(n)
+ *       lc213
  */
 public class lc198 {
     public int rob(int[] nums) {
diff --git a/code/lc207.java b/code/lc207.java
index bbc3d8e585b3b845e404095398cc18a893e87e46..8e7f0757a65350fac90c3da47981871499c0e3f3 100644
--- a/code/lc207.java
+++ b/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) {
diff --git a/code/lc215.java b/code/lc215.java
index 6daf558e37ce7a9427b173b3043ec16799155713..d46c3d03024015194c5578069b02859b1af96a08 100644
--- a/code/lc215.java
+++ b/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);
     }
 }
diff --git a/code/lc227.java b/code/lc227.java
index 66557778795908040ebd5d917ec7228634e08270..693b2962f7135b88961c4d3e613cd5b5bf69c64a 100644
--- a/code/lc227.java
+++ b/code/lc227.java
@@ -7,7 +7,7 @@ import java.util.Stack;
  * 题意：表达式计算
  * 难度：Medium
  * 分类：String
- * 思路：很巧妙的方法，每次遍历到下一个符号的时候，计算前一个符号的运算，泥面膜了复杂的逻辑。
+ * 思路：很巧妙的方法，每次遍历到下一个符号的时候，计算前一个符号的运算，避免了复杂的逻辑。
  *      + - 运算直接入栈，* / 运算则计算后将结果入栈，实现了 * / 优先运算
  * Tips：自己想的方法会非常麻烦。这个解法非常聪明。
  */
diff --git a/code/lc234.java b/code/lc234.java
index 7c628843ef6a44cfcbddcc48d4324c5b6149eec8..012f87e475350e009d56d23c540aa5e055b11d93 100644
--- a/code/lc234.java
+++ b/code/lc234.java
@@ -4,7 +4,7 @@ package code;
  * 题意：判断链表是否是回文的
  * 难度：Easy
  * 分类：LinkedList, Two Pointers
- * 思路：反转一般就行了，避免了空间开销
+ * 思路：反转一半就行了，避免了空间开销
  * Tips：很好的题，考了 Two Pointers, 还考了链表反转
  */
 public class lc234 {
diff --git a/code/lc84.java b/code/lc84.java
index 7a4fc6a9439268a30b79161ea8fe1417e41f3e9f..df5eca9775c0196add243221b0dd6059f5dfb8dc 100644
--- a/code/lc84.java
+++ b/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) {