Merge branch 'youngyangyang04:master' into master

Author: weiting-cn

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

@@ -181,7 +181,71 @@ var removeNthFromEnd = function(head, n) {
     return ret.next;
 };
 ```
+TypeScript:
+
+版本一（快慢指针法）：
+
+```typescript
+function removeNthFromEnd(head: ListNode | null, n: number): ListNode | null {
+    let newHead: ListNode | null = new ListNode(0, head);
+    let slowNode: ListNode | null = newHead,
+        fastNode: ListNode | null = newHead;
+    for (let i = 0; i < n; i++) {
+        fastNode = fastNode.next;
+    }
+    while (fastNode.next) {
+        fastNode = fastNode.next;
+        slowNode = slowNode.next;
+    }
+    slowNode.next = slowNode.next.next;
+    return newHead.next;
+};
+```
+
+版本二（计算节点总数法）：
+
+```typescript
+function removeNthFromEnd(head: ListNode | null, n: number): ListNode | null {
+    let curNode: ListNode | null = head;
+    let listSize: number = 0;
+    while (curNode) {
+        curNode = curNode.next;
+        listSize++;
+    }
+    if (listSize === n) {
+        head = head.next;
+    } else {
+        curNode = head;
+        for (let i = 0; i < listSize - n - 1; i++) {
+            curNode = curNode.next;
+        }
+        curNode.next = curNode.next.next;
+    }
+    return head;
+};
+```
+
+版本三（递归倒退n法）：
+
+```typescript
+function removeNthFromEnd(head: ListNode | null, n: number): ListNode | null {
+    let newHead: ListNode | null = new ListNode(0, head);
+    let cnt = 0;
+    function recur(node) {
+        if (node === null) return;
+        recur(node.next);
+        cnt++;
+        if (cnt === n + 1) {
+            node.next = node.next.next;
+        }
+    }
+    recur(newHead);
+    return newHead.next;
+};
+```
+
 Kotlin:
+
 ```Kotlin
 fun removeNthFromEnd(head: ListNode?, n: Int): ListNode? {
     val pre = ListNode(0).apply {

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

@@ -250,6 +250,38 @@ var swapPairs = function (head) {
 };
 ```
 
+TypeScript：
+
+```typescript
+function swapPairs(head: ListNode | null): ListNode | null {
+    /**
+     * 初始状态：
+     * curNode -> node1 -> node2 -> tmepNode
+     * 转换过程：
+     * curNode -> node2
+     * curNode -> node2 -> node1
+     * curNode -> node2 -> node1 -> tempNode
+     * curNode = node1
+     */
+    let retNode: ListNode | null = new ListNode(0, head),
+        curNode: ListNode | null = retNode,
+        node1: ListNode | null = null,
+        node2: ListNode | null = null,
+        tempNode: ListNode | null = null;
+
+    while (curNode && curNode.next && curNode.next.next) {
+        node1 = curNode.next;
+        node2 = curNode.next.next;
+        tempNode = node2.next;
+        curNode.next = node2;
+        node2.next = node1;
+        node1.next = tempNode;
+        curNode = node1;
+    }
+    return retNode.next;
+};
+```
+
 Kotlin:
 
 ```kotlin

problems/0034.在排序数组中查找元素的第一个和最后一个位置.md

@@ -389,6 +389,51 @@ class Solution:
 ### Go
 
 ```go
+func searchRange(nums []int, target int) []int {
+    leftBorder := getLeft(nums, target)
+    rightBorder := getRight(nums, target)
+    // 情况一
+    if leftBorder == -2 || rightBorder == -2 {
+        return []int{-1, -1}
+    }
+    // 情况三
+    if rightBorder - leftBorder > 1 {
+        return []int{leftBorder + 1, rightBorder - 1}
+    }
+    // 情况二
+    return []int{-1, -1}
+}
+
+func getLeft(nums []int, target int) int {
+    left, right := 0, len(nums)-1
+    border := -2 // 记录border没有被赋值的情况；这里不能赋值-1，target = num[0]时，会无法区分情况一和情况二
+    for left <= right { // []闭区间
+	mid := left + ((right - left) >> 1)
+	if nums[mid] >= target { // 找到第一个等于target的位置
+	    right = mid - 1
+            border = right
+	} else {
+	    left =  mid + 1
+	}
+    }
+    return border
+}
+
+func getRight(nums []int, target int) int {
+    left, right := 0, len(nums) - 1
+    border := -2
+    for left <= right {
+	mid := left + ((right - left) >> 1)
+	if nums[mid] > target { 
+		right = mid - 1
+	} else { // 找到第一个大于target的位置
+	    left = mid + 1
+            border = left
+	}
+    }
+    return border
+
+}
 ```
 
 ### JavaScript

problems/0059.螺旋矩阵II.md

@@ -287,6 +287,51 @@ var generateMatrix = function(n) {
 
 ```
 
+TypeScript:
+
+```typescript
+function generateMatrix(n: number): number[][] {
+    let loopNum: number = Math.floor(n / 2);
+    const resArr: number[][] = new Array(n).fill(1).map(i => new Array(n));
+    let chunkNum: number = n - 1;
+    let startX: number = 0;
+    let startY: number = 0;
+    let value: number = 1;
+    let x: number, y: number;
+    while (loopNum--) {
+        x = startX;
+        y = startY;
+        while (x < startX + chunkNum) {
+            resArr[y][x] = value;
+            x++;
+            value++;
+        }
+        while (y < startY + chunkNum) {
+            resArr[y][x] = value;
+            y++;
+            value++;
+        }
+        while (x > startX) {
+            resArr[y][x] = value;
+            x--;
+            value++;
+        }
+        while (y > startY) {
+            resArr[y][x] = value;
+            y--;
+            value++;
+        }
+        startX++;
+        startY++;
+        chunkNum -= 2;
+    }
+    if (n % 2 === 1) {
+        resArr[startX][startY] = value;
+    }
+    return resArr;
+};
+```
+
 Go:
 
 ```go

problems/0062.不同路径.md

@@ -347,6 +347,42 @@ var uniquePaths = function(m, n) {
 };
 ```
 
+### C
+```c
+//初始化dp数组
+int **initDP(int m, int n) {
+    //动态开辟dp数组
+    int **dp = (int**)malloc(sizeof(int *) * m);
+    int i, j;
+    for(i = 0; i < m; ++i) {
+        dp[i] = (int *)malloc(sizeof(int) * n);
+    }
+
+    //从0，0到i,0只有一种走法，所以dp[i][0]都是1，同理dp[0][j]也是1
+    for(i = 0; i < m; ++i) 
+        dp[i][0] = 1;
+    for(j = 0; j < n; ++j) 
+        dp[0][j] = 1;
+    return dp;
+}
+
+int uniquePaths(int m, int n){
+    //dp数组，dp[i][j]代表从dp[0][0]到dp[i][j]有几种走法
+    int **dp = initDP(m, n);
+
+    int i, j;
+    //到达dp[i][j]只能从dp[i-1][j]和dp[i][j-1]出发
+    //dp[i][j] = dp[i-1][j] + dp[i][j-1]
+    for(i = 1; i < m; ++i) {
+        for(j = 1; j < n; ++j) {
+            dp[i][j] = dp[i-1][j] + dp[i][j-1];
+        }
+    }
+    int result = dp[m-1][n-1];
+    free(dp);
+    return result;
+}
+```
 
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

problems/0063.不同路径II.md

@@ -333,6 +333,60 @@ var uniquePathsWithObstacles = function(obstacleGrid) {
 };
 ```
 
+C
+```c
+//初始化dp数组
+int **initDP(int m, int n, int** obstacleGrid) {
+    int **dp = (int**)malloc(sizeof(int*) * m);
+    int i, j;
+    //初始化每一行数组
+    for(i = 0; i < m; ++i) {
+        dp[i] = (int*)malloc(sizeof(int) * n);
+    }
+
+    //先将第一行第一列设为0
+    for(i = 0; i < m; ++i) {
+        dp[i][0] = 0;
+    }
+    for(j = 0; j < n; ++j) {
+        dp[0][j] = 0;
+    }
+
+    //若碰到障碍，之后的都走不了。退出循环
+    for(i = 0; i < m; ++i) {
+        if(obstacleGrid[i][0]) {
+            break;
+        }
+        dp[i][0] = 1;
+    }
+    for(j = 0; j < n; ++j) {
+        if(obstacleGrid[0][j])
+            break;
+        dp[0][j] = 1;
+    }
+    return dp;
+}
+
+int uniquePathsWithObstacles(int** obstacleGrid, int obstacleGridSize, int* obstacleGridColSize){
+    int m = obstacleGridSize, n = *obstacleGridColSize;
+    //初始化dp数组
+    int **dp = initDP(m, n, obstacleGrid);
+
+    int i, j;
+    for(i = 1; i < m; ++i) {
+        for(j = 1; j < n; ++j) {
+            //若当前i,j位置有障碍
+            if(obstacleGrid[i][j])
+                //路线不同
+                dp[i][j] = 0;
+            else
+                dp[i][j] = dp[i-1][j] + dp[i][j-1];
+        }
+    }
+    //返回最后终点的路径个数
+    return dp[m-1][n-1];
+}
+```
 
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

problems/0070.爬楼梯.md

@@ -296,6 +296,48 @@ var climbStairs = function(n) {
 };
 ```
 
+### C
+```c
+int climbStairs(int n){
+    //若n<=2，返回n
+    if(n <= 2)
+        return n;
+    //初始化dp数组，数组大小为n+1
+    int *dp = (int *)malloc(sizeof(int) * (n + 1));
+    dp[0] = 0, dp[1] = 1, dp[2] = 2;
+
+    //从前向后遍历数组，dp[i] = dp[i-1] + dp[i-2]
+    int i;
+    for(i = 3; i <= n; ++i) {
+        dp[i] = dp[i - 1] + dp[i - 2];
+    }
+    //返回dp[n]
+    return dp[n];
+}
+```
+
+优化空间复杂度：
+```c
+int climbStairs(int n){
+    //若n<=2，返回n
+    if(n <= 2)
+        return n;
+    //初始化dp数组，数组大小为3
+    int *dp = (int *)malloc(sizeof(int) * 3);
+    dp[1] = 1, dp[2] = 2;
+
+    //只记录前面两个台阶的状态
+    int i;
+    for(i = 3; i <= n; ++i) {
+        int sum = dp[1] + dp[2];
+        dp[1] = dp[2];
+        dp[2] = sum;
+    }
+    //返回dp[2]
+    return dp[2];
+}
+```
+
 
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>