Merge branch 'youngyangyang04:master' into master

Author: kingemma

README.md

@@ -299,24 +299,25 @@
 <img src='https://code-thinking.cdn.bcebos.com/pics/动态规划-背包问题总结.png' width=500 alt='背包问题大纲'> </img></div>
 
 
-11. [动态规划：01背包理论基础](./problems/背包理论基础01背包-1.md)
-12. [动态规划：01背包理论基础（滚动数组）](./problems/背包理论基础01背包-2.md)
+11. [动态规划：01背包理论基础（二维dp数组）](./problems/背包理论基础01背包-1.md)
+12. [动态规划：01背包理论基础（一维dp数组）](./problems/背包理论基础01背包-2.md)
 13. [动态规划：416.分割等和子集](./problems/0416.分割等和子集.md)
 14. [动态规划：1049.最后一块石头的重量II](./problems/1049.最后一块石头的重量II.md)
 15. [本周小结！（动态规划系列三）](./problems/周总结/20210121动规周末总结.md)
 16. [动态规划：494.目标和](./problems/0494.目标和.md)
 17. [动态规划：474.一和零](./problems/0474.一和零.md) 
-18. [动态规划：完全背包总结篇](./problems/背包问题理论基础完全背包.md)
-19. [动态规划：518.零钱兑换II](./problems/0518.零钱兑换II.md)
-20. [本周小结！（动态规划系列四）](./problems/周总结/20210128动规周末总结.md)
-21. [动态规划：377.组合总和Ⅳ](./problems/0377.组合总和Ⅳ.md)
-22. [动态规划：70.爬楼梯（完全背包版本）](./problems/0070.爬楼梯完全背包版本.md)
-23. [动态规划：322.零钱兑换](./problems/0322.零钱兑换.md)
-24. [动态规划：279.完全平方数](./problems/0279.完全平方数.md)
-25. [本周小结！（动态规划系列五）](./problems/周总结/20210204动规周末总结.md)
-26. [动态规划：139.单词拆分](./problems/0139.单词拆分.md)
-27. [动态规划：多重背包理论基础](./problems/背包问题理论基础多重背包.md)
-28. [背包问题总结篇](./problems/背包总结篇.md)
+18. [动态规划：完全背包理论基础（二维dp数组）](./problems/背包问题理论基础完全背包.md)
+19. [动态规划：完全背包理论基础（一维dp数组）](./problems/背包问题完全背包一维.md)
+20. [动态规划：518.零钱兑换II](./problems/0518.零钱兑换II.md)
+21. [本周小结！（动态规划系列四）](./problems/周总结/20210128动规周末总结.md)
+22. [动态规划：377.组合总和Ⅳ](./problems/0377.组合总和Ⅳ.md)
+23. [动态规划：70.爬楼梯（完全背包版本）](./problems/0070.爬楼梯完全背包版本.md)
+24. [动态规划：322.零钱兑换](./problems/0322.零钱兑换.md)
+25. [动态规划：279.完全平方数](./problems/0279.完全平方数.md)
+26. [本周小结！（动态规划系列五）](./problems/周总结/20210204动规周末总结.md)
+27. [动态规划：139.单词拆分](./problems/0139.单词拆分.md)
+28. [动态规划：多重背包理论基础](./problems/背包问题理论基础多重背包.md)
+29. [背包问题总结篇](./problems/背包总结篇.md)
 
 打家劫舍系列：
 
@@ -408,21 +409,6 @@
 
 （持续更新中....）
 
-
-## 十大排序
-
-## 数论 
-
-## 高级数据结构经典题目 
-
-* 并查集 
-* 最小生成树 
-* 线段树 
-* 树状数组 
-* 字典树 
-
-## 海量数据处理
-
 # 补充题目
 
 以上题目是重中之重，大家至少要刷两遍以上才能彻底理解，如果熟练以上题目之后还在找其他题目练手，可以再刷以下题目：

problems/0070.爬楼梯.md

@@ -130,8 +130,8 @@ public:
 };
 ```
 
-* 时间复杂度：$O(n)$
-* 空间复杂度：$O(n)$
+* 时间复杂度：O(n)
+* 空间复杂度：O(n)
 
 当然依然也可以，优化一下空间复杂度，代码如下：
 
@@ -154,8 +154,8 @@ public:
 };
 ```
 
-* 时间复杂度：$O(n)$
-* 空间复杂度：$O(1)$
+* 时间复杂度：O(n)
+* 空间复杂度：O(1)
 
 后面将讲解的很多动规的题目其实都是当前状态依赖前两个，或者前三个状态，都可以做空间上的优化，**但我个人认为面试中能写出版本一就够了哈，清晰明了，如果面试官要求进一步优化空间的话，我们再去优化**。
 
@@ -524,3 +524,4 @@ impl Solution {
 <a href="https://programmercarl.com/other/kstar.html" target="_blank">
   <img src="../pics/网站星球宣传海报.jpg" width="1000"/>
 </a>
+

problems/0111.二叉树的最小深度.md

@@ -40,7 +40,7 @@
 本题依然是前序遍历和后序遍历都可以，前序求的是深度，后序求的是高度。
 
 * 二叉树节点的深度：指从根节点到该节点的最长简单路径边的条数或者节点数（取决于深度从0开始还是从1开始）
-* 二叉树节点的高度：指从该节点到叶子节点的最长简单路径边的条数后者节点数（取决于高度从0开始还是从1开始）
+* 二叉树节点的高度：指从该节点到叶子节点的最长简单路径边的条数或者节点数（取决于高度从0开始还是从1开始）
 
 那么使用后序遍历，其实求的是根节点到叶子节点的最小距离，就是求高度的过程，不过这个最小距离 也同样是最小深度。
 

problems/0150.逆波兰表达式求值.md

@@ -188,34 +188,21 @@ class Solution(object):
         return stack.pop()
 ```
 
-另一种可行，但因为使用eval相对较慢的方法:
+另一种可行，但因为使用eval()相对较慢的方法:
 ```python
-from operator import add, sub, mul
-
-def div(x, y):
-    # 使用整数除法的向零取整方式
-    return int(x / y) if x * y > 0 else -(abs(x) // abs(y))
-
 class Solution(object):
-    op_map = {'+': add, '-': sub, '*': mul, '/': div}
-
-    def evalRPN(self, tokens):
-        """
-        :type tokens: List[str]
-        :rtype: int
-        """
+    def evalRPN(self, tokens: List[str]) -> int:
         stack = []
         for token in tokens:
-            if token in self.op_map:
-                op1 = stack.pop()
-                op2 = stack.pop()
-                operation = self.op_map[token]
-                stack.append(operation(op2, op1))
+            # 判断是否为数字，因为isdigit()不识别负数，故需要排除第一位的符号
+            if token.isdigit() or (len(token)>1 and token[1].isdigit()):
+                stack.append(token)
             else:
-                stack.append(int(token))
-        return stack.pop()
-
-
+                op2 = stack.pop()
+                op1 = stack.pop()
+		# 由题意"The division always truncates toward zero"，所以使用int()可以天然取整
+                stack.append(str(int(eval(op1 + token + op2))))
+        return int(stack.pop())
 ```
 
 ### Go:
@@ -502,6 +489,67 @@ impl Solution {
 }
 ```
 
+### C:
+
+```c
+int str_to_int(char *str) {
+    // string转integer
+    int num = 0, tens = 1;
+    for (int i = strlen(str) - 1; i >= 0; i--) {
+        if (str[i] == '-') {
+            num *= -1;
+            break;
+        }
+        num += (str[i] - '0') * tens;
+        tens *= 10;
+    }
+    return num;
+}
+
+int evalRPN(char** tokens, int tokensSize) {
+
+    int *stack = (int *)malloc(tokensSize * sizeof(int));
+    assert(stack);
+    int stackTop = 0;
+
+    for (int i = 0; i < tokensSize; i++) {
+        char symbol = (tokens[i])[0];
+        if (symbol < '0' && (tokens[i])[1] == '\0') {
+
+            // pop两个数字
+            int num1 = stack[--stackTop];
+            int num2 = stack[--stackTop];
+
+            // 计算结果
+            int result;
+            if (symbol == '+') {
+                result = num1 + num2;
+            } else if (symbol == '-') {
+                result = num2 - num1;
+            } else if (symbol == '/') {
+                result = num2 / num1;
+            } else {
+                result = num1 * num2;
+            }
+
+            // push回stack
+            stack[stackTop++] = result;
+
+        } else {
+
+            // push数字进stack
+            int num = str_to_int(tokens[i]);
+            stack[stackTop++] = num;
+            
+        }
+    }
+
+    int result = stack[0];
+    free(stack);
+    return result;
+}
+```
+
 <p align="center">
 <a href="https://programmercarl.com/other/kstar.html" target="_blank">
   <img src="../pics/网站星球宣传海报.jpg" width="1000"/>

problems/0225.用队列实现栈.md

@@ -1277,6 +1277,95 @@ impl MyStack {
 }
 ```
 
+### C:
+
+> C：单队列
+
+```c
+typedef struct Node {
+    int val;
+    struct Node *next;
+} Node_t;
+
+// 用单向链表实现queue
+typedef struct {
+    Node_t *head;
+    Node_t *foot;
+    int size;
+} MyStack;
+
+MyStack* myStackCreate() {
+    MyStack *obj = (MyStack *)malloc(sizeof(MyStack));
+    assert(obj);
+    obj->head = NULL;
+    obj->foot = NULL;
+    obj->size = 0;
+    return obj;
+}
+
+void myStackPush(MyStack* obj, int x) {
+
+    Node_t *temp = (Node_t *)malloc(sizeof(Node_t));
+    assert(temp);
+    temp->val = x;
+    temp->next = NULL;
+
+    // 添加至queue末尾
+    if (obj->foot) {
+        obj->foot->next = temp;
+    } else {
+        obj->head = temp;
+    }
+    obj->foot = temp;
+    obj->size++;
+}
+
+int myStackPop(MyStack* obj) {
+
+    // 获取末尾元素
+    int target = obj->foot->val;
+
+    if (obj->head == obj->foot) {
+        free(obj->foot);
+        obj->head = NULL;
+        obj->foot = NULL;
+    } else {
+        
+        Node_t *prev = obj->head;
+        // 移动至queue尾部节点前一个节点
+        while (prev->next != obj->foot) {
+            prev = prev->next;
+        }
+
+        free(obj->foot);
+        obj->foot = prev;
+        obj->foot->next = NULL;
+    }
+
+    obj->size--;
+    return target;
+}
+
+int myStackTop(MyStack* obj) {
+    return obj->foot->val;
+}
+
+bool myStackEmpty(MyStack* obj) {
+    return obj->size == 0;
+}
+
+void myStackFree(MyStack* obj) {
+    Node_t *curr = obj->head;
+    while (curr != NULL) {
+        Node_t *temp = curr->next;
+        free(curr);
+        curr = temp;
+    }
+    free(obj);
+}
+
+```
+
 
 <p align="center">
 <a href="https://programmercarl.com/other/kstar.html" target="_blank">

problems/0235.二叉搜索树的最近公共祖先.md

@@ -99,7 +99,7 @@ if (cur == NULL) return cur;
 
 * 确定单层递归的逻辑
 
-在遍历二叉搜索树的时候就是寻找区间[p->val, q->val]（注意这里是左闭又闭）
+在遍历二叉搜索树的时候就是寻找区间[p->val, q->val]（注意这里是左闭右闭）
 
 那么如果 cur->val 大于 p->val，同时 cur->val 大于q->val，那么就应该向左遍历（说明目标区间在左子树上）。
 

problems/0239.滑动窗口最大值.md

@@ -890,6 +890,38 @@ public:
 };
 ```
 
+### C
+
+```c
+int* maxSlidingWindow(int* nums, int numsSize, int k, int* returnSize) {
+    *returnSize = numsSize - k + 1;
+    int *res = (int*)malloc((*returnSize) * sizeof(int));
+    assert(res);
+    int *deque = (int*)malloc(numsSize * sizeof(int));
+    assert(deque);
+    int front = 0, rear = 0, idx = 0;
+
+    for (int i  = 0 ; i < numsSize ; i++) {
+        while (front < rear && deque[front] <= i - k) {
+            front++;
+        }
+
+        while (front < rear && nums[deque[rear - 1]] <= nums[i]) {
+            rear--;
+        }
+
+        deque[rear++] = i;
+
+        if (i >= k - 1) {
+            res[idx++] = nums[deque[front]];
+        }
+    }       
+
+    return res;
+}
+
+```
+
 <p align="center">
 <a href="https://programmercarl.com/other/kstar.html" target="_blank">
   <img src="../pics/网站星球宣传海报.jpg" width="1000"/>

problems/0349.两个数组的交集.md

@@ -123,6 +123,9 @@ public:
 ### Java：
 版本一：使用HashSet
 ```Java
+// 时间复杂度O(n+m+k) 空间复杂度O(n+k)
+// 其中n是数组nums1的长度，m是数组nums2的长度，k是交集元素的个数
+
 import java.util.HashSet;
 import java.util.Set;
 
@@ -145,8 +148,15 @@ class Solution {
         }
 
         //方法1：将结果集合转为数组
-
-        return resSet.stream().mapToInt(x -> x).toArray();
+        return res.stream().mapToInt(Integer::intValue).toArray();
+        /**
+         * 将 Set<Integer> 转换为 int[] 数组：
+         * 1. stream() : Collection 接口的方法，将集合转换为 Stream<Integer>
+         * 2. mapToInt(Integer::intValue) : 
+         *    - 中间操作，将 Stream<Integer> 转换为 IntStream
+         *    - 使用方法引用 Integer::intValue，将 Integer 对象拆箱为 int 基本类型
+         * 3. toArray() : 终端操作，将 IntStream 转换为 int[] 数组。
+         */
 
         //方法2：另外申请一个数组存放setRes中的元素,最后返回数组
         int[] arr = new int[resSet.size()];
@@ -538,3 +548,4 @@ end
 <a href="https://programmercarl.com/other/kstar.html" target="_blank">
   <img src="../pics/网站星球宣传海报.jpg" width="1000"/>
 </a>
+