Update

Author: youngyangyang04

README.md

@@ -3,6 +3,12 @@ https://leetcode-cn.com/problems/construct-binary-tree-from-inorder-and-postorde
 
 > 给出两个序列
 
+看完本文，可以一起解决如下两道题目 
+
+* 106.从中序与后序遍历序列构造二叉树 
+* 105.从前序与中序遍历序列构造二叉树
+
+
 # 106.从中序与后序遍历序列构造二叉树 
 
 根据一棵树的中序遍历与后序遍历构造二叉树。
@@ -383,7 +389,7 @@ public:
 };
 ```
 
-# 105. 从前序与中序遍历序列构造二叉树 
+# 105.从前序与中序遍历序列构造二叉树 
 
 根据一棵树的前序遍历与中序遍历构造二叉树。
 

pics/108.将有序数组转换为二叉搜索树.png

@@ -1,28 +1,122 @@
+> 构造二叉搜索树，一不小心就平衡了 
 
-## 思路 
+# 108.将有序数组转换为二叉搜索树 
 
-要考率 和 普通数组转成二叉树有什么差别
+将一个按照升序排列的有序数组，转换为一棵高度平衡二叉搜索树。
 
-注意这里是构造平衡二叉搜索树，其实 这里不用强调，因为数组构造二叉树，构成平衡树是自然而然的事情，因为大家默认都是从中间取值，不可能随机取，自找麻烦
+本题中，一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。
 
-一想 这道题目还是有难度的，
+示例:
 
-一定是递归 分治
+![108.将有序数组转换为二叉搜索树](https://img-blog.csdnimg.cn/20201022164420763.png)
 
-循环不变量 的题目列表 
+# 思路 
 
-注意答案不是唯一的 
+做这道题目之前大家可以了解一下这几道：
 
-输入：[-10,-3,0,5,9]
-输出：[0,-10,5,null,-3,null,9]
-预期结果：[0,-3,9,-10,null,5]
+* [106.从中序与后序遍历序列构造二叉树](https://mp.weixin.qq.com/s/7r66ap2s-shvVvlZxo59xg)
+* [654.最大二叉树](https://mp.weixin.qq.com/s/1iWJV6Aov23A7xCF4nV88w)中其实已经讲过了，如果根据数组构造一颗二叉树。
+* [701.二叉搜索树中的插入操作](https://mp.weixin.qq.com/s/lwKkLQcfbCNX2W-5SOeZEA) 
+* [450.删除二叉搜索树中的节点](https://mp.weixin.qq.com/s/-p-Txvch1FFk3ygKLjPAKw)
+
+
+进入正题：
+
+题目中说要转换为一棵高度平衡二叉搜索树。这和转换为一棵普通二叉搜索树有什么差别呢？
+
+其实这里不用强调平衡二叉搜索树，数组构造二叉树，构成平衡树是自然而然的事情，因为大家默认都是从数组中间位置取值作为节点元素，一般不会随机取，**所以想构成不平衡的二叉树是自找麻烦**。
+
+
+在[二叉树：构造二叉树登场！](https://mp.weixin.qq.com/s/7r66ap2s-shvVvlZxo59xg)和[二叉树：构造一棵最大的二叉树](https://mp.weixin.qq.com/s/1iWJV6Aov23A7xCF4nV88w)中其实已经讲过了，如果根据数组构造一颗二叉树。
+
+**本质就是寻找分割点，分割点作为当前节点，然后递归左区间和右区间**。
+
+本题其实要比[二叉树：构造二叉树登场！](https://mp.weixin.qq.com/s/7r66ap2s-shvVvlZxo59xg) 和 [二叉树：构造一棵最大的二叉树](https://mp.weixin.qq.com/s/1iWJV6Aov23A7xCF4nV88w)简单一些，因为有序数组构造二叉搜索树，寻找分割点就比较容易了。
+
+分割点就是数组中间位置的节点。
+
+那么为问题来了，如果数组长度为偶数，中间节点有两个，取哪一个？
+
+取哪一个都可以，只不过构成了不同的平衡二叉搜索树。
+
+例如：输入：[-10,-3,0,5,9] 
+
+如下两棵树，都是这个数组的平衡二叉搜索树：
+
+<img src='../pics/108.将有序数组转换为二叉搜索树.png' width=600> </img></div>
+
+如果要分割的数组长度为偶数的时候，中间元素为两个，是取左边元素  就是树1，取右边元素就是树2。 
+
+**这也是题目中强调答案不是唯一的原因。 理解这一点，这道题目算是理解到位了**。
+
+## 递归 
+
+递归三部曲：
+
+* 确定递归函数返回值及其参数 
+
+删除二叉树节点，增加二叉树节点，都是用递归函数的返回值来完成，这样是比较方便的。
+
+相信大家如果仔细看了[二叉树：搜索树中的插入操作](https://mp.weixin.qq.com/s/lwKkLQcfbCNX2W-5SOeZEA)和[二叉树：搜索树中的删除操作](https://mp.weixin.qq.com/s/-p-Txvch1FFk3ygKLjPAKw)，一定会对递归函数返回值的作用深有感触。
+
+那么本题要构造二叉树，依然用递归函数的返回值来构造中节点的左右孩子。
+
+再来看参数，首先是传入数组，然后就是左下表left和右下表right，我们在[二叉树：构造二叉树登场！](https://mp.weixin.qq.com/s/7r66ap2s-shvVvlZxo59xg)中提过，在构造二叉树的时候尽量不要重新定义左右区间数组，而是用下表来操作原数组。
+
+所以代码如下：
+
+```
+// 左闭右闭区间[left, right]
+TreeNode* traversal(vector<int>& nums, int left, int right) 
+```
+
+这里注意，**我这里定义的是左闭右闭区间，在不断分割的过程中，也会坚持左闭右闭的区间，这又涉及到我们讲过的循环不变量**。
+
+在[二叉树：构造二叉树登场！](https://mp.weixin.qq.com/s/7r66ap2s-shvVvlZxo59xg)，[35.搜索插入位置](https://mp.weixin.qq.com/s/fCf5QbPDtE6SSlZ1yh_q8Q) 和[59.螺旋矩阵II](https://mp.weixin.qq.com/s/KTPhaeqxbMK9CxHUUgFDmg)都详细讲过循环不变量。
+
+
+* 确定递归终止条件 
+
+这里定义的是左闭右闭的区间，所以当区间 left > right的时候，就是空节点了。
+
+代码如下：
+
+```
+if (left > right) return nullptr;
+```
+
+* 确定单层递归的逻辑 
+
+首先取数组中间元素的位置，不难写出`int mid = (left + right) / 2;`，**这么写其实有一个问题，就是数值越界，例如left和right都是最大int，这么操作就越界了，在[二分法](https://mp.weixin.qq.com/s/fCf5QbPDtE6SSlZ1yh_q8Q)中尤其需要注意！** 
+
+所以可以这么写：`int mid = left + ((right - left) / 2);` 
+
+但本题leetcode的测试数据并不会越界，所以怎么写都可以。但需要有这个意识！ 
+
+取了中间位置，就开始以中间位置的元素构造节点，代码：`TreeNode* root = new TreeNode(nums[mid]);`。 
+
+接着划分区间，root的左孩子接住下一层左区间的构造节点，右孩子接住下一层右区间构造的节点。
+
+最后返回root节点，单层递归整体代码如下：
+
+```
+int mid = left + ((right - left) / 2); 
+TreeNode* root = new TreeNode(nums[mid]);
+root->left = traversal(nums, left, mid - 1);
+root->right = traversal(nums, mid + 1, right);
+return root;
+```
+
+这里`int mid = left + ((right - left) / 2);`的写法相当于是如果数组长度为偶数，中间位置有两个元素，取靠左边的。
+
+* 递归整体代码如下：
 
 ```
 class Solution {
 private:
     TreeNode* traversal(vector<int>& nums, int left, int right) {
         if (left > right) return nullptr;
-        int mid = (left + right) / 2; // 注意越界
+        int mid = left + ((right - left) / 2); 
         TreeNode* root = new TreeNode(nums[mid]);
         root->left = traversal(nums, left, mid - 1);
         root->right = traversal(nums, mid + 1, right);
@@ -36,3 +130,68 @@ public:
 };
 ```
 
+**注意：在调用traversal的时候为什么传入的left和right为什么是0和nums.size() - 1，因为定义的区间为左闭右闭**。
+
+
+## 迭代法
+
+迭代法可以通过三个队列来模拟，一个队列放遍历的节点，一个队列放左区间下表，一个队列放右区间下表。
+
+模拟的就是不断分割的过程，C++代码如下：（我已经详细注释）
+
+```
+class Solution {
+public:
+    TreeNode* sortedArrayToBST(vector<int>& nums) {
+        if (nums.size() == 0) return nullptr;
+
+        TreeNode* root = new TreeNode(0);   // 初始根节点
+        queue<TreeNode*> nodeQue;           // 放遍历的节点
+        queue<int> leftQue;                 // 保存左区间下表
+        queue<int> rightQue;                // 保存右区间下表
+        nodeQue.push(root);                 // 根节点入队列
+        leftQue.push(0);                    // 0为左区间下表初始位置
+        rightQue.push(nums.size() - 1);     // nums.size() - 1为右区间下表初始位置
+
+        while (!nodeQue.empty()) {
+            TreeNode* curNode = nodeQue.front();
+            nodeQue.pop();
+            int left = leftQue.front(); leftQue.pop();
+            int right = rightQue.front(); rightQue.pop();
+            int mid = left + ((right - left) / 2); 
+
+            curNode->val = nums[mid];       // 将mid对应的元素给中间节点
+
+            if (left <= mid - 1) {          // 处理左区间
+                curNode->left = new TreeNode(0);
+                nodeQue.push(curNode->left);
+                leftQue.push(left);
+                rightQue.push(mid - 1);
+            }
+
+            if (right >= mid + 1) {         // 处理右区间
+                curNode->right = new TreeNode(0);
+                nodeQue.push(curNode->right);
+                leftQue.push(mid + 1);
+                rightQue.push(right);
+            }
+        }
+        return root;
+    }
+};
+```
+
+# 总结 
+
+**在[二叉树：构造二叉树登场！](https://mp.weixin.qq.com/s/7r66ap2s-shvVvlZxo59xg) 和 [二叉树：构造一棵最大的二叉树](https://mp.weixin.qq.com/s/1iWJV6Aov23A7xCF4nV88w)之后，我们顺理成章的应该构造一下二叉搜索树了，一不小心还是一棵平衡二叉搜索树**。
+
+其实思路也是一样的，不断中间分割，然后递归处理左区间，右区间，也可以说是分治。
+
+此时相信大家应该对通过递归函数的返回值来增删二叉树很熟悉了，这也是常规操作。
+
+在定义区间的过程中我们又一次强调了循环不变量的重要性。 
+
+最后依然给出迭代的方法，其实就是模拟取中间元素，然后不断分割去构造二叉树的过程。
+
+**就酱，如果对你有帮助的话，也转发给身边需要的同学吧！**
+

pics/234.回文链表.png

@@ -0,0 +1,122 @@
+
+## 题目链接
+https://leetcode-cn.com/problems/palindrome-linked-list/
+
+## 思路 
+
+### 数组模拟
+
+最直接的想法，就是把链表装成数组，然后再判断是否回文。
+
+代码也比较简单。如下：
+
+```
+class Solution {
+public:
+    bool isPalindrome(ListNode* head) {
+        vector<int> vec;
+        ListNode* cur  = head;
+        while (cur) {
+            vec.push_back(cur->val);
+            cur = cur->next;
+        }
+        // 比较数组回文
+        for (int i = 0, j = vec.size() - 1; i < j; i++, j--) {
+            if (vec[i] != vec[j]) return false;
+        }
+        return true;
+    }
+};
+```
+
+上面代码可以在优化，就是先求出链表长度，然后给定vector的初始长度，这样避免vector每次添加节点重新开辟空间
+
+```
+class Solution {
+public:
+    bool isPalindrome(ListNode* head) {
+
+        ListNode* cur  = head;
+        int length = 0;
+        while (cur) {
+            length++;
+            cur = cur->next;
+        }
+        vector<int> vec(length, 0); // 给定vector的初始长度，这样避免vector每次添加节点重新开辟空间
+        cur = head;
+        int index = 0;
+        while (cur) {
+            vec[index++] = cur->val;
+            cur = cur->next;
+        }
+        // 比较数组回文
+        for (int i = 0, j = vec.size() - 1; i < j; i++, j--) {
+            if (vec[i] != vec[j]) return false;
+        }
+        return true;
+    }
+};
+
+```
+
+### 反转后半部分链表
+
+分为如下几步：
+
+* 用快慢指针，快指针有两步，慢指针走一步，快指针遇到终止位置时，慢指针就在链表中间位置 
+* 同时用pre记录慢指针指向节点的前一个节点，用来分割链表 
+* 将链表分为前后均等两部分，如果链表长度是奇数，那么后半部分多一个节点 
+* 将后半部分反转 ，得cur2，前半部分为cur1
+* 按照cur1的长度，一次比较cur1和cur2的节点数值 
+
+如图所示：
+
+<img src='../pics/234.回文链表.png' width=600> </img></div>
+
+代码如下：
+
+```
+class Solution {
+public:
+    bool isPalindrome(ListNode* head) {
+        if (head == nullptr || head->next == nullptr) return true;
+        ListNode* slow = head; // 慢指针，找到链表中间分位置，作为分割
+        ListNode* fast = head;
+        ListNode* pre = head; // 记录慢指针的前一个节点，用来分割链表
+        while (fast && fast->next) {
+            pre = slow;
+            slow = slow->next;
+            fast = fast->next->next;
+        }
+        pre->next = nullptr; // 分割链表
+
+        ListNode* cur1 = head;  // 前半部分
+        ListNode* cur2 = reverseList(slow); // 反转后半部分，总链表长度如果是奇数，cur2比cur1多一个节点
+
+        // 开始两个链表的比较
+        while (cur1) {
+            if (cur1->val != cur2->val) return false;
+            cur1 = cur1->next;
+            cur2 = cur2->next;
+        }
+        return true;
+    }
+    // 反转链表
+    ListNode* reverseList(ListNode* head) {
+        ListNode* temp; // 保存cur的下一个节点
+        ListNode* cur = head;
+        ListNode* pre = nullptr;
+        while(cur) {
+            temp = cur->next;  // 保存一下 cur的下一个节点，因为接下来要改变cur->next
+            cur->next = pre; // 翻转操作
+            // 更新pre 和 cur指针
+            pre = cur;
+            cur = temp;
+        }
+        return pre;
+    }
+};
+```
+
+栈 
+

pics/538.把二叉搜索树转换为累加树.png

@@ -0,0 +1,11 @@
+
+## 思路 
+
+https://www.cnblogs.com/gzshan/p/12560566.html 图不错 
+
+有点难度 
+
+
+暴力的解法，其实也不是那么好写的， 首字符去0，k没消耗完，等等这些情况 
+
+有点难，卡我很久