修改了notes

carpeventus · carpeventus · commit a3a7e1be3506 · 2019-06-12T00:23:43.000+08:00
diff --git a/code/offer/.idea/misc.xml b/code/offer/.idea/misc.xml
diff --git a/code/offer/.idea/vcs.xml b/code/offer/.idea/vcs.xml
diff --git a/code/offer/.idea/workspace.xml b/code/offer/.idea/workspace.xml
diff --git a/code/offer/src/Chap7/LastSameInBST.java b/code/offer/src/Chap7/LastSameInBST.java
@@ -7,7 +7,6 @@ public class LastSameInBST {
     private class Node {
         private Node left, right;
         private int val;
-
         public Node(int val) {
             this.val = val;
         }
diff --git a/notes/剑指offer面试题 52--两个链表的第一个公共结点.md b/notes/剑指offer面试题 52--两个链表的第一个公共结点.md
@@ -138,13 +138,13 @@ public class FirstPublicNode {
 
 ```java
 public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {
-    ListNode p1 = pHead1;
-    ListNode p2 = pHead2;
-    while (p1 != p2) {
-    p1 = (p1 == null ? pHead2 : p1.next);
-    p2 = (p2 == null ? pHead1 : p2.next);
-    }
-    return p1;
+  	ListNode p1 = pHead1;
+  	ListNode p2 = pHead2;
+  	while (p1 != p2) {
+    	p1 = (p1 == null ? pHead2 : p1.next);
+    	p2 = (p2 == null ? pHead1 : p2.next);
+  	}
+  	return p1;
 }
 ```
 
diff --git a/notes/剑指offer面试题10--斐波那契数列.md b/notes/剑指offer面试题10--斐波那契数列.md
@@ -35,15 +35,15 @@ public class Fibonacci {
 
 ```java
 public int fib2(int n) {
-    if (n <= 0) {
-    return 0;
-    }
+  	if (n <= 0) {
+    	return 0;
+  	}
 
-    if (n == 1) {
-    return 1;
-    }
+  	if (n == 1) {
+    	return 1;
+  	}
 
-    return fib2(n-1) +fib(n-2);
+  	return fib2(n-1) +fib(n-2);
 }
 ```
 
diff --git a/notes/剑指offer面试题14--剪绳子.md b/notes/剑指offer面试题14--剪绳子.md
@@ -95,4 +95,4 @@ public static int maxProductAfterCutting2(int length) {
 
 by @sunhaiyu
 
-2017.12.19
+2017.12.19
diff --git a/notes/剑指offer面试题15--二进制中1的个数.md b/notes/剑指offer面试题15--二进制中1的个数.md
@@ -8,15 +8,15 @@
 
 ```java
 public int numberOf1_2(int n) {
-    int count = 0;
-
-    while (n != 0) {
-    if ((n & 1) == 1) {
-        count++;
-    }
-        n = n >> 1;
-    }
-    return count;
+  	int count = 0;
+
+  	while (n != 0) {
+    	if ((n & 1) == 1) {
+      	count++;
+    	}
+    	n = n >> 1;
+  	}
+  	return count;
 }
 ```
 
diff --git a/notes/剑指offer面试题21--调整数组的顺序使奇数位于偶数前面.md b/notes/剑指offer面试题21--调整数组的顺序使奇数位于偶数前面.md
@@ -83,7 +83,7 @@ public class ReOrderArray {
             // 右到左找出第一个奇数
             while (pBegin < pEnd && !p.test(array[pEnd]))
                 pEnd--;
-           // 交换两个奇数和偶数，奇数被换到了前面，偶数换到了后面
+		   // 交换两个奇数和偶数，奇数被换到了前面，偶数换到了后面
             if (pBegin < pEnd) {
                 int temp = array[pBegin];
                 array[pBegin] = array[pEnd];
diff --git a/notes/剑指offer面试题27--对称的二叉树.md b/notes/剑指offer面试题27--对称的二叉树.md
@@ -1,4 +1,4 @@
-# 剑指offer面试题28--对称的二叉树
+# 剑指offer面试题27--对称的二叉树
 
 > ```
 > 请实现一个函数，用来判断一颗二叉树是不是对称的。注意，如果一个二叉树同此二叉树的镜像是同样的，定义其为对称的。
diff --git a/notes/剑指offer面试题39--数组中出现次数超过一半的数字.md b/notes/剑指offer面试题39--数组中出现次数超过一半的数字.md
@@ -91,20 +91,20 @@ select方法是通用的选择排名为k的元素，只要参数传入n / 2即
 
 ```java
 public int findNumMoreThanHalf(int[] array) {
-    if (array == null || array.length == 0) return 0;
-
-    int count = 1;
-    int result = array[0];
-    for (int i = 1; i < array.length; i++) {
-    if (count == 0) {
-        result = array[i];
-        count = 1;
-    }
-
-    else if (array[i] == result) count++;
-    else count--;
-    }
-    return checkMoreThanHalf(array, result);
+  	if (array == null || array.length == 0) return 0;
+
+  	int count = 1;
+  	int result = array[0];
+  	for (int i = 1; i < array.length; i++) {
+    	if (count == 0) {
+      	result = array[i];
+      	count = 1;
+    	}
+
+    	else if (array[i] == result) count++;
+    	else count--;
+  	}
+  	return checkMoreThanHalf(array, result);
 }
 ```
 
diff --git a/notes/剑指offer面试题48--最长不含重复字符串的子字符串.md b/notes/剑指offer面试题48--最长不含重复字符串的子字符串.md
@@ -35,53 +35,25 @@ public class LongestSubstring {
             // 字符第一次出现，或者d > f(i -1)
             if (preIndex == -1 || i - preIndex > curLen) curLen++;
             // d <= f(i -1) 
-            else curLen = i - preIndex;
+            else {
+                if (curLen > maxLen) maxLen = curLen;
+                curLen = i - preIndex;
+            }
             // 记录当前字符出现的位置
             position[str.charAt(i) - 'a'] = i;
-            if (curLen > maxLen) maxLen = curLen;
         }
+        if (curLen > maxLen) maxLen = curLen;
         return maxLen;
     }
 }
 
 ```
 
-用了一个数组position代替哈希表，记录'a'~'z'每个字符上次出现的位置，能以O(1)的时间完成，先要将position中的值全初始化为-1，因为上次出现的位置可能含有索引0。 curLen就是上面说到的$f(i -1)$。
+用了一个数组position代替哈希表，记录'a'~'z'每个字符上次出现的位置，能以O(1)的时间完成，先要将position中的值全初始化为-1，因为上次出现的位置可能含有索引0。 curLen就是上面说到的$f(i -1)$
 
-类似的解法。
+如果某个字符第一次出现，那么它上次出现的位置preIndex为-1。当前最长不重复子字符串直接加1。
 
-用一个全局preIndex表示重复字符的最远位置，或者说上一次出现重复字符的位置。
-
-还是上面的例子。
-
-- 当`d <= f(i-1)`，如bdcefgc，在当前c未出现时，preIndex是-1，因为还没有出现过重复字符，当前c出现后，有重复字符了，preIndex是索引2处的c。i - preIndex == 4就表示了以当前c结尾的最长不重复子串长度。
-- 当`d > f(i-1)`，如erabcdabr，当前r未出现时，上一个重复字符是b，其preIndex是3。当前r出现后，r上一次出现的位置是1，比较两者，显然b的上次出现位置靠右些，所以应该以b的preIndex为准（如果以r的preIndex为准，会将重复的b包含进去）
-
-综和以上两种情况，需要计算1）不计入当前字符时最近一个重复字符的上次出现位置，2）算上当前字符时，当前字符的上次出现位置。取这两者的最大值，即取两个位置中更靠后的位置。`preIndex = Math.max(preIndex, position[ch - 'a'])`，然后`i - preIndex`表示以位置i处字符结尾的最长不重复子串的长度。
-
-```java
-public class LongestSubstring {
-    public int findLongestSubstring(String str) {
-        int curLen = 0;
-        int maxLen = 0;
-        int preIndex = -1;
-        // 0~25表示a~z，position[0] = index,表明a上次出现在index处
-        int[] position = new int[26];
-        for (int i = 0; i < 26; i++) {
-            position[i] = -1;
-        }
-
-        for (int i = 0; i < str.length(); i++) {
-            preIndex = Math.max(preIndex, position[str.charAt(i) - 'a']);
-			curLen = i - preIndex;
-            // 记录当前字符出现的位置
-            position[str.charAt(i) - 'a'] = i;
-            maxLen = Math.max(curLen, maxLen);
-        }
-        return maxLen;
-    }
-}
-```
+只有else语句中curLen才可能变小，因此要即使保存到maxLen，因为这个curLen可能就是最长的。而且if语句中curLen++并没有和maxLen比较，所以除了循环后还要再和maxLen比较一次。
 
 ---
 
diff --git a/notes/剑指offer面试题51--在排序数组中查找数字.md b/notes/剑指offer面试题51--在排序数组中查找数字.md
@@ -1,4 +1,4 @@
-# 剑指offer面试题51--咋排序数组中查找数字
+# 剑指offer面试题51--在排序数组中查找数字
 
 >   ```
 >   统计一个数字在排序数组中出现的次数。
diff --git a/notes/剑指offer面试题53--数组中的逆序对.md b/notes/剑指offer面试题53--数组中的逆序对.md
@@ -1,4 +1,4 @@
-# 剑指offer面试题51--数组中的逆序对
+# 剑指offer面试题53--数组中的逆序对
 
 >   ```
 >   在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数.
diff --git a/notes/剑指offer面试题65--不用加减乘除做加法.md b/notes/剑指offer面试题65--不用加减乘除做加法.md
@@ -23,7 +23,7 @@
 
 ```
 
-可以看到十进制作加法可以细分为以上三步。那么对于二进制的加法呢？18的二进制是10010，6的二进制是110
+可以看到十进制作加法可以细分为以上三步。那么对于二进制的加法呢？18的二进制是10010，5的二进制是111
 
 ```text
   10010
diff --git a/notes/剑指offer面试题68--树中两个结点的最低公共祖先.md b/notes/剑指offer面试题68--树中两个结点的最低公共祖先.md
@@ -29,9 +29,9 @@ public class LastSameInBST {
         Node cur = root;
         while (cur != null) {
             if (cur.val < a.val && cur.val < b.val) {
-                cur = cur.right;
-            } else if (cur.val > a.val && cur.val > b.val) {
                 cur = cur.left;
+            } else if (cur.val > a.val && cur.val > b.val) {
+                cur = cur.right;
             } else {
                 return cur;
             }
diff --git a/notes/剑指offer面试题7--重建二叉树.md b/notes/剑指offer面试题7--重建二叉树.md
@@ -10,7 +10,7 @@
 
 一棵树从上到下可以分解成了左子树、根结点、右子树，对于每一棵子树，又可以继续分解下去...一直到树底的叶子结点。相反，树的构建是从下到上的顺序，叶子结点可以看做最小的子树，这些子树的根结点成为其他结点的左右子结点，于是产生了更大的子树，这些子树继续成为上层结点的左右子结点....一直到根结点的做右子结点也确定下来。
 
-关键是要找到每棵树的根结点，**前序遍历的第一个结点就是树的根结点；在中序遍历里找到这个结点，其左边的结点都是根结点的左子树，其右边的结点都是根结点的右子树。假如根结点左边有M个结点，那么在前序序列中，根结点后的M个结点也是属于根结点的左子树的。前序序列中余下的后面的结点自然属于根结点的右子树。**这样就可以把中序遍历的数组从根结点处分解成左右子树（对应的有两个子数组），然后递归地对这两个子数组执行同样的操作。现在重点是要在子数组中找到根结点——它依然是数组的第一个元素！
+关键是要找到每棵树的根结点，**前序遍历的第一个结点就是树的根结点；在中序遍历里找到这个结点，其左边的结点都是根结点的左子树，其右边的结点都是根结点的右子树。假如根结点左边有M个结点，那么在前序序列中，根结点后的M个结点也是属于根结点的左子树的。前序序列中余下的后面的结点自然属于根结点的右子树**。这样就可以把中序遍历的数组从根结点处分解成左右子树（对应的有两个子数组），然后递归地对这两个子数组执行同样的操作。现在重点是要在子数组中找到根结点——它依然是数组的第一个元素！
 
 比如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}。前序序列可知根结点是1，于是从中序序列可知，{4, 7, 2}属于根结点1的左子树，有3个结点；{5, 3 ,8, 6}属于根结点1的右子树。回到前序序列，除开第一个根结点，其后3个结点{2, 4, 7}就是左子树，余下的{3, 5, 6 ,8}是右子树。按照这些关系可以精确地将数组分解成两个子数组，递归地对两个数组进行同样的操作即可。
 

Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,6 @@ public class LastSameInBST {`
`7`	`7`	`private class Node {`
`8`	`8`	`private Node left, right;`
`9`	`9`	`private int val;`
`10`		`-`
`11`	`10`	`public Node(int val) {`
`12`	`11`	`this.val = val;`
`13`	`12`	`}`
Original file line number	Diff line number	Diff line change
`@@ -95,4 +95,4 @@ public static int maxProductAfterCutting2(int length) {`
`95`	`95`
`96`	`96`	`by @sunhaiyu`
`97`	`97`
`98`		`-2017.12.19`
	`98`	`+2017.12.19`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-# 剑指offer面试题28--对称的二叉树`
	`1`	`+# 剑指offer面试题27--对称的二叉树`
`2`	`2`
`3`	`3`	> ```
`4`	`4`	`> 请实现一个函数，用来判断一颗二叉树是不是对称的。注意，如果一个二叉树同此二叉树的镜像是同样的，定义其为对称的。`