Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

Commit 22d8b82

Browse files
Merge branch 'youngyangyang04:master' into master
2 parents 173ebe7 + 6731702 commit 22d8b82

23 files changed

+1033
-532
lines changed

‎README.md‎

Lines changed: 14 additions & 28 deletions
Original file line numberDiff line numberDiff line change
@@ -299,24 +299,25 @@
299299
<img src='https://code-thinking.cdn.bcebos.com/pics/动态规划-背包问题总结.png' width=500 alt='背包问题大纲'> </img></div>
300300

301301

302-
11. [动态规划:01背包理论基础](./problems/背包理论基础01背包-1.md)
303-
12. [动态规划:01背包理论基础(滚动数组)](./problems/背包理论基础01背包-2.md)
302+
11. [动态规划:01背包理论基础(二维dp数组)](./problems/背包理论基础01背包-1.md)
303+
12. [动态规划:01背包理论基础(一维dp数组)](./problems/背包理论基础01背包-2.md)
304304
13. [动态规划:416.分割等和子集](./problems/0416.分割等和子集.md)
305305
14. [动态规划:1049.最后一块石头的重量II](./problems/1049.最后一块石头的重量II.md)
306306
15. [本周小结!(动态规划系列三)](./problems/周总结/20210121动规周末总结.md)
307307
16. [动态规划:494.目标和](./problems/0494.目标和.md)
308308
17. [动态规划:474.一和零](./problems/0474.一和零.md)
309-
18. [动态规划:完全背包总结篇](./problems/背包问题理论基础完全背包.md)
310-
19. [动态规划:518.零钱兑换II](./problems/0518.零钱兑换II.md)
311-
20. [本周小结!(动态规划系列四)](./problems/周总结/20210128动规周末总结.md)
312-
21. [动态规划:377.组合总和IV](./problems/0377.组合总和IV.md)
313-
22. [动态规划:70.爬楼梯(完全背包版本)](./problems/0070.爬楼梯完全背包版本.md)
314-
23. [动态规划:322.零钱兑换](./problems/0322.零钱兑换.md)
315-
24. [动态规划:279.完全平方数](./problems/0279.完全平方数.md)
316-
25. [本周小结!(动态规划系列五)](./problems/周总结/20210204动规周末总结.md)
317-
26. [动态规划:139.单词拆分](./problems/0139.单词拆分.md)
318-
27. [动态规划:多重背包理论基础](./problems/背包问题理论基础多重背包.md)
319-
28. [背包问题总结篇](./problems/背包总结篇.md)
309+
18. [动态规划:完全背包理论基础(二维dp数组)](./problems/背包问题理论基础完全背包.md)
310+
19. [动态规划:完全背包理论基础(一维dp数组)](./problems/背包问题完全背包一维.md)
311+
20. [动态规划:518.零钱兑换II](./problems/0518.零钱兑换II.md)
312+
21. [本周小结!(动态规划系列四)](./problems/周总结/20210128动规周末总结.md)
313+
22. [动态规划:377.组合总和IV](./problems/0377.组合总和IV.md)
314+
23. [动态规划:70.爬楼梯(完全背包版本)](./problems/0070.爬楼梯完全背包版本.md)
315+
24. [动态规划:322.零钱兑换](./problems/0322.零钱兑换.md)
316+
25. [动态规划:279.完全平方数](./problems/0279.完全平方数.md)
317+
26. [本周小结!(动态规划系列五)](./problems/周总结/20210204动规周末总结.md)
318+
27. [动态规划:139.单词拆分](./problems/0139.单词拆分.md)
319+
28. [动态规划:多重背包理论基础](./problems/背包问题理论基础多重背包.md)
320+
29. [背包问题总结篇](./problems/背包总结篇.md)
320321

321322
打家劫舍系列:
322323

@@ -408,21 +409,6 @@
408409

409410
(持续更新中....)
410411

411-
412-
## 十大排序
413-
414-
## 数论
415-
416-
## 高级数据结构经典题目
417-
418-
* 并查集
419-
* 最小生成树
420-
* 线段树
421-
* 树状数组
422-
* 字典树
423-
424-
## 海量数据处理
425-
426412
# 补充题目
427413

428414
以上题目是重中之重,大家至少要刷两遍以上才能彻底理解,如果熟练以上题目之后还在找其他题目练手,可以再刷以下题目:

‎problems/0070.爬楼梯.md‎

Lines changed: 5 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -130,8 +130,8 @@ public:
130130
};
131131
```
132132
133-
* 时间复杂度:$O(n)$
134-
* 空间复杂度:$O(n)$
133+
* 时间复杂度:O(n)
134+
* 空间复杂度:O(n)
135135
136136
当然依然也可以,优化一下空间复杂度,代码如下:
137137
@@ -154,8 +154,8 @@ public:
154154
};
155155
```
156156

157-
* 时间复杂度:$O(n)$
158-
* 空间复杂度:$O(1)$
157+
* 时间复杂度:O(n)
158+
* 空间复杂度:O(1)
159159

160160
后面将讲解的很多动规的题目其实都是当前状态依赖前两个,或者前三个状态,都可以做空间上的优化,**但我个人认为面试中能写出版本一就够了哈,清晰明了,如果面试官要求进一步优化空间的话,我们再去优化**。
161161

@@ -524,3 +524,4 @@ impl Solution {
524524
<a href="https://programmercarl.com/other/kstar.html" target="_blank">
525525
<img src="../pics/网站星球宣传海报.jpg" width="1000"/>
526526
</a>
527+

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

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -40,7 +40,7 @@
4040
本题依然是前序遍历和后序遍历都可以,前序求的是深度,后序求的是高度。
4141

4242
* 二叉树节点的深度:指从根节点到该节点的最长简单路径边的条数或者节点数(取决于深度从0开始还是从1开始)
43-
* 二叉树节点的高度:指从该节点到叶子节点的最长简单路径边的条数后者节点数(取决于高度从0开始还是从1开始)
43+
* 二叉树节点的高度:指从该节点到叶子节点的最长简单路径边的条数或者节点数(取决于高度从0开始还是从1开始)
4444

4545
那么使用后序遍历,其实求的是根节点到叶子节点的最小距离,就是求高度的过程,不过这个最小距离 也同样是最小深度。
4646

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

Lines changed: 71 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -188,34 +188,21 @@ class Solution(object):
188188
return stack.pop()
189189
```
190190

191-
另一种可行,但因为使用eval相对较慢的方法:
191+
另一种可行,但因为使用eval()相对较慢的方法:
192192
```python
193-
from operator import add, sub, mul
194-
195-
def div(x, y):
196-
# 使用整数除法的向零取整方式
197-
return int(x / y) if x * y > 0 else -(abs(x) // abs(y))
198-
199193
class Solution(object):
200-
op_map = {'+': add, '-': sub, '*': mul, '/': div}
201-
202-
def evalRPN(self, tokens):
203-
"""
204-
:type tokens: List[str]
205-
:rtype: int
206-
"""
194+
def evalRPN(self, tokens: List[str]) -> int:
207195
stack = []
208196
for token in tokens:
209-
if token in self.op_map:
210-
op1 = stack.pop()
211-
op2 = stack.pop()
212-
operation = self.op_map[token]
213-
stack.append(operation(op2, op1))
197+
# 判断是否为数字,因为isdigit()不识别负数,故需要排除第一位的符号
198+
if token.isdigit() or (len(token)>1 and token[1].isdigit()):
199+
stack.append(token)
214200
else:
215-
stack.append(int(token))
216-
return stack.pop()
217-
218-
201+
op2 = stack.pop()
202+
op1 = stack.pop()
203+
# 由题意"The division always truncates toward zero",所以使用int()可以天然取整
204+
stack.append(str(int(eval(op1 + token + op2))))
205+
return int(stack.pop())
219206
```
220207

221208
### Go:
@@ -502,6 +489,67 @@ impl Solution {
502489
}
503490
```
504491

492+
### C:
493+
494+
```c
495+
int str_to_int(char *str) {
496+
// string转integer
497+
int num = 0, tens = 1;
498+
for (int i = strlen(str) - 1; i >= 0; i--) {
499+
if (str[i] == '-') {
500+
num *= -1;
501+
break;
502+
}
503+
num += (str[i] - '0') * tens;
504+
tens *= 10;
505+
}
506+
return num;
507+
}
508+
509+
int evalRPN(char** tokens, int tokensSize) {
510+
511+
int *stack = (int *)malloc(tokensSize * sizeof(int));
512+
assert(stack);
513+
int stackTop = 0;
514+
515+
for (int i = 0; i < tokensSize; i++) {
516+
char symbol = (tokens[i])[0];
517+
if (symbol < '0' && (tokens[i])[1] == '0円') {
518+
519+
// pop两个数字
520+
int num1 = stack[--stackTop];
521+
int num2 = stack[--stackTop];
522+
523+
// 计算结果
524+
int result;
525+
if (symbol == '+') {
526+
result = num1 + num2;
527+
} else if (symbol == '-') {
528+
result = num2 - num1;
529+
} else if (symbol == '/') {
530+
result = num2 / num1;
531+
} else {
532+
result = num1 * num2;
533+
}
534+
535+
// push回stack
536+
stack[stackTop++] = result;
537+
538+
} else {
539+
540+
// push数字进stack
541+
int num = str_to_int(tokens[i]);
542+
stack[stackTop++] = num;
543+
544+
}
545+
}
546+
547+
int result = stack[0];
548+
free(stack);
549+
return result;
550+
}
551+
```
552+
505553
<p align="center">
506554
<a href="https://programmercarl.com/other/kstar.html" target="_blank">
507555
<img src="../pics/网站星球宣传海报.jpg" width="1000"/>

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

Lines changed: 89 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1277,6 +1277,95 @@ impl MyStack {
12771277
}
12781278
```
12791279

1280+
### C:
1281+
1282+
> C:单队列
1283+
1284+
```c
1285+
typedef struct Node {
1286+
int val;
1287+
struct Node *next;
1288+
} Node_t;
1289+
1290+
// 用单向链表实现queue
1291+
typedef struct {
1292+
Node_t *head;
1293+
Node_t *foot;
1294+
int size;
1295+
} MyStack;
1296+
1297+
MyStack* myStackCreate() {
1298+
MyStack *obj = (MyStack *)malloc(sizeof(MyStack));
1299+
assert(obj);
1300+
obj->head = NULL;
1301+
obj->foot = NULL;
1302+
obj->size = 0;
1303+
return obj;
1304+
}
1305+
1306+
void myStackPush(MyStack* obj, int x) {
1307+
1308+
Node_t *temp = (Node_t *)malloc(sizeof(Node_t));
1309+
assert(temp);
1310+
temp->val = x;
1311+
temp->next = NULL;
1312+
1313+
// 添加至queue末尾
1314+
if (obj->foot) {
1315+
obj->foot->next = temp;
1316+
} else {
1317+
obj->head = temp;
1318+
}
1319+
obj->foot = temp;
1320+
obj->size++;
1321+
}
1322+
1323+
int myStackPop(MyStack* obj) {
1324+
1325+
// 获取末尾元素
1326+
int target = obj->foot->val;
1327+
1328+
if (obj->head == obj->foot) {
1329+
free(obj->foot);
1330+
obj->head = NULL;
1331+
obj->foot = NULL;
1332+
} else {
1333+
1334+
Node_t *prev = obj->head;
1335+
// 移动至queue尾部节点前一个节点
1336+
while (prev->next != obj->foot) {
1337+
prev = prev->next;
1338+
}
1339+
1340+
free(obj->foot);
1341+
obj->foot = prev;
1342+
obj->foot->next = NULL;
1343+
}
1344+
1345+
obj->size--;
1346+
return target;
1347+
}
1348+
1349+
int myStackTop(MyStack* obj) {
1350+
return obj->foot->val;
1351+
}
1352+
1353+
bool myStackEmpty(MyStack* obj) {
1354+
return obj->size == 0;
1355+
}
1356+
1357+
void myStackFree(MyStack* obj) {
1358+
Node_t *curr = obj->head;
1359+
while (curr != NULL) {
1360+
Node_t *temp = curr->next;
1361+
free(curr);
1362+
curr = temp;
1363+
}
1364+
free(obj);
1365+
}
1366+
1367+
```
1368+
12801369
12811370
<p align="center">
12821371
<a href="https://programmercarl.com/other/kstar.html" target="_blank">

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

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -99,7 +99,7 @@ if (cur == NULL) return cur;
9999

100100
* 确定单层递归的逻辑
101101

102-
在遍历二叉搜索树的时候就是寻找区间[p->val, q->val](注意这里是左闭又闭)
102+
在遍历二叉搜索树的时候就是寻找区间[p->val, q->val](注意这里是左闭右闭)
103103

104104
那么如果 cur->val 大于 p->val,同时 cur->val 大于q->val,那么就应该向左遍历(说明目标区间在左子树上)。
105105

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

Lines changed: 32 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -890,6 +890,38 @@ public:
890890
};
891891
```
892892
893+
### C
894+
895+
```c
896+
int* maxSlidingWindow(int* nums, int numsSize, int k, int* returnSize) {
897+
*returnSize = numsSize - k + 1;
898+
int *res = (int*)malloc((*returnSize) * sizeof(int));
899+
assert(res);
900+
int *deque = (int*)malloc(numsSize * sizeof(int));
901+
assert(deque);
902+
int front = 0, rear = 0, idx = 0;
903+
904+
for (int i = 0 ; i < numsSize ; i++) {
905+
while (front < rear && deque[front] <= i - k) {
906+
front++;
907+
}
908+
909+
while (front < rear && nums[deque[rear - 1]] <= nums[i]) {
910+
rear--;
911+
}
912+
913+
deque[rear++] = i;
914+
915+
if (i >= k - 1) {
916+
res[idx++] = nums[deque[front]];
917+
}
918+
}
919+
920+
return res;
921+
}
922+
923+
```
924+
893925
<p align="center">
894926
<a href="https://programmercarl.com/other/kstar.html" target="_blank">
895927
<img src="../pics/网站星球宣传海报.jpg" width="1000"/>

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

Lines changed: 13 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -123,6 +123,9 @@ public:
123123
### Java:
124124
版本一:使用HashSet
125125
```Java
126+
// 时间复杂度O(n+m+k) 空间复杂度O(n+k)
127+
// 其中n是数组nums1的长度,m是数组nums2的长度,k是交集元素的个数
128+
126129
import java.util.HashSet;
127130
import java.util.Set;
128131

@@ -145,8 +148,15 @@ class Solution {
145148
}
146149

147150
//方法1:将结果集合转为数组
148-
149-
return resSet.stream().mapToInt(x -> x).toArray();
151+
return res.stream().mapToInt(Integer::intValue).toArray();
152+
/**
153+
* 将 Set<Integer> 转换为 int[] 数组:
154+
* 1. stream() : Collection 接口的方法,将集合转换为 Stream<Integer>
155+
* 2. mapToInt(Integer::intValue) :
156+
* - 中间操作,将 Stream<Integer> 转换为 IntStream
157+
* - 使用方法引用 Integer::intValue,将 Integer 对象拆箱为 int 基本类型
158+
* 3. toArray() : 终端操作,将 IntStream 转换为 int[] 数组。
159+
*/
150160

151161
//方法2:另外申请一个数组存放setRes中的元素,最后返回数组
152162
int[] arr = new int[resSet.size()];
@@ -538,3 +548,4 @@ end
538548
<a href="https://programmercarl.com/other/kstar.html" target="_blank">
539549
<img src="../pics/网站星球宣传海报.jpg" width="1000"/>
540550
</a>
551+

0 commit comments

Comments
(0)

AltStyle によって変換されたページ (->オリジナル) /