Merge branch 'master' of github.com:youngyangyang04/leetcode-master

Author: youngyangyang04

problems/0017.电话号码的字母组合.md

@@ -180,7 +180,7 @@ public:
     }
 };
 ```
-* 时间复杂度: O(3^m * 4^n)，其中 m 是对应四个字母的数字个数，n 是对应三个字母的数字个数
+* 时间复杂度: O(3^m * 4^n)，其中 m 是对应三个字母的数字个数，n 是对应四个字母的数字个数
 * 空间复杂度: O(3^m * 4^n)
 
 一些写法，是把回溯的过程放在递归函数里了，例如如下代码，我可以写成这样：（注意注释中不一样的地方）

problems/0054.螺旋矩阵.md

@@ -348,6 +348,82 @@ class Solution(object):
         return print_list
 ```
 
+### Go
+
+```go
+func spiralOrder(matrix [][]int) []int {
+    rows := len(matrix)
+    if rows == 0 {
+        return []int{}
+    }
+    columns := len(matrix[0])
+    if columns == 0 {
+        return []int{}
+    }
+    res := make([]int, rows * columns)
+    startx, starty := 0, 0 // 定义每循环一个圈的起始位置
+    loop := min(rows, columns) / 2
+    mid := min(rows, columns) / 2
+    count := 0 // 用来给矩阵中每一个空格赋值
+    offset := 1 // 每一圈循环，需要控制每一条边遍历的长度
+    for loop > 0 {
+        i, j := startx, starty
+		
+        // 模拟填充上行从左到右(左闭右开)
+        for ; j < starty + columns - offset; j++ {
+            res[count] = matrix[startx][j]
+            count++
+        }
+        // 模拟填充右列从上到下(左闭右开)
+        for ; i < startx + rows - offset; i++ {
+            res[count] = matrix[i][j]
+            count++
+        }
+        // 模拟填充下行从右到左(左闭右开)
+        for ; j > starty; j-- {
+            res[count] = matrix[i][j]
+            count++
+        }
+        // 模拟填充左列从下到上(左闭右开)
+        for ; i > startx; i-- {
+            res[count] = matrix[i][starty]
+            count++
+        }
+        
+        // 第二圈开始的时候，起始位置要各自加1， 例如：第一圈起始位置是(0, 0)，第二圈起始位置是(1, 1)
+        startx++
+        starty++
+        
+        // offset 控制每一圈里每一条边遍历的长度
+        offset += 2
+        loop--
+    }
+    
+    // 如果min(rows, columns)为奇数的话，需要单独给矩阵最中间的位置赋值
+    if min(rows, columns) % 2 == 1 {
+        if rows > columns {
+            for i := mid; i < mid + rows - columns + 1; i++ {
+                res[count] = matrix[i][mid]
+                count++
+            }
+        } else {
+            for i := mid; i < mid + columns - rows + 1; i++ {
+                res[count] = matrix[mid][i]
+                count++
+            }
+        }
+    }
+    return res
+}
+
+func min(x, y int) int {
+    if x < y {
+        return x
+    }
+    return y
+}
+```
+
 
 <p align="center">
 <a href="https://programmercarl.com/other/kstar.html" target="_blank">

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

@@ -829,7 +829,42 @@ int maxDepth(struct TreeNode* root){
     return depth;
 }
 ```
-
+二叉树最大深度迭代——后序遍历实现
+```c
+int maxDepth(struct TreeNode *root)
+{
+    if(root == NULL)
+        return 0;
+    struct TreeNode *stack[10000] = {};
+    int top = -1;
+    struct TreeNode *p = root, *r = NULL; // r指向上一个被访问的结点
+    int depth = 0, maxDepth = -1;
+    while(p != NULL || top >= 0)
+    {
+        if(p != NULL)
+        {
+            stack[++top] = p;
+            depth++;
+            p = p->left;
+        }
+        else
+        {
+            p = stack[top];
+            if(p->right != NULL && p->right != r) // 右子树未被访问
+                p = p->right;
+            else
+            {
+                if(depth >= maxDepth) maxDepth = depth;
+                p = stack[top--];
+                depth--;
+                r = p;
+                p = NULL;
+            }
+        }
+    }
+    return maxDepth;
+}
+```
 ### Swift:
 
 104.二叉树的最大深度

problems/kamacoder/0055.右旋字符串.md

@@ -253,6 +253,47 @@ func main(){
 ```
 
 
+### C：
+```C
+#include <stdio.h>
+#include <string.h>
+
+void reverse(char *s, int left, int right)
+{
+    while(left <= right)
+    {
+        char c = s[left];
+        s[left] = s[right];
+        s[right] = c;
+        left++;
+        right--;
+    }
+}
+
+void rightRotate(char *s, int k)
+{
+    int len = strlen(s);
+    // 先局部反转再整体反转
+    reverse(s, 0, len - k - 1);   // 反转前部分
+    reverse(s, len - k, len - 1); // 反转后部分：后k位
+    reverse(s, 0, len - 1);       // 整体反转
+}
+
+int main()
+{
+
+    int k;
+    scanf("%d", &k);
+    char s[10000];
+    scanf("%s", s);
+
+    rightRotate(s, k);
+    printf("%s\n", s);
+
+    return 0;
+}
+```
+
 ### JavaScript：