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(栈与队列)的更多相关文章

  1. Chapter 2 栈和队列

    Chapter 2 栈和队列 1-   栈 当n个元素以某顺序进栈,可在任意时刻出栈,元素排列的顺序N满足Catalan()规则: 常用操作: 1   栈的初始化和定义: 2   元素x进栈: 3   ...

  2. 学习javascript数据结构(一)——栈和队列

    前言 只要你不计较得失,人生还有什么不能想法子克服的. 原文地址:学习javascript数据结构(一)--栈和队列 博主博客地址:Damonare的个人博客 几乎所有的编程语言都原生支持数组类型,因 ...

  3. [ACM训练] 算法初级 之 数据结构 之 栈stack+队列queue (基础+进阶+POJ 1338+2442+1442)

    再次面对像栈和队列这样的相当基础的数据结构的学习,应该从多个方面,多维度去学习. 首先,这两个数据结构都是比较常用的,在标准库中都有对应的结构能够直接使用,所以第一个阶段应该是先学习直接来使用,下一个 ...

  4. 剑指Offer面试题:6.用两个栈实现队列

    一.题目:用两个栈实现队列 题目:用两个栈实现一个队列.队列的声明如下,请实现它的两个函数appendTail和deleteHead,分别完成在队列尾部插入结点和在队列头部删除结点的功能. 原文是使用 ...

  5. C实现栈和队列

    这两天再学习了数据结构的栈和队列,思想很简单,可能是学习PHP那会没有直接使用栈和队列,写的太少,所以用具体代码实现的时候出现了各种错误,感觉还是C语言功底不行.栈和队列不论在面试中还是笔试中都很重要 ...

  6. JavaScript数组模拟栈和队列

    *栈和队列:js中没有真正的栈和队列的类型              一切都是用数组对象模拟的 栈:只能从一端进出的数组,另一端封闭       FILO   何时使用:今后只要仅希望数组只能从一端进 ...

  7. 用JS描述的数据结构及算法表示——栈和队列(基础版)

    前言:找了上课时数据结构的教程来看,但是用的语言是c++,所以具体实现在网上搜大神的博客来看,我看到的大神们的博客都写得特别好,不止讲了最基本的思想和算法实现,更多的是侧重于实例运用,一边看一边在心里 ...

  8. JavaScript中的算法之美——栈、队列、表

    序 最近花了比较多的时间来学习前端的知识,在这个期间也看到了很多的优秀的文章,其中Aaron可能在这个算法方面算是我的启蒙,在此衷心感谢Aaron的付出和奉献,同时自己也会坚定的走前人这种无私奉献的分 ...

  9. Java数据结构和算法之栈与队列

    二.栈与队列 1.栈的定义 栈(Stack)是限制仅在表的一端进行插入和删除运算的线性表. (1)通常称插入.删除的这一端为栈顶(Top),另一端称为栈底(Bottom). (2)当表中没有元素时称为 ...

随机推荐

  1. Hadoop Streaming框架使用(二)

    上一篇文章介绍了Streaming的各种参数,本文具体介绍使用方法. 提交hadoop任务示例: $HADOOP_HOME/bin/hadoop streaming \ -input /user/te ...

  2. reduce()用法

    reduce()方法接受一个函数作为累加器,数组中的每个值(从左到右)开始缩减,最终为一个值 参数 callback 执行数组中的每个值的函数,包含四个参数 previousValue 上一次调用回调 ...

  3. 【Oracle】存储过程在字符串单引号'内拼接单引号'

    http://blog.csdn.net/u011704894/article/details/44976557 一般变量里面接3个单引号 eg: 'DELETE FROM RDM_SUPP_DATA ...

  4. NEWBEE软件团队 人员分配情况及分数获得方式

    人员分配: PM:李桐  王骜 dev:王骜 刘垚鹏 安康  林旭鹏  黄新越 test:黄伟龙 李桐 马佐霖 黄新越 注:黄新越为女生,不方便平时的交流,所以任务分配较为灵活,特分在两个组里. 评分 ...

  5. 2-Seventh Scrum Meeting20151207

    任务分配 闫昊: 今日完成:完成数据库设计. 明日任务:和唐彬讨论接口如何在android实现. 唐彬: 今日完成:读了IOS讨论区后台接口. 明日任务:和闫昊讨论接口如何在android实现. 史烨 ...

  6. 20172313『Java程序设计』课程结对编程练习_四则运算第二周阶段总结

    20172313『Java程序设计』课程结对编程练习_四则运算第二周阶段总结 结对伙伴 20172326康皓越 博客地址(http://www.cnblogs.com/326477465-a/p/90 ...

  7. 项目Beta冲刺(团队)第七天

    1.昨天的困难 服务器部署出了问题,本地服务器差点崩掉 运行一直闪退,在查找哪里出现问题的路上一去不复返 2.今天解决的进度 成员 进度 陈家权 消息功能模块 赖晓连 问答功能模块 雷晶 部署服务器到 ...

  8. Inside Qt Series (全集,共十六篇,不同版本的Qt有不同的实现)

    Inside Qt 系列 QObject这个 class 是 QT 对象模型的核心,绝大部分的 QT 类都是从这个类继承而来.这个模型的中心特征就是一个叫做信号和槽(signaland slot)的机 ...

  9. JS 随机整数

    <script>   function GetRandomNum(Min,Max){   var Range = Max - Min;   var Rand = Math.random() ...

  10. Linux进程调度策略的发展和演变(转)

    转发:http://blog.csdn.net/gatieme/article/details/51701149  1 前言 1.1 进程调度 内存中保存了对每个进程的唯一描述, 并通过若干结构与其他 ...