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)当表中没有元素时称为 ...
随机推荐
- 团队冲刺--six
昨天: 司宇航:合并版块,但部分有缺陷. 马佳慧:研究css. 王金萱:写注册界面. 季方: 研究爬虫,精确的处理数据. 今天: 司宇航:测试功能版块,优化功能版块. 马佳慧:优化界面 . 王金萱: ...
- CS小分队第二阶段冲刺站立会议（6月4日）
昨日成果:昨天一直在对主界面进行修改,遇到问题没有进展 遇到的问题:我代码写的不够缜密,各按钮信息添加的删除的时候总是有重名或者覆盖现象,需要有一次大的检查 今日计划:冲刺已经结束,项目的难度超过了预 ...
- 四则运算App--大总结（已完成）
1. 贡献分分配(20分) 欧泽波:14分,Android的学习,代码的编写,等等 杨洁华:1分,提供学习资料,框架的设计等等 赵泽嘉:3分,提供学习资料,框架的设计等等 林扬滨:2分,提供学习资料, ...
- 深入理解JAVA I/O系列二：字节流详解
流的概念 JAVA程序通过流来完成输入/输出.流是生产或消费信息的抽象,流通过JAVA的输入输出与物理设备链接,尽管与它们链接的物理设备不尽相同,所有流的行为具有相同的方式.这样就意味一个输入流能够抽 ...
- url 地址含参数较多如何拼接
url 地址拼接是经常会遇到的问题.所以必须要掌握这个技术 1.合并参数对象,循环出来. var commonParams = { g_tk: 1928093487, inCharset: 'utf- ...
- contos7忘记root密码怎么办
首先在这个界面按"e"键 然后呢就会进入到如下图所示的界面,在LANG=zh_CN.UTF8的后面加上 init=/bin/sh, 再按 [ Ctrl + X ] 进入'单用户模式 ...
- python基础（六）python操作excel
一.python操作excel,python操作excel使用xlrd.xlwt和xlutils模块,xlrd模块是读取excel的,xlwt模块是写excel的,xlutils是用来修改excel的 ...
- 有意思的Alias参数
1. 最简单的方式,运行正常. PS C:\> Get-Service -Name BITS -ComputerName localhost 2. 自己构造一个对象,试图通过管道将主机名传递下去 ...
- iptables 开放端口
#iptables -A INPUT -p tcp --dport 5000 -j ACCEPT #service iptables save
- Dubbo学习(九) Dubbo面试问题
Dubbo是Alibaba开源的分布式服务框架,它最大的特点是按照分层的方式来架构,使用这种方式可以使各个层之间解耦合(或者最大限度地松耦合). 从服务模型的角度来看,Dubbo采用的是一种非常简单的 ...