Merge remote-tracking branch 'upstream/master'

problems/0019.删除链表的倒数第N个节点.md

@@ -87,30 +87,27 @@ public:
 java:
 
 ```java
-class Solution {
+public ListNode removeNthFromEnd(ListNode head, int n){
-    public ListNode removeNthFromEnd(ListNode head, int n) {
+    ListNode dummyNode = new ListNode(0);
-        ListNode dummy = new ListNode(-1);
+    dummyNode.next = head;
-        dummy.next = head;
 
-        ListNode slow = dummy;
+    ListNode fastIndex = dummyNode;
-        ListNode fast = dummy;
+    ListNode slowIndex = dummyNode;
-        while (n-- > 0) {
-            fast = fast.next;
-        }
-        // 记住 待删除节点slow 的上一节点
-        ListNode prev = null;
-        while (fast != null) {
-            prev = slow;
-            slow = slow.next;
-            fast = fast.next;
-        }
-        // 上一节点的next指针绕过 待删除节点slow 直接指向slow的下一节点
-        prev.next = slow.next;
-        // 释放 待删除节点slow 的next指针, 这句删掉也能AC
-        slow.next = null;
 
-        return dummy.next;
+    //只要快慢指针相差 n 个结点即可
+    for (int i = 0; i < n  ; i++){
+        fastIndex = fastIndex.next;
     }
+
+    while (fastIndex.next != null){
+        fastIndex = fastIndex.next;
+        slowIndex = slowIndex.next;
+    }
+
+    //此时 slowIndex 的位置就是待删除元素的前一个位置。
+    //具体情况可自己画一个链表长度为 3 的图来模拟代码来理解
+    slowIndex.next = slowIndex.next.next;
+    return dummyNode.next;
 }
 ```
 

problems/0045.跳跃游戏II.md

@@ -214,7 +214,26 @@ class Solution:
         return ans
 ```
 
+```python
+# 贪心版本二
+class Solution:
+    def jump(self, nums: List[int]) -> int:
+        if len(nums) == 1:
+            return 0
+        curDistance, nextDistance = 0, 0
+        step = 0
+        for i in range(len(nums)-1):
+            nextDistance = max(nextDistance, nums[i]+i)
+            if i == curDistance:
+                curDistance = nextDistance
+                step += 1
+        return step
+```
+
+
+
 ### Go
+
 ```Go
 func jump(nums []int) int {
     dp := make([]int, len(nums))
@@ -240,7 +259,71 @@ func min(a, b int) int {
 }
 ```
 
+```go
+// 贪心版本一
+func jump(nums []int) int {
+    n := len(nums)
+    if n == 1 {
+        return 0
+    }
+    cur, next := 0, 0
+    step := 0
+    for i := 0; i < n; i++ {
+        next = max(nums[i]+i, next)
+        if i == cur {
+            if cur != n-1 {
+                step++
+                cur = next
+                if cur >= n-1 {
+                    return step
+                }
+            } else {
+                return step
+            }
+        }
+    }
+    return step
+}
+
+func max(a, b int) int {
+    if a > b {
+        return a
+    }
+    return b
+}
+```
+
+```go
+// 贪心版本二
+func jump(nums []int) int {
+    n := len(nums)
+    if n == 1 {
+        return 0
+    }
+    cur, next := 0, 0
+    step := 0
+    for i := 0; i < n-1; i++ {
+        next = max(nums[i]+i, next)
+        if i == cur {
+            cur = next
+            step++
+        }
+    }
+    return step
+}
+
+func max(a, b int) int {
+    if a > b {
+        return a
+    }
+    return b
+}
+```
+
+
+
 ### Javascript
+
 ```Javascript
 var jump = function(nums) {
     let curIndex = 0

problems/0055.跳跃游戏.md

@@ -139,7 +139,31 @@ func canJUmp(nums []int) bool {
 }
 ```
 
+```go
+// 贪心
+func canJump(nums []int) bool {
+    cover := 0
+    n := len(nums)-1
+    for i := 0; i <= cover; i++ { // 每次与覆盖值比较
+        cover = max(i+nums[i], cover) //每走一步都将 cover 更新为最大值
+        if cover >= n {
+            return true
+        }
+    }
+    return false
+}
+func max(a, b int ) int {
+    if a > b {
+        return a
+    }
+    return b
+}
+```
+
+
+
 ### Javascript 
+
 ```Javascript
 var canJump = function(nums) {
     if(nums.length === 1) return true

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

@@ -552,6 +552,29 @@ func maxdepth(root *treenode) int {
 
 ```
 
+### 559. n叉树的最大深度
+
+```go
+func maxDepth(root *Node) int {
+    if root == nil {
+        return 0
+    }
+    q := list.New()
+    q.PushBack(root)
+    depth := 0
+    for q.Len() > 0 {
+        n := q.Len()
+        for i := 0; i < n; i++ {
+            node := q.Remove(q.Front()).(*Node)
+            for j := range node.Children {
+                q.PushBack(node.Children[j])
+            }
+        }
+        depth++
+    }
+    return depth 
+}
+```
 
 ## javascript 
 

problems/0222.完全二叉树的节点个数.md

@@ -437,6 +437,33 @@ func countNodes(root *TreeNode) int {
 }
 ```
 
+迭代法
+
+```go
+func countNodes(root *TreeNode) int {
+    if root == nil {
+        return 0
+    }
+    q := list.New()
+    q.PushBack(root)
+    res := 0
+    for q.Len() > 0 {
+        n := q.Len()
+        for i := 0; i < n; i++ {
+            node := q.Remove(q.Front()).(*TreeNode)
+            if node.Left != nil {
+                q.PushBack(node.Left)
+            }
+            if node.Right != nil {
+                q.PushBack(node.Right)
+            }
+            res++
+        }
+    }
+    return res 
+}
+```
+
 
 
 ## JavaScript:

problems/链表理论基础.md

@@ -218,6 +218,22 @@ class ListNode(_x: Int = 0, _next: ListNode = null) {
 }
 ```
 
+Rust:
+```rust
+#[derive(PartialEq, Eq, Clone, Debug)]
+pub struct ListNode<T> {
+    pub val: T,
+    pub next: Option<Box<ListNode<T>>>,
+}
+
+impl<T> ListNode<T> {
+    #[inline]
+    fn new(val: T, node: Option<Box<ListNode<T>>>) -> Self {
+        ListNode { next: node, val }
+    }
+}
+```
+
 
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>