Merge branch 'youngyangyang04:master' into master

problems/0106.从中序与后序遍历序列构造二叉树.md

@@ -684,7 +684,7 @@ class Solution:
         root.right = self.buildTree(preorder_right, inorder_right)
 
         return root
-``` 
+```
 
 106.从中序与后序遍历序列构造二叉树
 
@@ -716,7 +716,7 @@ class Solution:
         root.right = self.buildTree(inorder_right, postorder_right)
 
         return root 
-``` 
+```
 
 ## Go
 
@@ -816,6 +816,7 @@ var buildTree = function(preorder, inorder) {
 
 ## C
 106 从中序与后序遍历序列构造二叉树
+
 ```c
 int linearSearch(int* arr, int arrSize, int key) {
     int i;
@@ -847,6 +848,7 @@ struct TreeNode* buildTree(int* inorder, int inorderSize, int* postorder, int po
 ```
 
 105 从前序与中序遍历序列构造二叉树
+
 ```c
 struct TreeNode* buildTree(int* preorder, int preorderSize, int* inorder, int inorderSize){
     // 递归结束条件：传入的数组大小为0
@@ -889,5 +891,100 @@ struct TreeNode* buildTree(int* preorder, int preorderSize, int* inorder, int in
 }
 ```
 
+## Swift
+
+105 从前序与中序遍历序列构造二叉树
+
+```swift
+class Solution {
+    func buildTree(_ preorder: [Int], _ inorder: [Int]) -> TreeNode? {
+        return helper(preorder: preorder,
+                      preorderBegin: 0,
+                      preorderEnd: preorder.count,
+                      inorder: inorder,
+                      inorderBegin: 0,
+                      inorderEnd: inorder.count)
+    }
+    
+    func helper(preorder: [Int], preorderBegin: Int, preorderEnd: Int, inorder: [Int], inorderBegin: Int, inorderEnd: Int) -> TreeNode? {
+        if preorderBegin == preorderEnd {
+            return nil
+        }
+        
+        // 前序遍历数组的第一个元素作为分割点
+        let rootValue = preorder[preorderBegin]
+        let root = TreeNode(rootValue)
+        
+        
+        if preorderEnd - preorderBegin == 1 {
+            return root
+        }
+        
+        var index = 0 // 从中序遍历数组中找到根节点的下标
+        if let ind = inorder.firstIndex(of: rootValue) {
+            index = ind
+        }
+        
+        // 递归
+        root.left = helper(preorder: preorder,
+                           preorderBegin: preorderBegin + 1,
+                           preorderEnd: preorderBegin + 1 + index - inorderBegin,
+                           inorder: inorder,
+                           inorderBegin: inorderBegin,
+                           inorderEnd: index)
+        root.right = helper(preorder: preorder,
+                            preorderBegin: preorderBegin + 1 + index - inorderBegin,
+                            preorderEnd: preorderEnd,
+                            inorder: inorder,
+                            inorderBegin: index + 1,
+                            inorderEnd: inorderEnd)
+        return root
+    }
+}
+```
+
+106 从中序与后序遍历序列构造二叉树
+
+```swift
+class Solution_0106 {
+    func buildTree(inorder: [Int], inorderBegin: Int, inorderEnd: Int, postorder: [Int], postorderBegin: Int, postorderEnd: Int) -> TreeNode? {
+        if postorderEnd - postorderBegin < 1 {
+            return nil
+        }
+        
+        // 后序遍历数组的最后一个元素作为分割点
+        let rootValue = postorder[postorderEnd - 1]
+        let root = TreeNode(rootValue)
+        
+        if postorderEnd - postorderBegin == 1 {
+            return root
+        }
+        
+        // 从中序遍历数组中找到根节点的下标
+        var delimiterIndex = 0
+        if let index = inorder.firstIndex(of: rootValue) {
+            delimiterIndex = index
+        }
+        
+        root.left = buildTree(inorder: inorder,
+                              inorderBegin: inorderBegin,
+                              inorderEnd: delimiterIndex,
+                              postorder: postorder,
+                              postorderBegin: postorderBegin,
+                              postorderEnd: postorderBegin + (delimiterIndex - inorderBegin))
+        
+        root.right = buildTree(inorder: inorder,
+                               inorderBegin: delimiterIndex + 1,
+                               inorderEnd: inorderEnd,
+                               postorder: postorder,
+                               postorderBegin: postorderBegin + (delimiterIndex - inorderBegin),
+                               postorderEnd: postorderEnd - 1)
+        return root
+    }
+}
+```
+
+
+
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

problems/0203.移除链表元素.md

@@ -302,7 +302,63 @@ var removeElements = function(head, val) {
 };
 ```
 
+TypeScript:
+
+版本一（在原链表上直接删除）：
+
+```typescript
+/**
+ * Definition for singly-linked list.
+ * class ListNode {
+ *     val: number
+ *     next: ListNode | null
+ *     constructor(val?: number, next?: ListNode | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.next = (next===undefined ? null : next)
+ *     }
+ * }
+ */
+function removeElements(head: ListNode | null, val: number): ListNode | null {
+    // 删除头部节点
+    while (head !== null && head.val === val) {
+        head = head.next;
+    }
+    if (head === null) return head;
+    let pre: ListNode = head, cur: ListNode = head.next;
+    // 删除非头部节点
+    while (cur) {
+        if (cur.val === val) {
+            pre.next = cur.next;
+        } else {
+            pre = pre.next;
+        }
+        cur = cur.next;
+    }
+    return head;
+};
+```
+
+版本二（虚拟头节点）：
+
+```typescript
+function removeElements(head: ListNode | null, val: number): ListNode | null {
+    head = new ListNode(0, head);
+    let pre: ListNode = head, cur: ListNode = head.next;
+    // 删除非头部节点
+    while (cur) {
+        if (cur.val === val) {
+            pre.next = cur.next;
+        } else {
+            pre = pre.next;
+        }
+        cur = cur.next;
+    }
+    return head.next;
+};
+```
+
 Swift：
+
 ```swift
 /**
  * Definition for singly-linked list.

problems/链表理论基础.md

@@ -168,6 +168,32 @@ public class ListNode {
 }
 ```
 
+JavaScript:
+
+```javascript
+class ListNode {
+  val;
+  next = null;
+  constructor(value) {
+    this.val = value;
+    this.next = null;
+  }
+}
+```
+
+TypeScript:
+
+```typescript
+class ListNode {
+  public val: number;
+  public next: ListNode = null;
+  constructor(value: number) {
+    this.val = value;
+    this.next = null;
+  }
+}
+```
+
 Python：