Update

Author: youngyangyang04

problems/0001.两数之和.md

@@ -352,5 +352,86 @@ List<int> twoSum(List<int> nums, int target) {
 }
 ```
 
+C:
+```c
+
+
+/**
+ * Note: The returned array must be malloced, assume caller calls free().
+ */
+
+// leetcode 支持 ut_hash 函式庫
+
+ typedef struct {
+     int key;
+     int value;
+     UT_hash_handle hh; // make this structure hashable
+ } map;
+
+map* hashMap = NULL;
+
+ void hashMapAdd(int key, int value){
+     map* s;
+     // key already in the hash?
+     HASH_FIND_INT(hashMap, &key, s);
+     if(s == NULL){
+         s = (map*)malloc(sizeof(map));
+         s -> key = key;
+         HASH_ADD_INT(hashMap, key, s);
+     }
+     s -> value = value;
+ }
+
+map* hashMapFind(int key){
+     map* s;
+     // *s: output pointer
+     HASH_FIND_INT(hashMap, &key, s);   
+     return s;
+ }
+
+ void hashMapCleanup(){
+     map* cur, *tmp;
+     HASH_ITER(hh, hashMap, cur, tmp){
+         HASH_DEL(hashMap, cur);
+         free(cur);
+     }
+ }
+
+ void hashPrint(){
+     map* s;
+     for(s = hashMap; s != NULL; s=(map*)(s -> hh.next)){
+         printf("key %d, value %d\n", s -> key, s -> value);
+     }
+ }
+
+ 
+int* twoSum(int* nums, int numsSize, int target, int* returnSize){
+    int i, *ans;
+    // hash find result
+    map* hashMapRes; 
+    hashMap = NULL;
+    ans = malloc(sizeof(int) * 2);
+
+    for(i = 0; i < numsSize; i++){
+        // key 代表 nums[i] 的值，value 代表所在 index;
+        hashMapAdd(nums[i], i);
+    }
+
+    hashPrint();
+
+    for(i = 0; i < numsSize; i++){
+        hashMapRes = hashMapFind(target - nums[i]);
+        if(hashMapRes && hashMapRes -> value != i){
+            ans[0] = i;
+            ans[1] = hashMapRes -> value ;
+            *returnSize = 2;
+            return ans;
+        }
+    }
+    
+    hashMapCleanup();
+    return NULL;
+}
+```
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

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

@@ -75,7 +75,12 @@ public:
             fast = fast->next;
             slow = slow->next;
         }
-        slow->next = slow->next->next;
+        slow->next = slow->next->next; 
+        
+        // ListNode *tmp = slow->next;  C++释放内存的逻辑
+        // slow->next = tmp->next;
+        // delete nth;
+        
         return dummyHead->next;
     }
 };
@@ -87,30 +92,27 @@ public:
 java:
 
 ```java
-class Solution {
-    public ListNode removeNthFromEnd(ListNode head, int n) {
-        ListNode dummy = new ListNode(-1);
-        dummy.next = head;
-
-        ListNode slow = dummy;
-        ListNode fast = dummy;
-        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;
+public ListNode removeNthFromEnd(ListNode head, int n){
+    ListNode dummyNode = new ListNode(0);
+    dummyNode.next = head;
+
+    ListNode fastIndex = dummyNode;
+    ListNode slowIndex = dummyNode;
 
-        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;
 }
 ```
 
@@ -341,5 +343,28 @@ object Solution {
   }
 }
 ```
+
+Rust:
+```rust
+impl Solution {
+    pub fn remove_nth_from_end(head: Option<Box<ListNode>>, mut n: i32) -> Option<Box<ListNode>> {
+        let mut dummy_head = Box::new(ListNode::new(0));
+        dummy_head.next = head;
+        let mut fast = &dummy_head.clone();
+        let mut slow = &mut dummy_head;
+        while n > 0 {
+            fast = fast.next.as_ref().unwrap();
+            n -= 1;
+        }
+        while fast.next.is_some() {
+            fast = fast.next.as_ref().unwrap();
+            slow = slow.next.as_mut().unwrap();
+        }
+        slow.next = slow.next.as_mut().unwrap().next.take();
+        dummy_head.next
+    }
+}
+```
+
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

problems/0024.两两交换链表中的节点.md

@@ -380,5 +380,51 @@ function swapPairs($head)
 }
 ```
 
+Rust:
+
+```rust
+// 虚拟头节点
+impl Solution {
+    pub fn swap_pairs(head: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
+        let mut dummy_head = Box::new(ListNode::new(0));
+        dummy_head.next = head;
+        let mut cur = dummy_head.as_mut();
+        while let Some(mut node) = cur.next.take() {
+            if let Some(mut next) = node.next.take() {
+                node.next = next.next.take();
+                next.next = Some(node);
+                cur.next = Some(next);
+                cur = cur.next.as_mut().unwrap().next.as_mut().unwrap();
+            } else {
+                cur.next = Some(node);
+                cur = cur.next.as_mut().unwrap();
+            }
+        }
+        dummy_head.next
+    }
+}
+```
+
+```rust
+// 递归
+impl Solution {
+    pub fn swap_pairs(head: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
+        if head == None || head.as_ref().unwrap().next == None {
+            return head;
+        }
+
+        let mut node = head.unwrap();
+
+        if let Some(mut next) = node.next.take() {
+            node.next = Solution::swap_pairs(next.next);
+            next.next = Some(node);
+            Some(next)
+        } else {
+            Some(node)
+        }
+    }
+}
+```
+
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

problems/0035.搜索插入位置.md

@@ -429,7 +429,57 @@ function searchInsert($nums, $target)
     return $r + 1;
 }
 ```
-
+### C
+```c
+//版本一 [left, right]左闭右闭区间
+int searchInsert(int* nums, int numsSize, int target){
+    //左闭右开区间 [0 , numsSize-1] 
+        int left =0;
+        int mid =0;
+        int right = numsSize - 1;
+        while(left <= right){//左闭右闭区间 所以可以 left == right
+            mid = left + (right - left) / 2;
+            if(target < nums[mid]){
+        //target 在左区间 [left, mid - 1]中，原区间包含mid，右区间边界可以向左内缩
+                right = mid -1;
+            }else if( target > nums[mid]){
+        //target 在右区间 [mid + 1, right]中,原区间包含mid，左区间边界可以向右内缩
+                left = mid + 1;
+            }else {
+        // nums[mid] == target ，顺利找到target，直接返回mid
+                return mid;
+            }
+        }
+        //数组中未找到target元素
+        //target在数组所有元素之后，[left, right]是右闭区间，需要返回 right +1 
+        return right + 1;
+}
+```
+```c
+//版本二 [left, right]左闭右开区间
+int searchInsert(int* nums, int numsSize, int target){
+    //左闭右开区间 [0 , numsSize) 
+        int left =0;
+        int mid =0;
+        int right = numsSize;
+        while(left < right){//左闭右闭区间 所以 left < right
+            mid = left + (right - left) / 2;
+            if(target < nums[mid]){
+        //target 在左区间 [left, mid)中，原区间没有包含mid，右区间边界不能内缩
+                right = mid ;
+            }else if( target > nums[mid]){
+        // target 在右区间 [mid+1, right)中，原区间包含mid，左区间边界可以向右内缩
+                left = mid + 1;
+            }else {
+        // nums[mid] == target ，顺利找到target，直接返回mid
+                return mid;
+            }
+        }
+	//数组中未找到target元素
+        //target在数组所有元素之后，[left, right)是右开区间， return right即可
+        return right;
+}
+```
 
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

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