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)当表中没有元素时称为 ...
随机推荐
- rev命令详解
基础命令学习目录首页 rev命令将文件中的每行内容以字符为单位反序输出,即第一个字符最后输出,最后一个字符最先输出,依次类推. #cat a.txt wo shi mcw, nihao how do ...
- js备忘录2
JavaScript 的类型分为两类,分别是原始类型和对象类型 其中原始类型中只有数字.字符串和布尔型,和java中的有些不一样 null和undefined不是基本数据类型中的某一种 对象是prop ...
- MVC 漫长之路（一）
1.新建项目 mvc 视图引擎选中 Razor 2.允许我们设置这个项目关于 MVC 的一些设置,确认选中了“空”项目模板 3. 4.打开 Global.asax 文件 配置路由名称等 ...
- Alpha版本测试文档
概述 本次测试主要是为了测试是否有导致崩溃的bug,验证是否符合软件基本需求. 测试环境 硬件测试:安卓系统手机,安卓平板. 测试人员 赖彦谕,金哉仁. 实际进度 2015/11/6 – 2015/1 ...
- 05慕课网《进击Node.js基础（一）》HTTP概念进阶（同步/异步）
HTTP模块介绍 支持http协议的更多特性 不缓存请求和响应 API比较底层处理流相关,信息解析 HTTP相关概念 回调 将函数作为参数传到执行函数中,参数函数在执行函数中嵌套执行 function ...
- alpha版postmortem 报告
一.团队开发存在的问题 此次会议我们团队中每个成员都仔细思考并提出了团队在这一阶段存在的问题,主要如下: 1.前期任务规划.分配不合适: 2.个人对认领任务模块完成度.了解度不够: 3.个人学习意识. ...
- ASP.NET MVC5 学习系列之初探MVC
一.由问题看本质 (一)什么是MVC? MVC是Model-View-Controller的简称.它是在1970年引入的软件设计模式.MVC 模式强迫关注分离 — 域模型和控制器逻辑与UI是松耦合关系 ...
- 【贪心算法】POJ-2393 简单贪心水题
一.题目 Description The cows have purchased a yogurt factory that makes world-famous Yucky Yogurt. Over ...
- rpm安装和二进制安装
rpm包安装 Tomcat RPM安装(先安装JDK + 再安装Tomcat) 1:升级系统自带的JDK(也可以使用oracle的JDK) yum install -y java-1.8.0-open ...
- beta 发布的相关评论
1. 礼物挑选小工具 飞天小女警 这个项目的创意独具匠心,贴近实际,令人耳目一新,网站的页面也是玫红色的,配色让人感到很温馨,对礼物的筛选方式很有趣,使用的记录特殊日子的方法来提醒自己挑选礼 ...