概要
本章和介绍"栈"时的流程一样，先对队列进行介绍，然后分别给出队列的C、C++和Java三种语言的实现。内容包括：
队列的介绍
队列(Queue)，是一种线性存储结构。它有以下几个特点：
(01) 队列中数据是按照"先进先出(FIFO, First-In-First-Out)"方式进出队列的。
(02) 队列只允许在"队首"进行删除操作，而在"队尾"进行插入操作。
队列通常包括的两种操作：入队列 和出队列。
1. 队列的示意图
队列中有10，20，30共3个数据。
2. 出队列
出队列前：队首是10，队尾是30。
出队列后：出队列(队首)之后。队首是20，队尾是30。
3. 入队列
入队列前：队首是20，队尾是30。
入队列后：40入队列(队尾)之后。队首是20，队尾是40。
下面介绍队列的实现，分别介绍C/C++/Java三种实现
队列的C实现
共介绍4种C语言实现。
1. C语言实现一：数组实现的队列，并且只能存储int数据。
2. C语言实现二：单向链表实现的队列，并且只能存储int数据。
3. C语言实现三：双向链表实现的队列，并且只能存储int数据。
4. C语言实现四：双向链表实现的队列，能存储任意类型的数据。
1. C语言实现一：数组实现的队列，并且只能存储int数据
实现代码(array_queue.c)
1 #include
2 #include
3
4 /**5 * C 语言: 数组实现的队列，只能存储int数据。6 *7 * @author skywang8 * @date 2013/11/079 */
10
11 //保存数据的数组
12 static int *arr=NULL;13 //队列的实际大小
14 static intcount;15
16 //创建“队列”
17 int create_array_queue(intsz)18 {19 arr = (int *)malloc(sz*sizeof(int));20 if (!arr)21 {22 printf("arr malloc error!");23 return -1;24 }25 count = 0;26
27 return 0;28 }29
30 //销毁“队列”
31 intdestroy_array_queue()32 {33 if(arr)34 {35 free(arr);36 arr =NULL;37 }38
39 return 0;40 }41
42 //将val添加到队列的末尾
43 void add(intval)44 {45 arr[count++] =val;46 }47
48 //返回“队列开头元素”
49 intfront()50 {51 return arr[0];52 }53
54 //返回并删除“队列开头元素”
55 intpop()56 {57 int i = 0;;58 int ret = arr[0];59
60 count--;61 while (i++
64 returnret;65 }66
67 //返回“队列”的大小
68 intsize()69 {70 returncount;71 }72
73 //返回“队列”是否为空
74 intis_empty()75 {76 return count==0;77 }78
79 voidmain()80 {81 int tmp=0;82
83 //创建“队列”
84 create_array_queue(12);85
86 //将10, 20, 30 依次推入队列中
87 add(10);88 add(20);89 add(30);90
91 //将“队列开头的元素”赋值给tmp，并删除“该元素”
92 tmp =pop();93 printf("tmp=%d\n", tmp);94
95 //只将“队列开头的元素”赋值给tmp，不删除该元素.
96 tmp =front();97 printf("tmp=%d\n", tmp);98
99 add(40);100
101 //打印队列
102 printf("is_empty()=%d\n", is_empty());103 printf("size()=%d\n", size());104 while (!is_empty())105 {106 printf("%d\n", pop());107 }108
109 //销毁队列
110 destroy_array_queue();111 }
View Code
运行结果：
tmp=10tmp=20is_empty()=0size()=3
20
30
40
结果说明：该示例中的队列，是通过"数组"来实现的！
由于代码中已经给出了详细了注释，这里就不再对函数进行说明了。仅对主函数main的逻辑进行简单介绍。
(01) 在主函数main中，先将 "10, 20, 30"依次入队列。此时，队列的数据是： 10 --> 20 --> 30
(02) 接着通过pop()返回队首元素；pop()操作并不会改变队列中的数据。此时，队列的数据依然是： 10 --> 20 --> 30
(03) 接着通过front()返回并删除队首元素。front()操作之后，队列的数据是： 10 --> 30
(04) 接着通过add(40)将40入队列。add(40)操作之后，队列中的数据是： 10 --> 20 --> 40
2. C语言实现二：单向链表实现的队列，并且只能存储int数据
实现代码(slink_queue.c)
1 #include
2 #include
3
4 /**5 * C 语言: 单链表实现“队列”，只能存储int数据。6 *7 * @author skywang8 * @date 2013/11/079 */
10
11 //单链表节点
12 structnode {13 intval;14 struct node*next;15 };16
17 //表头
18 static struct node *phead=NULL;19
20 //创建节点，val为节点值
21 static struct node*create_node(val)22 {23 struct node *pnode=NULL;24 pnode = (struct node*)malloc(sizeof(structnode));25 if (!pnode)26 returnNULL;27 pnode->val =val;28 pnode->next =NULL;29
30 returnpnode;31 }32
33 //销毁单向链表
34 static intdestroy_single_link()35 {36 struct node *pnode=NULL;37
38 while (phead !=NULL)39 {40 pnode =phead;41 phead = phead->next;42 free(pnode);43 }44 return 0;45 }46
47 //将val添加到队列的末尾
48 static void add(intval)49 {50 if (!phead)51 {52 phead =create_node(val);53 return;54 }55
56 struct node *pnode =create_node(val);57 struct node *pend =phead;58 while (pend->next)59 pend = pend->next;60
61 pend->next =pnode;62 }63
64 //返回“队列开头元素”
65 intfront()66 {67 return phead->val;68 }69
70 //返回并删除“队列开头元素”
71 static intpop()72 {73 int ret = phead->val;74 struct node *pnode =phead;75
76 phead = phead->next;77 free(pnode);78
79 returnret;80 }81
82 //返回链表中节点的个数
83 static intsize()84 {85 int count=0;86 struct node *pend =phead;87
88 while(pend)89 {90 pend = pend->next;91 count++;92 }93
94 returncount;95 }96
97 //链表是否为空
98 static intis_empty()99 {100 return size()==0;101 }102
103 voidmain()104 {105 int tmp=0;106
107 //将10, 20, 30 依次加入到队列中
108 add(10);109 add(20);110 add(30);111
112 //将“队列开头元素”赋值给tmp，并删除“该元素”
113 tmp =pop();114 printf("tmp=%d\n", tmp);115
116 //只将“队列开头的元素”赋值给tmp，不删除该元素.
117 tmp =front();118 printf("tmp=%d\n", tmp);119
120 add(40);121
122 printf("is_empty()=%d\n", is_empty());123 printf("size()=%d\n", size());124 while (!is_empty())125 {126 printf("%d\n", pop());127 }128
129 //销毁队列
130 destroy_single_link();131 }
View Code
代码说明："运行结果" 以及 "主函数main的逻辑"都和"C语言实现一"的一样。不同的是，该示例中的队列是通过单向链表实现的。
3. C语言实现三：双向链表实现的队列，并且只能存储int数据
实现代码
双向链表的头文件(double_link.h)
1 #ifndef _DOUBLE_LINK_H2 #define _DOUBLE_LINK_H
3
4 //新建“双向链表”。成功，返回表头；否则，返回NULL
5 extern intcreate_dlink();6 //撤销“双向链表”。成功，返回0；否则，返回-1
7 extern intdestroy_dlink();8
9 //“双向链表是否为空”。为空的话返回1；否则，返回0。
10 extern intdlink_is_empty();11 //返回“双向链表的大小”
12 extern intdlink_size();13
14 //获取“双向链表中第index位置的元素的值”。成功，返回节点值；否则，返回-1。
15 extern int dlink_get(intindex);16 //获取“双向链表中第1个元素的值”。成功，返回节点值；否则，返回-1。
17 extern intdlink_get_first();18 //获取“双向链表中最后1个元素的值”。成功，返回节点值；否则，返回-1。
19 extern intdlink_get_last();20
21 //将“value”插入到index位置。成功，返回0；否则，返回-1。
22 extern int dlink_insert(int index, intvalue);23 //将“value”插入到表头位置。成功，返回0；否则，返回-1。
24 extern int dlink_insert_first(intvalue);25 //将“value”插入到末尾位置。成功，返回0；否则，返回-1。
26 extern int dlink_append_last(intvalue);27
28 //删除“双向链表中index位置的节点”。成功，返回0；否则，返回-1
29 extern int dlink_delete(intindex);30 //删除第一个节点。成功，返回0；否则，返回-1
31 extern intdlink_delete_first();32 //删除组后一个节点。成功，返回0；否则，返回-1
33 extern intdlink_delete_last();34
35 //打印“双向链表”
36 extern voidprint_dlink();37
38 #endif
View Code
双向链表的实现文件(double_link.c)
1 #include
2 #include
3
4 /**5 * C 语言: 双向链表，只能存储int数据。6 *7 * @author skywang8 * @date 2013/11/079 */
10
11 //双向链表节点
12 typedef structtag_node13 {14 struct tag_node *prev;15 struct tag_node *next;16 intvalue;17 }node;18
19 //表头。注意，表头不存放元素值！！！
20 static node *phead=NULL;21 //节点个数。
22 static int count=0;23
24 //新建“节点”。成功，返回节点指针；否则，返回NULL。
25 static node* create_node(intvalue)26 {27 node *pnode=NULL;28 pnode = (node *)malloc(sizeof(node));29 if (!pnode)30 {31 printf("create node error!\n");32 returnNULL;33 }34 //默认的，pnode的前一节点和后一节点都指向它自身
35 pnode->prev = pnode->next =pnode;36 //节点的值为value
37 pnode->value =value;38
39 returnpnode;40 }41
42 //新建“双向链表”。成功，返回0；否则，返回-1。
43 intcreate_dlink()44 {45 //创建表头
46 phead = create_node(-1);47 if (!phead)48 return -1;49
50 //设置“节点个数”为0
51 count = 0;52
53 return 0;54 }55
56 //“双向链表是否为空”
57 intdlink_is_empty()58 {59 return count == 0;60 }61
62 //返回“双向链表的大小”
63 intdlink_size() {64 returncount;65 }66
67 //获取“双向链表中第index位置的节点”
68 static node* get_node(intindex)69 {70 if (index<0 || index>=count)71 {72 printf("%s failed! the index in out of bound!\n", __func__);73 returnNULL;74 }75
76 //正向查找
77 if (index <= (count/2))78 {79 int i=0;80 node *pnode=phead->next;81 while ((i++) next;83
84 returnpnode;85 }86
87 //反向查找
88 int j=0;89 int rindex = count - index - 1;90 node *rnode=phead->prev;91 while ((j++) prev;93
94 returnrnode;95 }96
97 //获取“第一个节点”
98 static node*get_first_node()99 {100 return get_node(0);101 }102
103 //获取“最后一个节点”
104 static node*get_last_node()105 {106 return get_node(count-1);107 }108
109 //获取“双向链表中第index位置的元素的值”。成功，返回节点值；否则，返回-1。
110 int dlink_get(intindex)111 {112 node *pindex=get_node(index);113 if (!pindex)114 {115 printf("%s failed!\n", __func__);116 return -1;117 }118
119 return pindex->value;120
121 }122
123 //获取“双向链表中第1个元素的值”
124 intdlink_get_first()125 {126 return dlink_get(0);127 }128
129 //获取“双向链表中最后1个元素的值”
130 intdlink_get_last()131 {132 return dlink_get(count-1);133 }134
135 //将“value”插入到index位置。成功，返回0；否则，返回-1。
136 int dlink_insert(int index, intvalue)137 {138 //插入表头
139 if (index==0)140 returndlink_insert_first(value);141
142 //获取要插入的位置对应的节点
143 node *pindex=get_node(index);144 if (!pindex)145 return -1;146
147 //创建“节点”
148 node *pnode=create_node(value);149 if (!pnode)150 return -1;151
152 pnode->prev = pindex->prev;153 pnode->next =pindex;154 pindex->prev->next =pnode;155 pindex->prev =pnode;156 //节点个数+1
157 count++;158
159 return 0;160 }161
162 //将“value”插入到表头位置
163 int dlink_insert_first(intvalue)164 {165 node *pnode=create_node(value);166 if (!pnode)167 return -1;168
169 pnode->prev =phead;170 pnode->next = phead->next;171 phead->next->prev =pnode;172 phead->next =pnode;173 count++;174 return 0;175 }176
177 //将“value”插入到末尾位置
178 int dlink_append_last(intvalue)179 {180 node *pnode=create_node(value);181 if (!pnode)182 return -1;183
184 pnode->next =phead;185 pnode->prev = phead->prev;186 phead->prev->next =pnode;187 phead->prev =pnode;188 count++;189 return 0;190 }191
192 //删除“双向链表中index位置的节点”。成功，返回0；否则，返回-1。
193 int dlink_delete(intindex)194 {195 node *pindex=get_node(index);196 if (!pindex)197 {198 printf("%s failed! the index in out of bound!\n", __func__);199 return -1;200 }201
202 pindex->next->prev = pindex->prev;203 pindex->prev->next = pindex->next;204 free(pindex);205 count--;206
207 return 0;208 }209
210 //删除第一个节点
211 intdlink_delete_first()212 {213 return dlink_delete(0);214 }215
216 //删除组后一个节点
217 intdlink_delete_last()218 {219 return dlink_delete(count-1);220 }221
222 //撤销“双向链表”。成功，返回0；否则，返回-1。
223 intdestroy_dlink()224 {225 if (!phead)226 {227 printf("%s failed! dlink is null!\n", __func__);228 return -1;229 }230
231 node *pnode=phead->next;232 node *ptmp=NULL;233 while(pnode !=phead)234 {235 ptmp =pnode;236 pnode = pnode->next;237 free(ptmp);238 }239
240 free(phead);241 phead =NULL;242 count = 0;243
244 return 0;245 }246
247 //打印“双向链表”
248 voidprint_dlink()249 {250 if (count==0 || (!phead))251 {252 printf("%s dlink is empty!\n", __func__);253 return;254 }255
256 printf("%s dlink size()=%d\n", __func__, count);257 node *pnode=phead->next;258 while(pnode !=phead)259 {260 printf("%d\n", pnode->value);261 pnode = pnode->next;262 }263 }
View Code
双向链表的测试程序(dlink_queue.c)
1 #include
2 #include "double_link.h"
3
4 /**5 * C 语言: 双向链表实现“队列”，只能存储int数据。6 *7 * @author skywang8 * @date 2013/11/079 */
10
11 //创建队列
12 intcreate_dlink_queue()13 {14 returncreate_dlink();15 }16
17 //销毁队列
18 intdestroy_dlink_queue()19 {20 returndestroy_dlink();21 }22
23 //将val添加到队列的末尾
24 int add(intval)25 {26 returndlink_append_last(val);27 }28
29 //返回“队列开头元素”
30 intfront()31 {32 returndlink_get_first();33 }34
35 //返回并删除“队列开头元素”
36 intpop()37 {38 int ret =dlink_get_first();39 dlink_delete_first();40 returnret;41 }42
43 //返回“队列”的大小
44 intsize()45 {46 returndlink_size();47 }48
49 //返回“队列”是否为空
50 intis_empty()51 {52 returndlink_is_empty();53 }54
55 voidmain()56 {57 int tmp=0;58
59 //创建“队列”
60 create_dlink_queue();61
62 //将10, 20, 30 依次队列中
63 add(10);64 add(20);65 add(30);66
67 //将“队列开头的元素”赋值给tmp，并删除“该元素”
68 tmp =pop();69 printf("tmp=%d\n", tmp);70
71 //只将“队列开头的元素”赋值给tmp，不删除该元素.
72 tmp =front();73 printf("tmp=%d\n", tmp);74
75 add(40);76
77 printf("is_empty()=%d\n", is_empty());78 printf("size()=%d\n", size());79 while (!is_empty())80 {81 printf("%d\n", pop());82 }83
84 //销毁队列
85 destroy_dlink_queue();86 }
View Code
代码说明："运行结果" 以及 "主函数main的逻辑"都和前两个示例的一样。不同的是，该示例中的队列是通过双向链表实现的。
4. C语言实现四：双向链表实现的队列，能存储任意类型的数据
实现代码
双向链表的头文件(double_link.h)
1 #ifndef _DOUBLE_LINK_H2 #define _DOUBLE_LINK_H
3
4 //新建“双向链表”。成功，返回表头；否则，返回NULL
5 extern intcreate_dlink();6 //撤销“双向链表”。成功，返回0；否则，返回-1
7 extern intdestroy_dlink();8
9 //“双向链表是否为空”。为空的话返回1；否则，返回0。
10 extern intdlink_is_empty();11 //返回“双向链表的大小”
12 extern intdlink_size();13
14 //获取“双向链表中第index位置的元素”。成功，返回节点指针；否则，返回NULL。
15 extern void* dlink_get(intindex);16 //获取“双向链表中第1个元素”。成功，返回节点指针；否则，返回NULL。
17 extern void*dlink_get_first();18 //获取“双向链表中最后1个元素”。成功，返回节点指针；否则，返回NULL。
19 extern void*dlink_get_last();20
21 //将“value”插入到index位置。成功，返回0；否则，返回-1。
22 extern int dlink_insert(int index, void *pval);23 //将“value”插入到表头位置。成功，返回0；否则，返回-1。
24 extern int dlink_insert_first(void *pval);25 //将“value”插入到末尾位置。成功，返回0；否则，返回-1。
26 extern int dlink_append_last(void *pval);27
28 //删除“双向链表中index位置的节点”。成功，返回0；否则，返回-1
29 extern int dlink_delete(intindex);30 //删除第一个节点。成功，返回0；否则，返回-1
31 extern intdlink_delete_first();32 //删除组后一个节点。成功，返回0；否则，返回-1
33 extern intdlink_delete_last();34
35 #endif
View Code
双向链表的实现文件(double_link.c)
1 #include
2 #include
3
4 /**5 * C 语言: 双向链表，能存储任意数据。6 *7 * @author skywang8 * @date 2013/11/079 */
10
11 //双向链表节点
12 typedef structtag_node13 {14 struct tag_node *prev;15 struct tag_node *next;16 void*p;17 }node;18
19 //表头。注意，表头不存放元素值！！！
20 static node *phead=NULL;21 //节点个数。
22 static int count=0;23
24 //新建“节点”。成功，返回节点指针；否则，返回NULL。
25 static node* create_node(void *pval)26 {27 node *pnode=NULL;28 pnode = (node *)malloc(sizeof(node));29 if (!pnode)30 {31 printf("create node error!\n");32 returnNULL;33 }34 //默认的，pnode的前一节点和后一节点都指向它自身
35 pnode->prev = pnode->next =pnode;36 //节点的值为pval
37 pnode->p =pval;38
39 returnpnode;40 }41
42 //新建“双向链表”。成功，返回0；否则，返回-1。
43 intcreate_dlink()44 {45 //创建表头
46 phead =create_node(NULL);47 if (!phead)48 return -1;49
50 //设置“节点个数”为0
51 count = 0;52
53 return 0;54 }55
56 //“双向链表是否为空”
57 intdlink_is_empty()58 {59 return count == 0;60 }61
62 //返回“双向链表的大小”
63 intdlink_size() {64 returncount;65 }66
67 //获取“双向链表中第index位置的节点”
68 static node* get_node(intindex)69 {70 if (index<0 || index>=count)71 {72 printf("%s failed! index out of bound!\n", __func__);73 returnNULL;74 }75
76 //正向查找
77 if (index <= (count/2))78 {79 int i=0;80 node *pnode=phead->next;81 while ((i++) next;83
84 returnpnode;85 }86
87 //反向查找
88 int j=0;89 int rindex = count - index - 1;90 node *rnode=phead->prev;91 while ((j++) prev;93
94 returnrnode;95 }96
97 //获取“第一个节点”
98 static node*get_first_node()99 {100 return get_node(0);101 }102
103 //获取“最后一个节点”
104 static node*get_last_node()105 {106 return get_node(count-1);107 }108
109 //获取“双向链表中第index位置的元素”。成功，返回节点值；否则，返回-1。
110 void* dlink_get(intindex)111 {112 node *pindex=get_node(index);113 if (!pindex)114 {115 printf("%s failed!\n", __func__);116 returnNULL;117 }118
119 return pindex->p;120
121 }122
123 //获取“双向链表中第1个元素的值”
124 void*dlink_get_first()125 {126 return dlink_get(0);127 }128
129 //获取“双向链表中最后1个元素的值”
130 void*dlink_get_last()131 {132 return dlink_get(count-1);133 }134
135 //将“pval”插入到index位置。成功，返回0；否则，返回-1。
136 int dlink_insert(int index, void*pval)137 {138 //插入表头
139 if (index==0)140 returndlink_insert_first(pval);141
142 //获取要插入的位置对应的节点
143 node *pindex=get_node(index);144 if (!pindex)145 return -1;146
147 //创建“节点”
148 node *pnode=create_node(pval);149 if (!pnode)150 return -1;151
152 pnode->prev = pindex->prev;153 pnode->next =pindex;154 pindex->prev->next =pnode;155 pindex->prev =pnode;156 //节点个数+1
157 count++;158
159 return 0;160 }161
162 //将“pval”插入到表头位置
163 int dlink_insert_first(void *pval)164 {165 node *pnode=create_node(pval);166 if (!pnode)167 return -1;168
169 pnode->prev =phead;170 pnode->next = phead->next;171 phead->next->prev =pnode;172 phead->next =pnode;173 count++;174 return 0;175 }176
177 //将“pval”插入到末尾位置
178 int dlink_append_last(void *pval)179 {180 node *pnode=create_node(pval);181 if (!pnode)182 return -1;183
184 pnode->next =phead;185 pnode->prev = phead->prev;186 phead->prev->next =pnode;187 phead->prev =pnode;188 count++;189 return 0;190 }191
192 //删除“双向链表中index位置的节点”。成功，返回0；否则，返回-1。
193 int dlink_delete(intindex)194 {195 node *pindex=get_node(index);196 if (!pindex)197 {198 printf("%s failed! the index in out of bound!\n", __func__);199 return -1;200 }201
202 pindex->next->prev = pindex->prev;203 pindex->prev->next = pindex->next;204 free(pindex);205 count--;206
207 return 0;208 }209
210 //删除第一个节点
211 intdlink_delete_first()212 {213 return dlink_delete(0);214 }215
216 //删除组后一个节点
217 intdlink_delete_last()218 {219 return dlink_delete(count-1);220 }221
222 //撤销“双向链表”。成功，返回0；否则，返回-1。
223 intdestroy_dlink()224 {225 if (!phead)226 {227 printf("%s failed! dlink is null!\n", __func__);228 return -1;229 }230
231 node *pnode=phead->next;232 node *ptmp=NULL;233 while(pnode !=phead)234 {235 ptmp =pnode;236 pnode = pnode->next;237 free(ptmp);238 }239
240 free(phead);241 phead =NULL;242 count = 0;243
244 return 0;245 }
View Code
双向链表的测试程序(dlink_queue.c)
1 #include
2 #include "double_link.h"
3
4 /**5 * C 语言: 双向链表实现“队列”，能存储任意数据。6 *7 * @author skywang8 * @date 2013/11/079 */
10
11 //创建队列
12 intcreate_dlink_queue()13 {14 returncreate_dlink();15 }16
17 //销毁队列
18 intdestroy_dlink_queue()19 {20 returndestroy_dlink();21 }22
23 //将p添加到队列的末尾
24 int add(void *p)25 {26 returndlink_append_last(p);27 }28
29 //返回“队列开头元素”
30 void*front()31 {32 returndlink_get_first();33 }34
35 //返回“队列开头的元素”，并删除“该元素”
36 void*pop()37 {38 void *p =dlink_get_first();39 dlink_delete_first();40 returnp;41 }42
43 //返回“队列”的大小
44 intsize()45 {46 returndlink_size();47 }48
49 //返回“队列”是否为空
50 intis_empty()51 {52 returndlink_is_empty();53 }54
55
56 typedef structtag_stu57 {58 intid;59 char name[20];60 }stu;61
62 static stu arr_stu[] =
63 {64 {10, "sky"},65 {20, "jody"},66 {30, "vic"},67 {40, "dan"},68 };69 #define ARR_STU_SIZE ( (sizeof(arr_stu)) / (sizeof(arr_stu[0])) )
70
71 static void print_stu(stu *p)72 {73 if (!p)74 return;75
76 printf("id=%d, name=%s\n", p->id, p->name);77 }78
79 voidmain()80 {81 stu *pval=NULL;82
83 //创建“队列”
84 create_dlink_queue();85
86 //将10, 20, 30 依次推入队列中
87 int i=0;88 for (i=0; i
93 //将“队列开头的元素”赋值给tmp，并删除“该元素”
94 pval = (stu*)pop();95 print_stu(pval) ;96
97 //只将“队列开头的元素”赋值给tmp，不删除该元素.
98 pval =front();99 print_stu(pval) ;100
101 add(&arr_stu[ARR_STU_SIZE-1]);102
103 printf("is_empty()=%d\n", is_empty());104 printf("size()=%d\n", size());105 //打印队列中的所有元素
106 while (!is_empty())107 {108 pval =pop();109 print_stu(pval) ;110 }111
112 //销毁队列
113 destroy_dlink_queue();114 }
View Code
运行结果：
id=10, name=sky
id=20, name=jody
is_empty()=0size()=3id=20, name=jody
id=30, name=vic
id=40, name=dan
结果说明：该示例中的队列是通过双向链表实现的，并且能存储任意类型的数据。
队列的C++实现
C++的STL中本身就包含了list类，基本上该list类就能满足我们的需求，所以很少需要我们自己来实现。本部分介绍2种C++实现。
1. C++实现一：数组实现的队列，能存储任意类型的数据。
2. C++实现二：C++的 STL 中自带的"队列"(list)的示例。
1. C++实现一：数组实现的队列，能存储任意类型的数据
实现代码
队列的实现文件(ArrayQueue.h)
1 #ifndef ARRAY_QUEUE_HXX2 #define ARRAY_QUEUE_HXX
3
4 #include
5 using namespacestd;6
7 template classArrayQueue{8 public:9 ArrayQueue();10 ~ArrayQueue();11
12 voidadd(T t);13 T front();14 T pop();15 intsize();16 intis_empty();17
18 private:19 T *arr;20 intcount;21 };22
23 //创建“队列”，默认大小是12
24 template
25 ArrayQueue::ArrayQueue()26 {27 arr = new T[12];28 if (!arr)29 {30 cout<
34 //销毁“队列”
35 template
36 ArrayQueue::~ArrayQueue()37 {38 if(arr)39 {40 delete[] arr;41 arr =NULL;42 }43 }44
45 //将val添加到队列的末尾
46 template
47 void ArrayQueue::add(T t)48 {49 arr[count++] =t;50 }51
52
53 //返回“队列开头元素”
54 template
55 T ArrayQueue::front()56 {57 return arr[0];58 }59
60 //返回并删除“队列末尾的元素”
61 template
62 T ArrayQueue::pop()63 {64 int i = 0;;65 T ret = arr[0];66
67 count--;68 while (i++
71 returnret;72 }73
74 //返回“队列”的大小
75 template
76 int ArrayQueue::size()77 {78 returncount;79 }80
81 //返回“队列”是否为空
82 template
83 int ArrayQueue::is_empty()84 {85 return count==0;86 }87
88
89 #endif
View Code
队列的测试程序(Main.cpp)
1 #include
2 #include "ArrayQueue.h"
3 using namespacestd;4
5 /**6 * C++ : 数组实现“队列”，能存储任意数据。7 *8 * @author skywang9 * @date 2013/11/0710 */
11 intmain()12 {13 int tmp=0;14 ArrayQueue *astack = new ArrayQueue();15
16 //将10, 20, 30 依次推入队列中
17 astack->add(10);18 astack->add(20);19 astack->add(30);20
21 //将“队列开头元素”赋值给tmp，并删除“该元素”
22 tmp = astack->pop();23 cout<
25 //只将“队列开头的元素”赋值给tmp，不删除该元素.
26 tmp = astack->front();27 cout<
29 astack->add(40);30
31 cout<is_empty()<size()<is_empty())34 {35 tmp = astack->pop();36 cout<
39 return 0;40 }
View Code
运行结果：
tmp=10tmp=20is_empty()=0size()=3
20
30
40
结果说明：关于"队列的声明和实现都在头文件中"的原因，是因为队列的实现利用了C++模板，而"C++编译器不能支持对模板的分离式编译"。
2. C++实现二：C++的 STL 中自带的"队列"(list)的示例
实现代码(StlQueue.cpp)
1 #include
2 #include
3 using namespacestd;4
5 /**6 * C++ : STL中的队列(queue)的演示程序。7 *8 * @author skywang9 * @date 2013/11/0710 */
11 intmain ()12 {13 int tmp=0;14 queueiqueue;15
16 //将10, 20, 30 依次加入队列的末尾
17 iqueue.push(10);18 iqueue.push(20);19 iqueue.push(30);20
21 //删除队列开头的元素
22 iqueue.pop();23
24 //将“队列开头的元素”赋值给tmp，不删除该元素.
25 tmp =iqueue.front();26 cout<
28 //将40加入到队列的末尾
29 iqueue.push(40);30
31 cout << "empty()=" << iqueue.empty() <
40 return 0;41 }
View Code
运行结果：
tmp=20empty()=0size()=3
20
30
40
队列的Java实现
和C++一样，JDK包Queue中的也提供了"队列"的实现。JDK中的Queue接口就是"队列"，它的实现类也都是队列，用的最多的是LinkedList。本部分介绍给出2种Java实现
1. Java实现一：数组实现的队列，能存储任意类型的数据。
2. Java实现二：Java的 Collection集合 中自带的"队列"(LinkedList)的示例。
1. Java实现一：数组实现的队列，能存储任意类型的数据
实现代码(ArrayQueue.java)
1 /**
2 * Java : 数组实现“队列”，只能存储int数据。3 *4 *@authorskywang5 * @date 2013/11/076 */
7 public classArrayQueue {8
9 private int[] mArray;10 private intmCount;11
12 public ArrayQueue(intsz) {13 mArray = new int[sz];14 mCount = 0;15 }16
17 //将val添加到队列的末尾
18 public void add(intval) {19 mArray[mCount++] =val;20 }21
22 //返回“队列开头元素”
23 public intfront() {24 return mArray[0];25 }26
27 //返回“栈顶元素值”，并删除“栈顶元素”
28 public intpop() {29 int ret = mArray[0];30 mCount--;31 for (int i=1; i<=mCount; i++)32 mArray[i-1] =mArray[i];33 returnret;34 }35
36 //返回“栈”的大小
37 public intsize() {38 returnmCount;39 }40
41 //返回“栈”是否为空
42 public booleanisEmpty() {43 return size()==0;44 }45
46 public static voidmain(String[] args) {47 int tmp=0;48 ArrayQueue astack = new ArrayQueue(12);49
50 //将10, 20, 30 依次推入栈中
51 astack.add(10);52 astack.add(20);53 astack.add(30);54
55 //将“栈顶元素”赋值给tmp，并删除“栈顶元素”
56 tmp =astack.pop();57 System.out.printf("tmp=%d\n", tmp);58
59 //只将“栈顶”赋值给tmp，不删除该元素.
60 tmp =astack.front();61 System.out.printf("tmp=%d\n", tmp);62
63 astack.add(40);64
65 System.out.printf("isEmpty()=%b\n", astack.isEmpty());66 System.out.printf("size()=%d\n", astack.size());67 while (!astack.isEmpty()) {68 System.out.printf("size()=%d\n", astack.pop());69 }70 }71 }
View Code
运行结果：
tmp=10tmp=20isEmpty()=falsesize()=3size()=20size()=30size()=40
结果说明：ArrayQueue是通过数组实现的队列，而且ArrayQueue中使用到了泛型，因此它支持任意类型的数据。
2. Java实现二：Java的 Collection集合 中自带的"队列"(LinkedList)的示例
实现代码(QueueTest.java)
1 importjava.util.Stack;2
3 /**
4 * 用“栈”实现队列5 *6 *@authorskywang7 */
8 public class StackList{9
10 //向队列添加数据时：(01) 将“已有的全部数据”都移到mIn中。 (02) 将“新添加的数据”添加到mIn中。
11 private Stack mIn = null;12 //从队列获取元素时：(01) 将“已有的全部数据”都移到mOut中。(02) 返回并删除mOut栈顶元素。
13 private Stack mOut = null;14 //统计计数
15 private int mCount = 0;16
17 publicStackList() {18 mIn = new Stack();19 mOut = new Stack();20 mCount = 0;21 }22
23 private voidadd(T t) {24 //将“已有的全部数据”都移到mIn中
25 while (!mOut.empty())26 mIn.push(mOut.pop());27
28 //将“新添加的数据”添加到mIn中
29 mIn.push(t);30 //统计数+1
31 mCount++;32 }33
34 privateT get() {35 //将“已有的全部数据”都移到mOut中
36 while (!mIn.empty())37 mOut.push(mIn.pop());38 //统计数-1
39 mCount--;40
41 //返回并删除mOut栈顶元素
42 returnmOut.pop();43 }44
45 private intsize() {46 returnmCount;47 }48 private booleanisEmpty() {49 return mCount==0;50 }51
52 public static voidmain(String[] args) {53 StackList slist = newStackList();54
55 //将10, 20, 30 依次推入栈中
56 slist.add(10);57 slist.add(20);58 slist.add(30);59
60 System.out.printf("isEmpty()=%b\n", slist.isEmpty());61 System.out.printf("size()=%d\n", slist.size());62 while(!slist.isEmpty()) {63 System.out.printf("%d\n", slist.get());64 }65 }66 }
View Code
运行结果：
tmp=10tmp=20isEmpty()=falsesize()=3tmp=20tmp=30tmp=40
2847
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
