Merge branch 'youngyangyang04:master' into master

problems/0045.跳跃游戏II.md

@@ -250,6 +250,27 @@ var jump = function(nums) {
 };
 ```
 
+### TypeScript
+
+```typescript
+function jump(nums: number[]): number {
+    const length: number = nums.length;
+    let curFarthestIndex: number = 0,
+        nextFarthestIndex: number = 0;
+    let curIndex: number = 0;
+    let stepNum: number = 0;
+    while (curIndex < length - 1) {
+        nextFarthestIndex = Math.max(nextFarthestIndex, curIndex + nums[curIndex]);
+        if (curIndex === curFarthestIndex) {
+            curFarthestIndex = nextFarthestIndex;
+            stepNum++;
+        }
+        curIndex++;
+    }
+    return stepNum;
+};
+```
+
 
 
 

problems/0055.跳跃游戏.md

@@ -154,6 +154,23 @@ var canJump = function(nums) {
 };
 ```
 
+### TypeScript
+
+```typescript
+function canJump(nums: number[]): boolean {
+    let farthestIndex: number = 0;
+    let cur: number = 0;
+    while (cur <= farthestIndex) {
+        farthestIndex = Math.max(farthestIndex, cur + nums[cur]);
+        if (farthestIndex >= nums.length - 1) return true;
+        cur++;
+    }
+    return false;
+};
+```
+
+
+
 
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

problems/0122.买卖股票的最佳时机II.md

@@ -268,6 +268,18 @@ const maxProfit = (prices) => {
 };
 ```
 
+TypeScript：
+
+```typescript
+function maxProfit(prices: number[]): number {
+    let resProfit: number = 0;
+    for (let i = 1, length = prices.length; i < length; i++) {
+        resProfit += Math.max(prices[i] - prices[i - 1], 0);
+    }
+    return resProfit;
+};
+```
+
 C:
 
 ```c

problems/0707.设计链表.md

@@ -973,6 +973,10 @@ class MyLinkedList {
         // 处理头节点
         if (index === 0) {
             this.head = this.head!.next;
+            // 如果链表中只有一个元素，删除头节点后，需要处理尾节点
+            if (index === this.size - 1) {
+                this.tail = null
+            }
             this.size--;
             return;
         }

problems/0763.划分字母区间.md

@@ -77,6 +77,61 @@ public:
 
 但这道题目的思路是很巧妙的，所以有必要介绍给大家做一做，感受一下。
 
+## 补充
+
+这里提供一种与[452.用最少数量的箭引爆气球](https://programmercarl.com/0452.用最少数量的箭引爆气球.html)、[435.无重叠区间](https://programmercarl.com/0435.无重叠区间.html)相同的思路。
+
+统计字符串中所有字符的起始和结束位置，记录这些区间(实际上也就是[435.无重叠区间](https://programmercarl.com/0435.无重叠区间.html)题目里的输入)，**将区间按左边界从小到大排序，找到边界将区间划分成组，互不重叠。找到的边界就是答案。**
+
+```CPP
+class Solution {
+public:
+    static bool cmp(vector<int> &a, vector<int> &b) {
+        return a[0] < b[0];
+    }
+    // 记录每个字母出现的区间
+    vector<vector<int>> countLabels(string s) {
+        vector<vector<int>> hash(26, vector<int>(2, INT_MIN));
+        vector<vector<int>> hash_filter;
+        for (int i = 0; i < s.size(); ++i) {
+            if (hash[s[i] - 'a'][0] == INT_MIN) {
+                hash[s[i] - 'a'][0] = i;
+            }
+            hash[s[i] - 'a'][1] = i;
+        }
+        // 去除字符串中未出现的字母所占用区间
+        for (int i = 0; i < hash.size(); ++i) {
+            if (hash[i][0] != INT_MIN) {
+                hash_filter.push_back(hash[i]);
+            }
+        }
+        return hash_filter;
+    }
+    vector<int> partitionLabels(string s) {
+        vector<int> res;
+        // 这一步得到的 hash 即为无重叠区间题意中的输入样例格式：区间列表
+        // 只不过现在我们要求的是区间分割点
+        vector<vector<int>> hash = countLabels(s);
+        // 按照左边界从小到大排序
+        sort(hash.begin(), hash.end(), cmp);
+        // 记录最大右边界
+        int rightBoard = hash[0][1];
+        int leftBoard = 0;
+        for (int i = 1; i < hash.size(); ++i) {
+            // 由于字符串一定能分割，因此,
+            // 一旦下一区间左边界大于当前右边界，即可认为出现分割点
+            if (hash[i][0] > rightBoard) {
+                res.push_back(rightBoard - leftBoard + 1);
+                leftBoard = hash[i][0];
+            }
+            rightBoard = max(rightBoard, hash[i][1]);
+        }
+        // 最右端
+        res.push_back(rightBoard - leftBoard + 1);
+        return res;
+    }
+};
+```
 
 ## 其他语言版本
 

problems/前序/ACM模式如何构建二叉树.md

@@ -208,6 +208,59 @@ int main() {
 ## Java 
 
 ```Java
+public class Solution {
+    // 节点类
+    static class TreeNode {
+        // 节点值
+        int val;
+
+        // 左节点
+        TreeNode left;
+
+        // 右节点
+        TreeNode right;
+
+        // 节点的构造函数(默认左右节点都为null)
+        public TreeNode(int x) {
+            this.val = x;
+            this.left = null;
+            this.right = null;
+        }
+    }
+    
+    /**
+     * 根据数组构建二叉树
+     * @param arr 树的数组表示
+     * @return 构建成功后树的根节点
+     */
+    public TreeNode constructBinaryTree(final int[] arr) {
+        // 构建和原数组相同的树节点列表
+        List<TreeNode> treeNodeList = arr.length > 0 ? new ArrayList<>(arr.length) : null;
+        TreeNode root = null;
+        // 把输入数值数组，先转化为二叉树节点列表
+        for (int i = 0; i < arr.length; i++) {
+            TreeNode node = null;
+            if (arr[i] != -1) { // 用 -1 表示null
+                node = new TreeNode(arr[i]);
+            }
+            treeNodeList.add(node);
+            if (i == 0) {
+                root = node;
+            }
+        }
+        // 遍历一遍，根据规则左右孩子赋值就可以了
+        // 注意这里 结束规则是 i * 2 + 2 < arr.length，避免空指针
+        for (int i = 0; i * 2 + 2 < arr.length; i++) {
+            TreeNode node = treeNodeList.get(i);
+            if (node != null) {
+                // 线性存储转连式存储关键逻辑
+                node.left = treeNodeList.get(2 * i + 1);
+                node.right = treeNodeList.get(2 * i + 2);
+            }
+        }
+        return root;
+    }
+}
 ```