没有合适的资源?快使用搜索试试~ 我知道了~
资源详情
资源评论
资源推荐
Code
数组
合并排序的数组
约瑟夫环问题——高效解法
栈
栈实现队列
最小栈
逆波兰表达式求值
队列
设计循环队列
链表
删除链表节点
删除链表中间节点
删除链表的倒数第n个节点
删除链表中的重复元素
相交链表
链表中环的入口点
反转链表
旋转链表
合并两个链表
重排链表
链表排序——插入
链表排序——归并
二叉树
中序遍历
前序遍历
后序遍历
二叉树的层序遍历
前序 + 中序 构建二叉树
有序数组转为二叉搜索树
将二叉搜索树变平衡
二叉树的最近公共祖先
层数最深的叶子节点的和
对称二叉树
二叉树的右视图
排序
插入 冒泡 选择
希尔 快排 堆排 归并
基数 计数
双轴快排
按奇偶排序数组——快排
荷兰国旗问题——颜色分类——快排
数组中的多数元素——快排
逆序对问题——归并
Top K 问题——堆排
最小的 K 个数——堆排
最大间距——基排
排序杂题
相对名次
双指针
无重复字符的最长子串
二分
旋转数组的最小数字
0~n-1 中缺失的数字
深度优先搜索 dfs
括号生成
路径总和
贪心
三元组最小距离
动态规划
最大子数组和
最大乘积子数组
最长公共子序列
最长公共子数组(最长重复子数组)
最长递增子序列
01背包 *
完全背包 *
零钱兑换——完全背包变体 *
零钱兑换II ——完全背包变体 *
杂题
回文数
字符串压缩——模拟
背包问题已经标 *,有一说一,几率应该不大,所以不是重点,可以理解则理解,否则 pass。重要的还是排序、树的遍历,递归,非递归这些。图论算法也的看看,尤其
是图的遍历,其实和树的一样,就是需要标记一下访问过的节点,避免死循环。
相信自己,写的代码很多了,一定可以的,即使一眼看着不太会,冷静思考分析一下,或许就会有想法哦,加油!
Code
数组
合并排序的数组
给定两个排序后的数组 A 和 B,其中 A 的末端有足够的缓冲空间容纳 B。 编写一个方法,将 B 合并入 A 并排序。
初始化 A 和 B 的元素数量分别为 m 和 n。
约瑟夫环问题——高效解法
0,1,···,n-1这n个数字排成一个圆圈,从数字0开始,每次从这个圆圈里删除第m个数字(删除后从下一个数字开始计数)。求出这个圆圈里剩下的最后一个数字。
例如,0、1、2、3、4这5个数字组成一个圆圈,从数字0开始每次删除第3个数字,则删除的前4个数字依次是2、0、4、1,因此最后剩下的数字是3。
k 神题解
栈
栈实现队列
请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作(push、pop、peek、empty):
实现 MyQueue 类:
void push(int x) 将元素 x 推到队列的末尾
int pop() 从队列的开头移除并返回元素
int peek() 返回队列开头的元素
boolean empty() 如果队列为空,返回 true ;否则,返回 false
void merge(int* A, int ASize, int m, int* B, int BSize, int n){
if(ASize == 0) return;
int * c = (int *)malloc(sizeof(int )*ASize);
int num = 0,j,k;
for(int i = 0;i < ASize;i++)
c[i] = 0;
for(j = 0,k = 0;j < m && k < n;num++)
{
if(A[j] <= B[k])
c[num] = A[j++];
else
c[num] = B[k++];
}
while(j < m) c[num++] = A[j++];
while(k < n) c[num++] = B[k++];
for(int i = 0;i < ASize;i++)
A[i] = c[i];
return;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
int f(int n, int m) {
if (n == 1) {
return 0;
}
int x = f(n - 1, m);
return (m + x) % n;
}
int lastRemaining(int n, int m) {
return f(n, m);
}
1
2
3
4
5
6
7
8
9
10
11
⼀
注意: 出栈的元素为空时 需要将入栈的元素全部挪到出栈当中
最小栈
typedef struct {
int *in_stack;
int *out_stack;
int top_in;
int top_out;
int size;
} MyQueue;
MyQueue* myQueueCreate() {
MyQueue* m = (MyQueue *)malloc(sizeof(MyQueue)*1);
m->in_stack = (int*)malloc(sizeof(int)*110);
m->out_stack = (int*)malloc(sizeof(int)*110);
m->top_in = -1;
m->top_out = -1;
m->size = 0;
return m;
}
void myQueuePush(MyQueue* obj, int x) {
obj->in_stack[++(obj->top_in)] = x;
obj->size++;
return ;
}
int myQueuePop(MyQueue* obj) {
if(obj->top_out == -1)
{
while(obj->top_in >= 0)
obj->out_stack[++(obj->top_out)] = obj->in_stack[(obj->top_in)--];
}
(obj->size)--;
return obj->out_stack[(obj->top_out)--];
}
int myQueuePeek(MyQueue* obj) {
if(obj->top_out == -1)
{
while(obj->top_in >= 0)
obj->out_stack[++(obj->top_out)] = obj->in_stack[(obj->top_in)--];
}
return obj->out_stack[obj->top_out];
}
bool myQueueEmpty(MyQueue* obj) {
if(obj->size == 0)
return true;
else
return false;
}
void myQueueFree(MyQueue* obj) {
free(obj->in_stack);
free(obj->out_stack);
obj->top_out = -1;
obj->top_in = -1;
obj->size = 0;
return ;
}
/**
* Your MyQueue struct will be instantiated and called as such:
* MyQueue* obj = myQueueCreate();
* myQueuePush(obj, x);
* int param_2 = myQueuePop(obj);
* int param_3 = myQueuePeek(obj);
* bool param_4 = myQueueEmpty(obj);
* myQueueFree(obj);
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
设计一个支持 push ,pop ,top 操作,并能在常数时间内检索到最小元素的栈。
push(x) —— 将元素 x 推入栈中。
pop() —— 删除栈顶的元素。
top() —— 获取栈顶元素。
getMin() —— 检索栈中的最小元素。
逆波兰表达式求值
根据 逆波兰表示法,求表达式的值。
有效的算符包括 +、-、*、/ 。每个运算对象可以是整数,也可以是另一个逆波兰表达式。
说明:
typedef struct {
int *arr;
int top;
int size;//xieshangzaishuo
int min_num;
int *brr;
} MinStack;
MinStack* minStackCreate() {
MinStack* m = (MinStack *)malloc(sizeof(MinStack)*1);
m->arr = (int *)malloc(sizeof(int)*101000);
m->brr = (int *)malloc(sizeof(int)*101000);
m->top = -1;
m->size = 0;
m->min_num = 2147483647;
return m;
}
void minStackPush(MinStack* obj, int val) {
obj->arr[++(obj->top)] = val;
(obj->size)++;
if(val < (obj->min_num))
{
obj->min_num = val;
// obj->brr[(obj->top)] = obj->min_num;
}
obj->brr[(obj->top)] = obj->min_num;
// else
// obj->brr[(obj->top)] =
}
int minStackTop(MinStack* obj) {
return obj->arr[(obj->top)];
}
void minStackPop(MinStack* obj) {
(obj->size)-= 1;
(obj->top)--;
// 最小的弹出去之后 记得更新 min_num
if(obj->size == 0)
obj->min_num = 2147483647;
else
obj->min_num = obj->brr[(obj->top)];
}
int minStackGetMin(MinStack* obj) {
return obj->brr[obj->top];
}
void minStackFree(MinStack* obj) {
free(obj->arr);
free(obj->brr);
obj->size = 0;
obj->top = -1;
obj->min_num = 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
o
整数除法只保留整数部分。
给定逆波兰表达式总是有效的。换句话说,表达式总会得出有效数值且不存在除数为 0 的情况。
队列
设计循环队列
设计你的循环队列实现。 循环队列是一种线性数据结构,其操作表现基于 FIFO(先进先出)原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲
器”。
循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里,一旦一个队列满了,我们就不能插入下一个元素,即使在队列前面仍有空间。但是使
用循环队列,我们能使用这些空间去存储新的值。
你的实现应该支持如下操作:
MyCircularQueue(k): 构造器,设置队列长度为 k 。
Front: 从队首获取元素。如果队列为空,返回 -1 。
Rear: 获取队尾元素。如果队列为空,返回 -1 。
enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真。
deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真。
isEmpty(): 检查循环队列是否为空。
isFull(): 检查循环队列是否已满。
/*
遇到数字就入栈,遇到符号就将栈顶的两个元素取出进行计算,将计算的结果入栈
*/
int evalRPN(char ** tokens, int tokensSize){
int *stack = (int *)calloc(tokensSize,sizeof(int));
int top = 0;
int a,b;
for(int i = 0;i < tokensSize;i++)
{
char *c = tokens[i];
if(strlen(c) == 1 && c[0] >= 42 && c[0] <= 47 )
{
b = stack[top-1];
a = stack[top-2];
top = top- 2;
switch(c[0])
{
case '+':
stack[top++] = a+b;
break;
case '-':
stack[top++] = a-b;
break;
case '*':
stack[top++] = a*b;
break;
case '/':
stack[top++] = a/b;
break;
}
}
else
stack[top++] = atoi(c);
}
return stack[--top];
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
typedef struct {
int k;
int *queue;
int length;
int front,rear;
} MyCircularQueue;
MyCircularQueue* myCircularQueueCreate(int k) {
MyCircularQueue *q = (MyCircularQueue *)calloc(1,sizeof(MyCircularQueue));
q->queue = (int *)calloc(k,sizeof(int));
q->k = k;
q->front = -1;
1
2
3
4
5
6
7
8
9
10
11
12
c
剩余35页未读,继续阅读
_苏沐
- 粉丝: 7777
- 资源: 12
上传资源 快速赚钱
- 我的内容管理 展开
- 我的资源 快来上传第一个资源
- 我的收益 登录查看自己的收益
- 我的积分 登录查看自己的积分
- 我的C币 登录后查看C币余额
- 我的收藏
- 我的下载
- 下载帮助
安全验证
文档复制为VIP权益,开通VIP直接复制
信息提交成功
评论0