Merge pull request #26 from coderhare/main

剑指offer3，lc001, 027, 209更新cpp代码

animation-simulation/二叉树/二叉树的前序遍历(栈).md

@@ -26,7 +26,7 @@
 
 我们都知道栈的特性是先进后出，我们借助栈来帮助我们完成前序遍历的时候。
 
-则需要注意的一点是，我们应该先将右子节点入栈，再将左子节点入栈。
+则需要注意的一点是，我们应该`先将右子节点入栈，再将左子节点入栈`。
 
 这样出栈时，则会先出左节点，再出右子节点，则能够完成树的前序遍历。
 
@@ -34,7 +34,7 @@
 
 ![](https://img-blog.csdnimg.cn/20210512205822221.gif)
 
-我们用一句话对上图进行总结，当栈不为空时，栈顶元素出栈，如果其右孩子不为空，则右孩子入栈，其左孩子不为空，则左孩子入栈。还有一点需要注意的是，我们和层序遍历一样，需要先将 root 节点进行入栈，然后再执行 while 循环。
+我们用一句话对上图进行总结，`当栈不为空时，栈顶元素出栈，如果其右孩子不为空，则右孩子入栈，其左孩子不为空，则左孩子入栈`。还有一点需要注意的是，我们和层序遍历一样，需要先将 root 节点进行入栈，然后再执行 while 循环。
 
 看到这里你已经能够自己编写出代码了，不信你去试试。
 
@@ -69,7 +69,105 @@ class Solution {
 
 ### Morris
 
-Morris 遍历利用树的左右孩子为空（大量空闲指针），实现空间开销的极限缩减。这个遍历方法，稍微难理解一些，不过结合动图，也就一目了然啦，各位系好安全带，我们要发车啦。
+Morris 遍历利用树的左右孩子为空（大量空闲指针），实现空间开销的极限缩减。这个遍历方法，稍微有那么一丢丢难理解，不过结合动图，也就一目了然啦，下面我们先看动画吧。
 
 
 
+看完视频，是不是感觉自己搞懂了，又感觉自己没搞懂，哈哈，咱们继续往下看。
+
+![image](https://cdn.jsdelivr.net/gh/tan45du/test@master/image.1u3at0ckvn34.png)
+
+我们之前说的，Morris 遍历利用了`树中大量空闲指针的特性`，我们需要`找到当前节点的左子树中的最右边的叶子节点`，将该叶子节点的 right 指向当前节点。例如当前节点为2，其左子树中的最右节点为 9 ，则在 9 节点添加一个 right 指针指向 2。
+
+其实上图中的 Morris 遍历遵循两个原则，我们在动画中也能够得出。 
+
+1. 当 p1.left == null 时，p1 = p1.right。(这也就是我们为什么要给叶子节点添加 right 指针的原因)
+
+2. 如果 p1.left != null，找到 p1 左子树上最右的节点。(也就是我们的 p2 最后停留的位置)，此时我们又可以分为两种情况，一种是叶子节点添加 right 指针的情况，一种是去除叶子节点 right 指针的情况。
+
+3. - 如果 p2 的 right 指针指向空，让其指向 p1，p1向左移动,即 p1 = p1.left
+   - 如果 p2 的 right 指针指向 p1，让其指向空，（为了防止重复执行，则需要去掉 right 指针）p1 向右移动，p1 = p1.right。
+
+这时你可以结合咱们刚才提到的两个原则，再去看一遍动画，并代入规则进行模拟，差不多就能完全搞懂啦。
+
+下面我们来对动画中的内容进行拆解 ，
+
+首先 p1 指向 root节点
+
+p2 = p1.left，下面我们需要通过 p2 找到 p1的左子树中的最右节点。即节点 5，然后将该节点的 right 指针指向 root。并记录 root 节点的值。
+
+![image](https://cdn.jsdelivr.net/gh/tan45du/test@master/image.3h60vcjhqo80.png)
+
+向左移动 p1，即 p1 = p1.left
+
+p2 = p1.left ，即节点 4 ，找到 p1 的左子树中的最右叶子节点，也就是 9，并将该节点的 right 指针指向 2。
+
+![image](https://cdn.jsdelivr.net/gh/tan45du/test@master/image.zq91mdjkyzk.png)
+
+
+
+继续向左移动 p1,即 p1 =  p1.left，p2 = p1.left。 也就是节点 8。并将该节点的 right 指针指向 p1。
+
+![image](https://cdn.jsdelivr.net/gh/tan45du/test@master/image.5vsh71yrzxs0.png)
+
+ 
+
+我们发现这一步给前两步是一样的，都是找到叶子节点，将其 right 指针指向 p1,此时我们完成了添加 right 指针的过程，下面我们继续往下看。
+
+我们继续移动 p1 指针，p1 = p1.left。p2 = p.left。此时我们发现 p2 == null,即下图
+
+![image](https://cdn.jsdelivr.net/gh/tan45du/test@master/image.zk7nxrjdgr.png)
+
+此时我们需要移动 p1, 但是不再是 p1 = p1.left 而是 p1 = p1.right。也就是 4，继续让 p2 = p1.left。此时则为下图这种情况
+
+![image](https://cdn.jsdelivr.net/gh/tan45du/test@master/image.1pjni9r6tkps.png)
+
+此时我们发现 p2.right != null 而是指向 4，说明此时我们已经添加过了 right 指针，所以去掉 right 指针，并让 p1 = p1.right
+
+![image](https://cdn.jsdelivr.net/gh/tan45du/test@master/image.17t7n8yy340w.png)
+
+下面则继续移动  p1 ,按照规则继续移动即可，遇到的情况已经在上面做出了举例，所以下面我们就不继续赘述啦，如果还不是特别理解的同学，可以再去看一遍动画加深下印象。
+
+时间复杂度 O（n），空间复杂度 O（1）
+
+下面我们来看代码吧。
+
+#### 代码
+
+```java
+class Solution {
+    public List<Integer> preorderTraversal(TreeNode root) {
+
+        List<Integer> list = new ArrayList<>();
+        if (root == null) {
+            return list;
+        }
+        TreeNode p1 = root; TreeNode p2 = null;
+        while (p1 != null) {
+            p2 = p1.left;
+            if (p2 != null) {
+                //找到左子树的最右叶子节点
+                while (p2.right != null && p2.right != p1) {
+                    p2 = p2.right;
+                }
+                //添加 right 指针，对应 right 指针为 null 的情况
+                if (p2.right == null) {
+                    list.add(p1.val);
+                    p2.right = p1;
+                    p1 = p1.left;
+                    continue;
+                }
+                //对应 right 指针存在的情况，则去掉 right 指针
+                p2.right = null;
+            } else {
+                list.add(p1.val);
+            }
+            //移动 p1
+            p1 = p1.right;
+        }
+        return list;
+    }
+}
+```
+
+好啦，今天就看到这里吧，咱们下期见！

animation-simulation/数据结构和算法/直接插入排序.md

@@ -64,4 +64,5 @@ class Solution {
 
 我们根据代码可知，我们只会移动比 temp 值大的元素，所以我们排序后可以保证相同元素的相对位置不变。所以直接插入排序为稳定性排序算法。
 
-![](https://cdn.jsdelivr.net/gh/tan45du/bedphoto2@master/20210122/微信截图_20210128084750.6911k6mnrac0.png)
+![](https://cdn.jsdelivr.net/gh/tan45du/bedphoto2@master/20210122/微信截图_20210128084750.6911k6mnrac0.png)
+

animation-simulation/数组篇/leetcode27移除元素.md

@@ -95,7 +95,7 @@ class Solution {
               return 0;
           }
           int i = 0;
-          for (int j = 0; j < nums.length; ++j) {
+          for (int j = 0; j < len; ++j) {
                 //如果等于目标值，则删除
                 if (nums[j] == val) {
                     continue;
@@ -110,7 +110,7 @@ class Solution {
 
 Python3 Code:
 
-```py
+```python
 class Solution:
     def removeElement(self, nums: List[int], val: int) -> int:
         i = 0
@@ -121,3 +121,21 @@ class Solution:
         return i
 ```
 
+C++ Code:
+
+```cpp
+class Solution {
+public:
+    int removeElement(vector<int>& nums, int val) {
+        int n = nums.size();
+      	if(!n) return 0;
+      	int i = 0;
+      	for(int j = 0; j < n; ++j){
+          if(nums[j] == val) continue;
+          nums[i++] = nums[j];
+        }
+      	return i;
+    }
+};
+```
+

animation-simulation/数组篇/leetcode41缺失的第一个正数.md

@@ -119,7 +119,7 @@ class Solution {
 
 Python3 Code:
 
-```py
+```python
 class Solution:
     def firstMissingPositive(self, nums: List[int]) -> int:
         n = len(nums)

animation-simulation/数组篇/剑指offer3数组中重复的数.md

@@ -57,6 +57,8 @@ class Solution {
 
 **题目代码**
 
+Java Code:
+
 ```java
 class Solution {
     public int findRepeatNumber(int[] nums) {
@@ -80,3 +82,22 @@ class Solution {
 }
 ```
 
+C++ Code:
+
+```cpp
+class Solution {
+public:
+    int findRepeatNumber(vector<int>& nums) {
+	if(nums.empty()) return 0;
+      	int n = nums.size();
+      	for(int i = 0; i < n; ++i){
+          while(nums[i] != i){
+            if(nums[i] == nums[nums[i]]) return nums[i];
+            swap(nums[i], nums[nums[i]]);
+          }
+        }
+      return -1;
+    }
+};
+```
+

animation-simulation/数组篇/长度最小的子数组.md

@@ -38,6 +38,8 @@
 
 #### 题目代码
 
+Java Code:
+
 ```java
 class Solution {
     public int minSubArrayLen(int s, int[] nums) {
@@ -60,3 +62,23 @@ class Solution {
 }
 ```
 
+C++ Code:
+
+```cpp
+class Solution {
+public:
+    int minSubArrayLen(int t, vector<int>& nums) {
+		int n = nums.size();
+      	int i = 0, sum = 0, winlen = INT_MAX;
+      	for(int j = 0; j < n; ++j){
+          sum += nums[j];
+          while(sum >= t){
+            winlen = min(winlen, j - i + 1);
+            sum -= nums[i++];
+          }
+        }
+      return winlen == INT_MAX? 0: winlen;
+    }
+};
+```
+