Chapter 4(栈与队列)
1.栈的顺序存储结构
//*********************************stack_array.h************************************
#ifndef STACK_ARRAY_H
#define STACK_ARRAY_H
#define MAXSIZE 1000
#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>
typedef int datatype;
typedef struct stack_array
{
datatype data[MAXSIZE];
size_t top;
}SqStack;
//栈初始化
bool InitStack(SqStack *p);
//入栈
bool push(SqStack *stack,datatype e);
//出栈
bool pop(SqStack *stack,datatype *e);
#endif //STACK_ARRAY_H
//*********************************stack_array.c************************************
#include "stack_array.h"
//栈初始化
bool InitStack(SqStack *p)
{
if(NULL == p)return false;
p->top = -1;
return true;
}
//入栈
bool push(SqStack *stack,datatype e)
{
if(MAXSIZE-1 == stack->top)return false;//栈满
++stack->top;//入栈
stack->data[stack->top] = e;
return true;
}
//出栈
bool pop(SqStack *stack,datatype *e)
{
if(-1 == stack->top)return false;
*e = stack->data[stack->top];
--stack->top;
return true;
}
//*********************************stack_arrayTest.c************************************
#include "stack_array.h"
int main()
{
SqStack stack;
InitStack(&stack);
for(int i = 1;i <= 10;i++)
{
push(&stack,i);
}
datatype tmp;
for(int i =1;i <= 10;i++)
{
pop(&stack,&tmp);
printf("%d \n",tmp);
}
}104
1
//*********************************stack_array.h************************************
2
#ifndef STACK_ARRAY_H
3
#define STACK_ARRAY_H
4
5
#define MAXSIZE 1000
6
#include <stdio.h>
7
#include <stdbool.h>
8
#include <stdlib.h>
9
typedef int datatype;
10
11
typedef struct stack_array
12
{
13
datatype data[MAXSIZE];
14
size_t top;
15
}SqStack;
16
17
18
//栈初始化
19
bool InitStack(SqStack *p);
20
21
22
//入栈
23
bool push(SqStack *stack,datatype e);
24
25
26
//出栈
27
bool pop(SqStack *stack,datatype *e);
28
29
30
#endif //STACK_ARRAY_H
31
32
33
//*********************************stack_array.c************************************
34
35
#include "stack_array.h"
36
37
//栈初始化
38
bool InitStack(SqStack *p)
39
{
40
if(NULL == p)return false;
41
p->top = -1;
42
return true;
43
}
44
45
//入栈
46
bool push(SqStack *stack,datatype e)
47
{
48
if(MAXSIZE-1 == stack->top)return false;//栈满
49
50
++stack->top;//入栈
51
stack->data[stack->top] = e;
52
53
return true;
54
}
55
56
57
//出栈
58
bool pop(SqStack *stack,datatype *e)
59
{
60
if(-1 == stack->top)return false;
61
*e = stack->data[stack->top];
62
--stack->top;
63
return true;
64
}
65
66
67
68
//*********************************stack_arrayTest.c************************************
69
70
#include "stack_array.h"
71
72
73
74
75
76
int main()
77
78
{
79
80
SqStack stack;
81
82
InitStack(&stack);
83
84
for(int i = 1;i <= 10;i++)
85
86
{
87
88
push(&stack,i);
89
90
}
91
92
datatype tmp;
93
94
for(int i =1;i <= 10;i++)
95
96
{
97
98
pop(&stack,&tmp);
99
100
printf("%d \n",tmp);
101
102
}
103
104
}
2.两栈共享空间（栈的顺序存储结构）
//*******************************stack_share.h***********************************
#ifndef STACK_SHARE_H
#define STACK_SHARE_H
#define MAXSIZE 1000
#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>
#include <memory.h>
typedef int datatype;
typedef struct stack_share
{
datatype data[MAXSIZE];
size_t top1;
size_t top2;
}SqDoubleStack;
//初始化栈
void InitStack(SqDoubleStack *stack);
//压栈
bool push(SqDoubleStack *stack,datatype e,int num);
//弹栈
bool pop(SqDoubleStack *stack,datatype *e,int num);
#endif //STACK_SHARE_H
//*******************************stack_share.c***********************************
#include "stack_share.h"
//初始化栈
void InitStack(SqDoubleStack *stack)
{
stack->top1 = -1;
stack->top2 = MAXSIZE;
}
//压栈
bool push(SqDoubleStack *stack,datatype e,int num)
{
if(stack->top1+1 == stack->top2)return false;
if(1 == num)
{
stack->data[++stack->top1] = e;
}
else if(2 == num)
{
stack->data[--stack->top2] = e;
}
return true;
}
//弹栈
bool pop(SqDoubleStack *stack,datatype *e,int num)
{
if(1 == num)
{
if(-1 != stack->top1)return false;
*e = stack->data[stack->top1--];
}
else if(2 == num)
{
if(MAXSIZE != stack->top2)return false;
*e = stack->data[stack->top2++];
}
return true;
}
//*******************************stack_shareTest.c***********************************
#include "stack_share.h"
int main()
{
SqDoubleStack stack;
InitStack(&stack);
memset(stack.data,0,sizeof(int)*1000);
for(int i =1;i <= 10;i++)
{
push(&stack,i,1);
}
for(int i =1;i <= 10;i++)
{
push(&stack,i,2);
}
for(int i = 0;i < 1000;i++)
{
printf("%d ",stack.data[i]);
}
return 0;
}126
1
//*******************************stack_share.h***********************************
2
3
#ifndef STACK_SHARE_H
4
#define STACK_SHARE_H
5
6
#define MAXSIZE 1000
7
#include <stdio.h>
8
#include <stdbool.h>
9
#include <stdlib.h>
10
#include <memory.h>
11
typedef int datatype;
12
13
typedef struct stack_share
14
{
15
datatype data[MAXSIZE];
16
size_t top1;
17
size_t top2;
18
}SqDoubleStack;
19
20
21
//初始化栈
22
void InitStack(SqDoubleStack *stack);
23
24
//压栈
25
bool push(SqDoubleStack *stack,datatype e,int num);
26
27
//弹栈
28
bool pop(SqDoubleStack *stack,datatype *e,int num);
29
30
31
32
#endif //STACK_SHARE_H
33
34
35
//*******************************stack_share.c***********************************
36
37
#include "stack_share.h"
38
39
//初始化栈
40
void InitStack(SqDoubleStack *stack)
41
{
42
stack->top1 = -1;
43
stack->top2 = MAXSIZE;
44
}
45
46
//压栈
47
bool push(SqDoubleStack *stack,datatype e,int num)
48
{
49
if(stack->top1+1 == stack->top2)return false;
50
51
if(1 == num)
52
{
53
stack->data[++stack->top1] = e;
54
}
55
else if(2 == num)
56
{
57
stack->data[--stack->top2] = e;
58
}
59
return true;
60
}
61
62
//弹栈
63
bool pop(SqDoubleStack *stack,datatype *e,int num)
64
{
65
if(1 == num)
66
{
67
if(-1 != stack->top1)return false;
68
*e = stack->data[stack->top1--];
69
}
70
else if(2 == num)
71
{
72
if(MAXSIZE != stack->top2)return false;
73
*e = stack->data[stack->top2++];
74
}
75
return true;
76
}
77
78
79
80
//*******************************stack_shareTest.c***********************************
81
82
#include "stack_share.h"
83
84
85
86
87
88
int main()
89
90
{
91
92
SqDoubleStack stack;
93
94
InitStack(&stack);
95
96
memset(stack.data,0,sizeof(int)*1000);
97
98
for(int i =1;i <= 10;i++)
99
100
{
101
102
push(&stack,i,1);
103
104
}
105
106
for(int i =1;i <= 10;i++)
107
108
{
109
110
push(&stack,i,2);
111
112
}
113
114
115
116
for(int i = 0;i < 1000;i++)
117
118
{
119
120
printf("%d ",stack.data[i]);
121
122
}
123
124
return 0;
125
126
}
3.*****链栈*****
//****************************stack_link.h************************************
#ifndef STACK_LINK_H
#define STACK_LINK_H
#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>
typedef int datatype;
typedef struct StackNode
{
datatype data;
struct StackNode *next;
}StackNode;
typedef struct StackLink
{
StackNode *top;
size_t count;
}Stack;
//创建链栈
Stack *create();
//压栈
bool push(Stack *stack,datatype e);
//弹栈
bool pop(Stack *stack,datatype *e);
#endif //STACK_LINK_H
//****************************stack_link.c************************************
#include "stack_link.h"
//创建链栈
Stack *create()
{
Stack *stack = (Stack *)malloc(sizeof(Stack));
stack->top = NULL;
stack->count = 0;
return stack;
}
//压栈
bool push(Stack *stack,datatype e)
{
if(NULL == stack)return false;
StackNode *node = (StackNode *)malloc(sizeof(StackNode)); //申请新节点
node->data = e;//为新节点赋值
node->next = stack->top;
stack->top = node;//使top指向新节点
++stack->count;//count++
return true;
}
//弹栈
bool pop(Stack *stack,datatype *e)
{
if(NULL == stack->top)return false;//如果栈空，弹出失败
StackNode *curr = stack->top;//保存栈顶节点地址
StackNode *next = curr->next;//保存栈顶下一个节点地址
*e = curr->data;//保存弹出值
stack->top = next;//使top指向原栈顶下一个节点
--stack->count;
free(curr);
return true;
}
//****************************stack_linkTest.c************************************
#include "stack_link.h"
int main()
{
Stack *stack = create();
for(int i = 1;i <= 10;i++)
{
push(stack,i);
}
datatype tmp;
for(int i = 1;i <= 10;i++)
{
pop(stack,&tmp);
printf("%d ",tmp);
}
printf("\n");
return 0;
}x
1
//****************************stack_link.h************************************
2
#ifndef STACK_LINK_H
3
4
#define STACK_LINK_H
5
6
7
8
#include <stdio.h>
9
#include <stdbool.h>
10
#include <stdlib.h>
11
typedef int datatype;
12
13
14
typedef struct StackNode
15
16
{
17
18
datatype data;
19
20
struct StackNode *next;
21
22
}StackNode;
23
24
typedef struct StackLink
25
26
{
27
28
StackNode *top;
29
30
size_t count;
31
32
}Stack;
33
34
35
36
//创建链栈
37
Stack *create();
38
39
//压栈
40
41
bool push(Stack *stack,datatype e);
42
43
//弹栈
44
45
bool pop(Stack *stack,datatype *e);
46
47
48
#endif //STACK_LINK_H
49
50
51
52
//****************************stack_link.c************************************
53
#include "stack_link.h"
54
55
56
//创建链栈
57
58
Stack *create()
59
60
{
61
62
Stack *stack = (Stack *)malloc(sizeof(Stack));
63
64
stack->top = NULL;
65
66
stack->count = 0;
67
68
return stack;
69
70
}
71
72
73
74
//压栈
75
76
bool push(Stack *stack,datatype e)
77
78
{
79
80
if(NULL == stack)return false;
81
82
83
84
StackNode *node = (StackNode *)malloc(sizeof(StackNode)); //申请新节点
85
86
87
88
node->data = e;//为新节点赋值
89
90
node->next = stack->top;
91
92
93
94
stack->top = node;//使top指向新节点
95
96
++stack->count;//count++
97
98
return true;
99
100
}
101
102
103
104
105
106
//弹栈
107
108
bool pop(Stack *stack,datatype *e)
109
110
{
111
112
if(NULL == stack->top)return false;//如果栈空，弹出失败
113
114
115
116
StackNode *curr = stack->top;//保存栈顶节点地址
117
118
StackNode *next = curr->next;//保存栈顶下一个节点地址
119
120
121
122
*e = curr->data;//保存弹出值
123
124
stack->top = next;//使top指向原栈顶下一个节点
125
126
--stack->count;
127
128
129
130
free(curr);
131
132
return true;
133
134
}
135
136
137
138
//****************************stack_linkTest.c************************************
139
#include "stack_link.h"
140
141
142
143
int main()
144
145
{
146
147
Stack *stack = create();
148
149
for(int i = 1;i <= 10;i++)
150
151
{
152
153
push(stack,i);
154
155
}
156
157
datatype tmp;
158
159
for(int i = 1;i <= 10;i++)
160
161
{
162
163
pop(stack,&tmp);
164
165
printf("%d ",tmp);
166
167
}
168
169
printf("\n");
170
171
return 0;
172
173
}
4.循环队列（顺序存储结构）
//************************************circular_queue.h****************************************
#ifndef CIRCULAR_LINK_H
#define CIRCULAR_LINK_H
#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>
#define MAXSIZE 1000
typedef int datatype;
typedef struct
{
datatype data[MAXSIZE];
size_t front;
size_t rear;
}SqQueue;
//初始化队列
void InitQueue(SqQueue *Q);
//求队列长度
size_t length(SqQueue Q);
//入队
bool EnQueue(SqQueue *Q,datatype e);
//出队
bool DeQueue(SqQueue *Q,datatype *e);
#endif //CIRCULAR_LINK_H
//************************************circular_queue.c****************************************
#include "circular_queue.h"
//初始化队列
void InitQueue(SqQueue *Q)
{
Q->front = 0;
Q->rear = 0;
}
//求队列长度
size_t length(SqQueue Q)
{
return (Q.rear-Q.front+MAXSIZE)%MAXSIZE;
}
//入队
bool EnQueue(SqQueue *Q,datatype e)
{
if((Q->rear+1)%MAXSIZE == Q->front)return false;
Q->data[Q->rear] = e;
Q->rear = (Q->rear+1)%MAXSIZE;
return false;
}
//出队
bool DeQueue(SqQueue *Q,datatype *e)
{
if(Q->front == Q->rear)return false;
*e = Q->data[Q->front];
Q->front = (Q->front+1)%MAXSIZE;
return true;
}
//************************************circular_queueTest.c****************************************
#include "circular_queue.h"
int main()
{
SqQueue Q;
InitQueue(&Q);
printf("length:%d \n",length(Q));
for(size_t i = 1;i <= 1000;i++)
{
EnQueue(&Q,i);
}
printf("length:%d \n",length(Q));
size_t temp;
for(size_t i = 1;i <= 10;i++)
{
DeQueue(&Q,&temp);
printf("%d ",temp);
}
printf("\n");
printf("length:%d \n",length(Q));
for(size_t i = 1;i <= 10;i++)
{
EnQueue(&Q,i);
}
printf("length:%d \n",length(Q));
for(size_t i = 1;i <= 1000;i++)
{
DeQueue(&Q,&temp);
printf("%d ",temp);
}
printf("length:%d \n",length(Q));
return 0;
}x
112
1
//************************************circular_queue.h****************************************
2
#ifndef CIRCULAR_LINK_H
3
#define CIRCULAR_LINK_H
4
5
#include <stdio.h>
6
#include <stdbool.h>
7
#include <stdlib.h>
8
#define MAXSIZE 1000
9
typedef int datatype;
10
11
typedef struct
12
{
13
datatype data[MAXSIZE];
14
size_t front;
15
size_t rear;
16
}SqQueue;
17
18
19
//初始化队列
20
void InitQueue(SqQueue *Q);
21
22
//求队列长度
23
size_t length(SqQueue Q);
24
25
//入队
26
bool EnQueue(SqQueue *Q,datatype e);
27
28
//出队
29
bool DeQueue(SqQueue *Q,datatype *e);
30
31
32
#endif //CIRCULAR_LINK_H
33
34
35
//************************************circular_queue.c****************************************
36
#include "circular_queue.h"
37
38
39
//初始化队列
40
void InitQueue(SqQueue *Q)
41
{
42
Q->front = 0;
43
Q->rear = 0;
44
}
45
46
//求队列长度
47
size_t length(SqQueue Q)
48
{
49
return (Q.rear-Q.front+MAXSIZE)%MAXSIZE;
50
}
51
52
//入队
53
bool EnQueue(SqQueue *Q,datatype e)
54
{
55
if((Q->rear+1)%MAXSIZE == Q->front)return false;
56
57
Q->data[Q->rear] = e;
58
Q->rear = (Q->rear+1)%MAXSIZE;
59
return false;
60
}
61
62
//出队
63
bool DeQueue(SqQueue *Q,datatype *e)
64
{
65
if(Q->front == Q->rear)return false;
66
67
*e = Q->data[Q->front];
68
Q->front = (Q->front+1)%MAXSIZE;
69
return true;
70
}
71
72
73
74
//************************************circular_queueTest.c****************************************
75
#include "circular_queue.h"
76
77
78
int main()
79
{
80
SqQueue Q;
81
InitQueue(&Q);
82
83
printf("length:%d \n",length(Q));
84
85
for(size_t i = 1;i <= 1000;i++)
86
{
87
EnQueue(&Q,i);
88
}
89
printf("length:%d \n",length(Q));
90
size_t temp;
91
92
for(size_t i = 1;i <= 10;i++)
93
{
94
DeQueue(&Q,&temp);
95
printf("%d ",temp);
96
}
97
printf("\n");
98
printf("length:%d \n",length(Q));
99
for(size_t i = 1;i <= 10;i++)
100
{
101
EnQueue(&Q,i);
102
}
103
104
printf("length:%d \n",length(Q));
105
for(size_t i = 1;i <= 1000;i++)
106
{
107
DeQueue(&Q,&temp);
108
printf("%d ",temp);
109
}
110
printf("length:%d \n",length(Q));
111
return 0;
112
}
5.链队列
//*******************************queue_link.h****************************************
#ifndef QUEUE_LINK_H
#define QUEUE_LINK_H
#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>
typedef int datatype;
typedef struct QNode
{
datatype data;
struct QNode *next;
}QNode,*QueuePtr;
typedef struct
{
QueuePtr front,rear;
}LinkQueue;
//创建队列
LinkQueue create();
//入队
bool EnQueue(LinkQueue *Q,datatype e);
//出队
bool DeQueue(LinkQueue *Q,datatype *e);
#endif //QUEUE_LINK_H
//*******************************queue_link.c****************************************
#include "queue_link.h"
//创建队列
LinkQueue create()
{
QueuePtr head = (QueuePtr)malloc(sizeof(QNode));
head->next = NULL;
LinkQueue Q;
Q.front = head;
Q.rear = head;
return Q;
}
//入队
bool EnQueue(LinkQueue *Q,datatype e)
{
QueuePtr s = (QueuePtr)malloc(sizeof(QNode));//创建新节点
if(!s)return false;
s->data = e; //设置新节点数据
s->next = NULL;
Q->rear->next = s; //将原来的队尾指向新节点
Q->rear = s; //队尾指针指向s
return true;
}
//出队
bool DeQueue(LinkQueue *Q,datatype *e)
{
if(Q->front == Q->rear)return false;
QueuePtr node = Q->front->next;//保存要删除节点的地址
QueuePtr behind = node->next;//保存要删除节点下一个节点的地址
*e = node->data;//保存数据
Q->front->next = behind;//使front指向下一个节点
if(Q->rear == node)Q->rear = Q->front;//假如出队前队列只有一个元素，则出队后队列为空，队尾应该指向头节点。
free(node);
return true;
}
//*******************************queue_linkTest.c****************************************
#include "queue_link.h"
int main()
{
LinkQueue Q = create();
for(size_t i = 1;i <= 10;i++)
{
EnQueue(&Q,i);
}
size_t tmp;
for(size_t i = 1;i <= 10;i++)
{
DeQueue(&Q,&tmp);
printf("%d ",tmp);
}
printf("\n");
return 0;
}x
150
1
//*******************************queue_link.h****************************************
2
#ifndef QUEUE_LINK_H
3
#define QUEUE_LINK_H
4
5
6
#include <stdio.h>
7
#include <stdbool.h>
8
#include <stdlib.h>
9
10
11
12
typedef int datatype;
13
14
15
16
typedef struct QNode
17
18
{
19
20
datatype data;
21
22
struct QNode *next;
23
24
}QNode,*QueuePtr;
25
26
27
typedef struct
28
29
{
30
31
QueuePtr front,rear;
32
33
}LinkQueue;
34
35
//创建队列
36
37
LinkQueue create();
38
39
//入队
40
41
bool EnQueue(LinkQueue *Q,datatype e);
42
43
//出队
44
45
bool DeQueue(LinkQueue *Q,datatype *e);
46
47
48
#endif //QUEUE_LINK_H
49
50
51
//*******************************queue_link.c****************************************
52
#include "queue_link.h"
53
54
55
//创建队列
56
57
LinkQueue create()
58
59
{
60
61
QueuePtr head = (QueuePtr)malloc(sizeof(QNode));
62
63
head->next = NULL;
64
65
LinkQueue Q;
66
67
Q.front = head;
68
69
Q.rear = head;
70
71
return Q;
72
73
}
74
75
76
77
//入队
78
79
bool EnQueue(LinkQueue *Q,datatype e)
80
81
{
82
83
QueuePtr s = (QueuePtr)malloc(sizeof(QNode));//创建新节点
84
85
if(!s)return false;
86
87
88
89
s->data = e; //设置新节点数据
90
91
s->next = NULL;
92
93
94
95
Q->rear->next = s; //将原来的队尾指向新节点
96
97
Q->rear = s; //队尾指针指向s
98
99
return true;
100
101
}
102
103
104
105
//出队
106
107
bool DeQueue(LinkQueue *Q,datatype *e)
108
109
{
110
111
if(Q->front == Q->rear)return false;
112
113
114
115
QueuePtr node = Q->front->next;//保存要删除节点的地址
116
117
QueuePtr behind = node->next;//保存要删除节点下一个节点的地址
118
119
120
121
*e = node->data;//保存数据
122
123
124
125
Q->front->next = behind;//使front指向下一个节点
126
127
128
129
if(Q->rear == node)Q->rear = Q->front;//假如出队前队列只有一个元素，则出队后队列为空，队尾应该指向头节点。
130
131
132
133
free(node);
134
135
136
137
return true;
138
139
}
140
141
142
143
144
145
//*******************************queue_linkTest.c****************************************
146
#include "queue_link.h"
147
148
149
150
int main()
151
152
{
153
154
LinkQueue Q = create();
155
156
157
158
for(size_t i = 1;i <= 10;i++)
159
160
{
161
162
EnQueue(&Q,i);
163
164
}
165
166
167
168
size_t tmp;
169
170
for(size_t i = 1;i <= 10;i++)
171
172
{
173
174
DeQueue(&Q,&tmp);
175
176
printf("%d ",tmp);
177
178
}
179
180
printf("\n");
181
182
return 0;
183
184
}
附件列表
Chapter 4(栈与队列)的更多相关文章
- Chapter 2 栈和队列
Chapter 2 栈和队列 1- 栈 当n个元素以某顺序进栈,可在任意时刻出栈,元素排列的顺序N满足Catalan()规则: 常用操作: 1 栈的初始化和定义: 2 元素x进栈: 3 ...
- 学习javascript数据结构(一)——栈和队列
前言 只要你不计较得失,人生还有什么不能想法子克服的. 原文地址:学习javascript数据结构(一)--栈和队列 博主博客地址:Damonare的个人博客 几乎所有的编程语言都原生支持数组类型,因 ...
- [ACM训练] 算法初级 之 数据结构 之 栈stack+队列queue (基础+进阶+POJ 1338+2442+1442)
再次面对像栈和队列这样的相当基础的数据结构的学习,应该从多个方面,多维度去学习. 首先,这两个数据结构都是比较常用的,在标准库中都有对应的结构能够直接使用,所以第一个阶段应该是先学习直接来使用,下一个 ...
- 剑指Offer面试题：6.用两个栈实现队列
一.题目:用两个栈实现队列 题目:用两个栈实现一个队列.队列的声明如下,请实现它的两个函数appendTail和deleteHead,分别完成在队列尾部插入结点和在队列头部删除结点的功能. 原文是使用 ...
- C实现栈和队列
这两天再学习了数据结构的栈和队列,思想很简单,可能是学习PHP那会没有直接使用栈和队列,写的太少,所以用具体代码实现的时候出现了各种错误,感觉还是C语言功底不行.栈和队列不论在面试中还是笔试中都很重要 ...
- JavaScript数组模拟栈和队列
*栈和队列:js中没有真正的栈和队列的类型 一切都是用数组对象模拟的 栈:只能从一端进出的数组,另一端封闭 FILO 何时使用:今后只要仅希望数组只能从一端进 ...
- 用JS描述的数据结构及算法表示——栈和队列（基础版）
前言:找了上课时数据结构的教程来看,但是用的语言是c++,所以具体实现在网上搜大神的博客来看,我看到的大神们的博客都写得特别好,不止讲了最基本的思想和算法实现,更多的是侧重于实例运用,一边看一边在心里 ...
- JavaScript中的算法之美——栈、队列、表
序 最近花了比较多的时间来学习前端的知识,在这个期间也看到了很多的优秀的文章,其中Aaron可能在这个算法方面算是我的启蒙,在此衷心感谢Aaron的付出和奉献,同时自己也会坚定的走前人这种无私奉献的分 ...
- Java数据结构和算法之栈与队列
二.栈与队列 1.栈的定义 栈(Stack)是限制仅在表的一端进行插入和删除运算的线性表. (1)通常称插入.删除的这一端为栈顶(Top),另一端称为栈底(Bottom). (2)当表中没有元素时称为 ...
随机推荐
- webpack入门指南-step02
webpack 安装 1)安装前的准备:webpack是基于node环境的项目,所以使用前必须先安装node和npm. 在安装 Webpack 前,你本地环境需要支持 node.js.如果电脑没有装过 ...
- 个人作业2——APP案例分析
产品:网易LOFTER(乐乎) 网易LOFTER是网易旗下图片社交APP,产品覆盖web及移动各端. 网易LOFTER社区内汇聚了多领域的品质生活家与生活达人,包含女神.明星.穿搭.文具.旅行.美 ...
- vue-cli 安装时 npm 报错 errno -4048
如何解决vue-cli 安装时 npm 报错 errno -4048 第一种解决方法:以管理身份运行cmd.exe 第二种解决办法:在dos窗口输入命令 npm cache clean --fo ...
- 第二次结对作业-WordCount进阶需求
原博客 队友博客 github项目地址 目录 具体分工 需求分析 PSP表格 解题思路描述与设计实现说明 爬虫使用 代码组织与内部实现设计(类图) 算法的关键与关键实现部分流程图 附加题设计与展示 设 ...
- win7系统安装SQLServer2000的详细步骤(图文)
首先,如果以前安装的话,要删除干净.我也找了半天的网络资料.1.把原来SQLServer的安装目录 C:\Program Files\Microsoft SQL Server 删除2.所有SQLSe ...
- APP端测试与web端测试的区别
想要知道APP端测试与web端测试的区别 ,那么我们就要先来了解,web和app的区别. web项目,一般都是b/s架构,基于浏览器的,而app则是c/s的,必须要有客户端.那么在系统测试测试的时候就 ...
- 转载LoadRunner的常用Java API
Java API是访问Vuser函数的基础,通过LoadRunner的Java API可以在脚本中很容易地创建事务与并发点.获取用户信息等功能. 1. 事务函数(Transaction Functio ...
- HTTP压力测试工具wrk的安装及测试
本次在VMware虚拟机的CentOS6.3系统中进行安装wrk压测工具,具体如下: 一.预先安装需求项 为了安装顺利,不受权限的限制,首先可以把用户切换为root用户# su + 输入root用户对 ...
- Spring4+Spring MVC+MyBatis整合思路
1.Spring框架的搭建 这个很简单,只需要web容器中注册org.springframework.web.context.ContextLoaderListener,并指定spring加载配置文件 ...
- poj3320 Jessica's Reading Problem
Description Jessica's a very lovely girl wooed by lots of boys. Recently she has a problem. The fina ...