Update

Author: youngyangyang04

README.md

@@ -77,6 +77,157 @@
 
 （待补充.....）
 
+# 算法模板 
+
+## 二分法 
+（待补充....）
+
+## KMP
+
+（待补充....）
+
+## 二叉树 
+
+### 深度优先遍历（递归） 
+
+前序遍历（中左右）
+```
+void traversal(TreeNode* cur, vector<int>& vec) {
+    if (cur == NULL) return;
+    vec.push_back(cur->val);    // 中 ，同时也是处理节点逻辑的地方
+    traversal(cur->left, vec);  // 左
+    traversal(cur->right, vec); // 右
+}
+```
+中序遍历（左中右）
+```
+void traversal(TreeNode* cur, vector<int>& vec) {
+    if (cur == NULL) return;
+    traversal(cur->left, vec);  // 左
+    vec.push_back(cur->val);    // 中 ，同时也是处理节点逻辑的地方
+    traversal(cur->right, vec); // 右
+}
+```
+中序遍历（中左右）
+```
+void traversal(TreeNode* cur, vector<int>& vec) {
+    if (cur == NULL) return;
+    vec.push_back(cur->val);    // 中 ，同时也是处理节点逻辑的地方
+    traversal(cur->left, vec);  // 左
+    traversal(cur->right, vec); // 右
+}
+```
+
+### 深度优先遍历：迭代法（使用栈模拟递归）
+
+相关题解：[0094.二叉树的中序遍历](https://github.com/youngyangyang04/leetcode/blob/master/problems/0094.二叉树的中序遍历.md)
+
+前序遍历（中左右）
+```
+vector<int> preorderTraversal(TreeNode* root) {
+    vector<int> result;
+    stack<TreeNode*> st;
+    if (root != NULL) st.push(root);
+    while (!st.empty()) {
+        TreeNode* node = st.top();
+        if (node != NULL) {
+            st.pop();
+            if (node->right) st.push(node->right);  // 右
+            if (node->left) st.push(node->left);    // 左
+            st.push(node);                          // 中
+            st.push(NULL);                          
+        } else {
+            st.pop();
+            node = st.top();
+            st.pop();
+            result.push_back(node->val);            // 节点处理逻辑
+        }
+    }
+    return result;
+}
+
+```
+
+中序遍历（左中右）
+```
+vector<int> inorderTraversal(TreeNode* root) {
+    vector<int> result; // 存放中序遍历的元素
+    stack<TreeNode*> st;
+    if (root != NULL) st.push(root);
+    while (!st.empty()) {
+        TreeNode* node = st.top();
+        if (node != NULL) {
+            st.pop(); 
+            if (node->right) st.push(node->right);  // 右
+            st.push(node);                          // 中
+            st.push(NULL); 
+            if (node->left) st.push(node->left);    // 左
+        } else {
+            st.pop(); 
+            node = st.top(); 
+            st.pop();
+            result.push_back(node->val);            // 节点处理逻辑
+        }
+    }
+    return result;
+}
+```
+
+后序遍历（左右中）
+```
+vector<int> postorderTraversal(TreeNode* root) {
+    vector<int> result;
+    stack<TreeNode*> st;
+    if (root != NULL) st.push(root);
+    while (!st.empty()) {
+        TreeNode* node = st.top();
+        if (node != NULL) {
+            st.pop();
+            st.push(node);                          // 中
+            st.push(NULL);
+            if (node->right) st.push(node->right);  // 右
+            if (node->left) st.push(node->left);    // 左
+
+        } else {
+            st.pop();
+            node = st.top();
+            st.pop();
+            result.push_back(node->val);            // 节点处理逻辑
+        }
+    }
+    return result;
+}
+```
+### 广度优先遍历（队列）
+
+相关题解：[0102.二叉树的层序遍历](https://github.com/youngyangyang04/leetcode/blob/master/problems/0102.二叉树的层序遍历.md)
+
+```
+vector<vector<int>> levelOrder(TreeNode* root) {
+    queue<TreeNode*> que;
+    if (root != NULL) que.push(root);
+    vector<vector<int>> result;
+    while (!que.empty()) {
+        int size = que.size();
+        vector<int> vec;
+        for (int i = 0; i < size; i++) {// 这里一定要使用固定大小size，不要使用que.size()
+            TreeNode* node = que.front();
+            que.pop();
+            vec.push_back(node->val);   // 节点处理的逻辑
+            if (node->left) que.push(node->left);
+            if (node->right) que.push(node->right);
+        }
+        result.push_back(vec);
+    }
+    return result;
+}
+
+```
+
+### 二叉树深度
+
+### 二叉树节点数量
+
 # LeetCode 最强题解:
 
 |题目 | 类型 | 难度 | 解题方法 |

problems/0094.二叉树的中序遍历.md

@@ -3,6 +3,9 @@ https://leetcode-cn.com/problems/binary-tree-inorder-traversal/
 
 ## 思路 
 
+
+
+
 094.二叉树的中序遍历
 144.二叉树的前序遍历
 145.二叉树的后序遍历

problems/0101.对称二叉树.md

@@ -3,7 +3,110 @@ https://leetcode-cn.com/problems/symmetric-tree/
 
 ## 思路 
 
-这是考察二叉树基本操作的经典题目，递归的方式相对好理解一些，迭代的方法 我看大家清一色使用队列，其实使用栈也是可以的，只不过遍历的顺序不同而已，关键是要理解只要是对称比较就可以了，遍历的顺序无所谓的。
+这是考察二叉树基本操作的经典题目，递归的方式相对好理解一些，迭代法看大家清一色使用队列，其实使用栈也是可以的，只不过遍历的顺序不同而已，关键是要理解只要是对称比较就可以了，遍历的顺序无所谓的。
+
+
+### 递归法 
+
+#### 递归三部曲
+
+* 确定递归函数的参数和返回值 
+* 确定终止条件 
+* 确定单层递归的逻辑
+
+##### 确定递归函数的参数和返回值 
+
+判断左右孩子是否对称，所以传入的参数为左指针和右指针，那么就返回是否是对称的就可以了，所以返回值是布尔类型。
+
+代码如下：
+```
+bool compare(TreeNode* left, TreeNode* right)
+```
+
+##### 确定终止条件 
+
+* 左孩子为空，右孩子不为空，不对称，return false 
+* 左不为空，右为空，不对称 return  false
+* 左右都为空，对称，返回true 
+* 左右都不为空，比较节点数值，不相同就return false
+
+代码如下：
+```
+if (left == NULL && right != NULL) return false;
+else if (left != NULL && right == NULL) return false;
+else if (left == NULL && right == NULL) return true;
+else if (left->val != right->val) return false;
+```
+
+#####  确定单层递归的逻辑 
+
+* 比较二叉树外侧是否对称：传入的是左孩子的左指针，右孩子的右指针。
+* 比较内测是否对称，传入左孩子的右指针，右孩子的左指针。 
+* 如果左右都对称就返回true ，有一侧不对称就返回false 。
+
+代码如下：
+
+```
+bool outside = compare(left->left, right->right);
+bool inside = compare(left->right, right->left);
+return outside && inside;
+```
+
+这样递归的C++代码就写出来了，如下：
+
+```
+class Solution {
+public:
+    bool compare(TreeNode* left, TreeNode* right) {
+        if (left == NULL && right != NULL) return false;
+        else if (left != NULL && right == NULL) return false;
+        else if (left == NULL && right == NULL) return true;
+        else if (left->val != right->val) return false;
+        else return compare(left->left, right->right) && compare(left->right, right->left);
+
+    }
+    bool isSymmetric(TreeNode* root) {
+        if (root == NULL) return true;
+        return compare(root->left, root->right);
+    }
+};
+```
+
+### 迭代法 
+
+通过队列来判断二叉树内侧和外侧是否相等，如动画所示：
+
+<video src='../video/对称二叉树.mp4' controls='controls' width='640' height='320' autoplay='autoplay'> Your browser does not support the video tag.</video></div>
+
+代码如下：
+
+```
+class Solution {
+public:
+    bool isSymmetric(TreeNode* root) {
+        if (root == NULL) return true;
+        queue<TreeNode*> que;
+        que.push(root->left);
+        que.push(root->right);
+        while (!que.empty()) {
+            TreeNode* leftNode = que.front(); que.pop();
+            TreeNode* rightNode = que.front(); que.pop();
+            if (!leftNode && !rightNode) {
+                continue;
+            }
+            if ((!leftNode || !rightNode || (leftNode->val != rightNode->val))) {
+                return false;
+            }
+            que.push(leftNode->left);
+            que.push(rightNode->right);
+            que.push(leftNode->right);
+            que.push(rightNode->left);
+        }
+        return true;
+    }
+};
+```
+其实使用栈也是可以的，只要把队列原封不动的改成栈就可以了，我下面也给出了代码。
 
 ## C++代码
 

problems/0104.二叉树的最大深度.md

@@ -21,7 +21,7 @@ public:
 };
 ```
 
-### BFS 
+### 迭代法
 
 ```
 class Solution {

problems/0111.二叉树的最小深度.md

@@ -29,7 +29,7 @@ public:
 
 ```
 
-### BFS
+### 迭代法
 ```
 class Solution {
 public:

problems/0142.环形链表II.md

@@ -5,7 +5,12 @@ https://leetcode-cn.com/problems/linked-list-cycle-ii/
 
 这道题目，不仅考察对链表的操作，而且还需要一些数学运算。
 
-**首先如何判断链表有环呢**
+主要考察两知识点：
+
+* 判断链表是否环
+* 如果有环，如何找到这个环的入口
+
+### **首先如何判断链表有环呢**
 
 可以使用快慢指针法，  分别定义 fast 和 slow指针，从头结点出发，fast指针每次移动两个节点，slow指针每次移动一个节点，如果 fast 和 slow指针在途中相遇 ，说明这个链表有环。
 
@@ -26,7 +31,9 @@ fast和slow各自再走一步， fast和slow就相遇了
 这是因为fast是走两步，slow是走一步，**其实相对于slow来说，fast是一个节点一个节点的靠近slow的**，所以fast一定可以和slow重合。
 
 
-此时我们已经可以判断链表是否有环了，那么接下来要找这个环的入口了
+### 如果有环，如何找到这个环的入口
+
+**此时我们已经可以判断链表是否有环了，那么接下来要找这个环的入口了**
 
 
 假设从头结点到环形入口节点 的节点数为x。