概要
本章和介绍”栈“时的流程一样，先对队列进行介绍，然后分别给出队列的C、C++和Java三种语言的实现。内容包括：
1. 队列的介绍
2. 队列的C实现
3. 队列的C++实现
4. 队列的Java实现
转载请注明出处：http://www.cnblogs.com/skywang12345/p/3562279.html
更多内容: 数据结构与算法系列 目录
队列的介绍
队列（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 <stdio.h> 2 #include <malloc.h> 3 4 /** 5 * C 语言: 数组实现的队列，只能存储int数据。 6 * 7 * @author skywang 8 * @date 2013/11/07 9 */ 10 11 // 保存数据的数组 12 static int *arr=NULL; 13 // 队列的实际大小 14 static int count; 15 16 // 创建“队列” 17 int create_array_queue(int sz) 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 int destroy_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(int val) 44 { 45 arr[count++] = val; 46 } 47 48 // 返回“队列开头元素” 49 int front() 50 { 51 return arr[0]; 52 } 53 54 // 返回并删除“队列开头元素” 55 int pop() 56 { 57 int i = 0;; 58 int ret = arr[0]; 59 60 count--; 61 while (i++<count) 62 arr[i-1] = arr[i]; 63 64 return ret; 65 } 66 67 // 返回“队列”的大小 68 int size() 69 { 70 return count; 71 } 72 73 // 返回“队列”是否为空 74 int is_empty() 75 { 76 return count==0; 77 } 78 79 void main() 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=10 tmp=20 is_empty()=0 size()=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 <stdio.h> 2 #include <malloc.h> 3 4 /** 5 * C 语言: 单链表实现“队列”，只能存储int数据。 6 * 7 * @author skywang 8 * @date 2013/11/07 9 */ 10 11 // 单链表节点 12 struct node { 13 int val; 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(struct node)); 25 if (!pnode) 26 return NULL; 27 pnode->val = val; 28 pnode->next = NULL; 29 30 return pnode; 31 } 32 33 // 销毁单向链表 34 static int destroy_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(int val) 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 int front() 66 { 67 return phead->val; 68 } 69 70 // 返回并删除“队列开头元素” 71 static int pop() 72 { 73 int ret = phead->val; 74 struct node *pnode = phead; 75 76 phead = phead->next; 77 free(pnode); 78 79 return ret; 80 } 81 82 // 返回链表中节点的个数 83 static int size() 84 { 85 int count=0; 86 struct node *pend = phead; 87 88 while (pend) 89 { 90 pend = pend->next; 91 count++; 92 } 93 94 return count; 95 } 96 97 // 链表是否为空 98 static int is_empty() 99 { 100 return size()==0; 101 } 102 103 void main() 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_H 2 #define _DOUBLE_LINK_H 3 4 // 新建“双向链表”。成功，返回表头；否则，返回NULL 5 extern int create_dlink(); 6 // 撤销“双向链表”。成功，返回0；否则，返回-1 7 extern int destroy_dlink(); 8 9 // “双向链表是否为空”。为空的话返回1；否则，返回0。 10 extern int dlink_is_empty(); 11 // 返回“双向链表的大小” 12 extern int dlink_size(); 13 14 // 获取“双向链表中第index位置的元素的值”。成功，返回节点值；否则，返回-1。 15 extern int dlink_get(int index); 16 // 获取“双向链表中第1个元素的值”。成功，返回节点值；否则，返回-1。 17 extern int dlink_get_first(); 18 // 获取“双向链表中最后1个元素的值”。成功，返回节点值；否则，返回-1。 19 extern int dlink_get_last(); 20 21 // 将“value”插入到index位置。成功，返回0；否则，返回-1。 22 extern int dlink_insert(int index, int value); 23 // 将“value”插入到表头位置。成功，返回0；否则，返回-1。 24 extern int dlink_insert_first(int value); 25 // 将“value”插入到末尾位置。成功，返回0；否则，返回-1。 26 extern int dlink_append_last(int value); 27 28 // 删除“双向链表中index位置的节点”。成功，返回0；否则，返回-1 29 extern int dlink_delete(int index); 30 // 删除第一个节点。成功，返回0；否则，返回-1 31 extern int dlink_delete_first(); 32 // 删除组后一个节点。成功，返回0；否则，返回-1 33 extern int dlink_delete_last(); 34 35 // 打印“双向链表” 36 extern void print_dlink(); 37 38 #endif
View Code
双向链表的实现文件(double_link.c)
1 #include <stdio.h> 2 #include <malloc.h> 3 4 /** 5 * C 语言: 双向链表，只能存储int数据。 6 * 7 * @author skywang 8 * @date 2013/11/07 9 */ 10 11 // 双向链表节点 12 typedef struct tag_node 13 { 14 struct tag_node *prev; 15 struct tag_node *next; 16 int value; 17 }node; 18 19 // 表头。注意，表头不存放元素值！！！ 20 static node *phead=NULL; 21 // 节点个数。 22 static int count=0; 23 24 // 新建“节点”。成功，返回节点指针；否则，返回NULL。 25 static node* create_node(int value) 26 { 27 node *pnode=NULL; 28 pnode = (node *)malloc(sizeof(node)); 29 if (!pnode) 30 { 31 printf("create node error!\n"); 32 return NULL; 33 } 34 // 默认的，pnode的前一节点和后一节点都指向它自身 35 pnode->prev = pnode->next = pnode; 36 // 节点的值为value 37 pnode->value = value; 38 39 return pnode; 40 } 41 42 // 新建“双向链表”。成功，返回0；否则，返回-1。 43 int create_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 int dlink_is_empty() 58 { 59 return count == 0; 60 } 61 62 // 返回“双向链表的大小” 63 int dlink_size() { 64 return count; 65 } 66 67 // 获取“双向链表中第index位置的节点” 68 static node* get_node(int index) 69 { 70 if (index<0 || index>=count) 71 { 72 printf("%s failed! the index in out of bound!\n", __func__); 73 return NULL; 74 } 75 76 // 正向查找 77 if (index <= (count/2)) 78 { 79 int i=0; 80 node *pnode=phead->next; 81 while ((i++) < index) 82 pnode = pnode->next; 83 84 return pnode; 85 } 86 87 // 反向查找 88 int j=0; 89 int rindex = count - index - 1; 90 node *rnode=phead->prev; 91 while ((j++) < rindex) 92 rnode = rnode->prev; 93 94 return rnode; 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(int index) 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 int dlink_get_first() 125 { 126 return dlink_get(0); 127 } 128 129 // 获取“双向链表中最后1个元素的值” 130 int dlink_get_last() 131 { 132 return dlink_get(count-1); 133 } 134 135 // 将“value”插入到index位置。成功，返回0；否则，返回-1。 136 int dlink_insert(int index, int value) 137 { 138 // 插入表头 139 if (index==0) 140 return dlink_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(int value) 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(int value) 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(int index) 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 int dlink_delete_first() 212 { 213 return dlink_delete(0); 214 } 215 216 // 删除组后一个节点 217 int dlink_delete_last() 218 { 219 return dlink_delete(count-1); 220 } 221 222 // 撤销“双向链表”。成功，返回0；否则，返回-1。 223 int destroy_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 void print_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 <stdio.h> 2 #include "double_link.h" 3 4 /** 5 * C 语言: 双向链表实现“队列”，只能存储int数据。 6 * 7 * @author skywang 8 * @date 2013/11/07 9 */ 10 11 // 创建队列 12 int create_dlink_queue() 13 { 14 return create_dlink(); 15 } 16 17 // 销毁队列 18 int destroy_dlink_queue() 19 { 20 return destroy_dlink(); 21 } 22 23 // 将val添加到队列的末尾 24 int add(int val) 25 { 26 return dlink_append_last(val); 27 } 28 29 // 返回“队列开头元素” 30 int front() 31 { 32 return dlink_get_first(); 33 } 34 35 // 返回并删除“队列开头元素” 36 int pop() 37 { 38 int ret = dlink_get_first(); 39 dlink_delete_first(); 40 return ret; 41 } 42 43 // 返回“队列”的大小 44 int size() 45 { 46 return dlink_size(); 47 } 48 49 // 返回“队列”是否为空 50 int is_empty() 51 { 52 return dlink_is_empty(); 53 } 54 55 void main() 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_H 2 #define _DOUBLE_LINK_H 3 4 // 新建“双向链表”。成功，返回表头；否则，返回NULL 5 extern int create_dlink(); 6 // 撤销“双向链表”。成功，返回0；否则，返回-1 7 extern int destroy_dlink(); 8 9 // “双向链表是否为空”。为空的话返回1；否则，返回0。 10 extern int dlink_is_empty(); 11 // 返回“双向链表的大小” 12 extern int dlink_size(); 13 14 // 获取“双向链表中第index位置的元素”。成功，返回节点指针；否则，返回NULL。 15 extern void* dlink_get(int index); 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(int index); 30 // 删除第一个节点。成功，返回0；否则，返回-1 31 extern int dlink_delete_first(); 32 // 删除组后一个节点。成功，返回0；否则，返回-1 33 extern int dlink_delete_last(); 34 35 #endif
View Code
双向链表的实现文件(double_link.c)
1 #include <stdio.h> 2 #include <malloc.h> 3 4 /** 5 * C 语言: 双向链表，能存储任意数据。 6 * 7 * @author skywang 8 * @date 2013/11/07 9 */ 10 11 // 双向链表节点 12 typedef struct tag_node 13 { 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 return NULL; 33 } 34 // 默认的，pnode的前一节点和后一节点都指向它自身 35 pnode->prev = pnode->next = pnode; 36 // 节点的值为pval 37 pnode->p = pval; 38 39 return pnode; 40 } 41 42 // 新建“双向链表”。成功，返回0；否则，返回-1。 43 int create_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 int dlink_is_empty() 58 { 59 return count == 0; 60 } 61 62 // 返回“双向链表的大小” 63 int dlink_size() { 64 return count; 65 } 66 67 // 获取“双向链表中第index位置的节点” 68 static node* get_node(int index) 69 { 70 if (index<0 || index>=count) 71 { 72 printf("%s failed! index out of bound!\n", __func__); 73 return NULL; 74 } 75 76 // 正向查找 77 if (index <= (count/2)) 78 { 79 int i=0; 80 node *pnode=phead->next; 81 while ((i++) < index) 82 pnode = pnode->next; 83 84 return pnode; 85 } 86 87 // 反向查找 88 int j=0; 89 int rindex = count - index - 1; 90 node *rnode=phead->prev; 91 while ((j++) < rindex) 92 rnode = rnode->prev; 93 94 return rnode; 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(int index) 111 { 112 node *pindex=get_node(index); 113 if (!pindex) 114 { 115 printf("%s failed!\n", __func__); 116 return NULL; 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 return dlink_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(int index) 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 int dlink_delete_first() 212 { 213 return dlink_delete(0); 214 } 215 216 // 删除组后一个节点 217 int dlink_delete_last() 218 { 219 return dlink_delete(count-1); 220 } 221 222 // 撤销“双向链表”。成功，返回0；否则，返回-1。 223 int destroy_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 <stdio.h> 2 #include "double_link.h" 3 4 /** 5 * C 语言: 双向链表实现“队列”，能存储任意数据。 6 * 7 * @author skywang 8 * @date 2013/11/07 9 */ 10 11 // 创建队列 12 int create_dlink_queue() 13 { 14 return create_dlink(); 15 } 16 17 // 销毁队列 18 int destroy_dlink_queue() 19 { 20 return destroy_dlink(); 21 } 22 23 // 将p添加到队列的末尾 24 int add(void *p) 25 { 26 return dlink_append_last(p); 27 } 28 29 // 返回“队列开头元素” 30 void* front() 31 { 32 return dlink_get_first(); 33 } 34 35 // 返回“队列开头的元素”，并删除“该元素” 36 void* pop() 37 { 38 void *p = dlink_get_first(); 39 dlink_delete_first(); 40 return p; 41 } 42 43 // 返回“队列”的大小 44 int size() 45 { 46 return dlink_size(); 47 } 48 49 // 返回“队列”是否为空 50 int is_empty() 51 { 52 return dlink_is_empty(); 53 } 54 55 56 typedef struct tag_stu 57 { 58 int id; 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 void main() 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<ARR_STU_SIZE-1; i++) 89 { 90 add(&arr_stu[i]); 91 } 92 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()=0 size()=3 id=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_HXX 2 #define ARRAY_QUEUE_HXX 3 4 #include <iostream> 5 using namespace std; 6 7 template<class T> class ArrayQueue{ 8 public: 9 ArrayQueue(); 10 ~ArrayQueue(); 11 12 void add(T t); 13 T front(); 14 T pop(); 15 int size(); 16 int is_empty(); 17 18 private: 19 T *arr; 20 int count; 21 }; 22 23 // 创建“队列”，默认大小是12 24 template<class T> 25 ArrayQueue<T>::ArrayQueue() 26 { 27 arr = new T[12]; 28 if (!arr) 29 { 30 cout<<"arr malloc error!"<<endl; 31 } 32 } 33 34 // 销毁“队列” 35 template<class T> 36 ArrayQueue<T>::~ArrayQueue() 37 { 38 if (arr) 39 { 40 delete[] arr; 41 arr = NULL; 42 } 43 } 44 45 // 将val添加到队列的末尾 46 template<class T> 47 void ArrayQueue<T>::add(T t) 48 { 49 arr[count++] = t; 50 } 51 52 53 // 返回“队列开头元素” 54 template<class T> 55 T ArrayQueue<T>::front() 56 { 57 return arr[0]; 58 } 59 60 // 返回并删除“队列末尾的元素” 61 template<class T> 62 T ArrayQueue<T>::pop() 63 { 64 int i = 0;; 65 T ret = arr[0]; 66 67 count--; 68 while (i++<count) 69 arr[i-1] = arr[i]; 70 71 return ret; 72 } 73 74 // 返回“队列”的大小 75 template<class T> 76 int ArrayQueue<T>::size() 77 { 78 return count; 79 } 80 81 // 返回“队列”是否为空 82 template<class T> 83 int ArrayQueue<T>::is_empty() 84 { 85 return count==0; 86 } 87 88 89 #endif
View Code
队列的测试程序(Main.cpp)
1 #include <iostream> 2 #include "ArrayQueue.h" 3 using namespace std; 4 5 /** 6 * C++ : 数组实现“队列”，能存储任意数据。 7 * 8 * @author skywang 9 * @date 2013/11/07 10 */ 11 int main() 12 { 13 int tmp=0; 14 ArrayQueue<int> *astack = new ArrayQueue<int>(); 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<<"tmp="<<tmp<<endl; 24 25 // 只将“队列开头的元素”赋值给tmp，不删除该元素. 26 tmp = astack->front(); 27 cout<<"tmp="<<tmp<<endl; 28 29 astack->add(40); 30 31 cout<<"is_empty()="<<astack->is_empty()<<endl; 32 cout<<"size()="<<astack->size()<<endl; 33 while (!astack->is_empty()) 34 { 35 tmp = astack->pop(); 36 cout<<tmp<<endl; 37 } 38 39 return 0; 40 }
View Code
运行结果：
tmp=10 tmp=20 is_empty()=0 size()=3 20 30 40
结果说明：关于”队列的声明和实现都在头文件中”的原因，是因为队列的实现利用了C++模板，而”C++编译器不能支持对模板的分离式编译”。
2. C++实现二：C++的 STL 中自带的”队列”(list)的示例
实现代码(StlQueue.cpp)
1 #include <iostream> 2 #include <queue> 3 using namespace std; 4 5 /** 6 * C++ : STL中的队列(queue)的演示程序。 7 * 8 * @author skywang 9 * @date 2013/11/07 10 */ 11 int main () 12 { 13 int tmp=0; 14 queue<int> iqueue; 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<<"tmp="<<tmp<<endl; 27 28 // 将40加入到队列的末尾 29 iqueue.push(40); 30 31 cout << "empty()=" << iqueue.empty() <<endl; 32 cout << "size()=" << iqueue.size() <<endl; 33 while (!iqueue.empty()) 34 { 35 tmp = iqueue.front(); 36 cout<<tmp<<endl; 37 iqueue.pop(); 38 } 39 40 return 0; 41 }
View Code
运行结果：
tmp=20 empty()=0 size()=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 * @author skywang 5 * @date 2013/11/07 6 */ 7 public class ArrayQueue { 8 9 private int[] mArray; 10 private int mCount; 11 12 public ArrayQueue(int sz) { 13 mArray = new int[sz]; 14 mCount = 0; 15 } 16 17 // 将val添加到队列的末尾 18 public void add(int val) { 19 mArray[mCount++] = val; 20 } 21 22 // 返回“队列开头元素” 23 public int front() { 24 return mArray[0]; 25 } 26 27 // 返回“栈顶元素值”，并删除“栈顶元素” 28 public int pop() { 29 int ret = mArray[0]; 30 mCount--; 31 for (int i=1; i<=mCount; i++) 32 mArray[i-1] = mArray[i]; 33 return ret; 34 } 35 36 // 返回“栈”的大小 37 public int size() { 38 return mCount; 39 } 40 41 // 返回“栈”是否为空 42 public boolean isEmpty() { 43 return size()==0; 44 } 45 46 public static void main(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=10 tmp=20 isEmpty()=false size()=3 size()=20 size()=30 size()=40
结果说明：ArrayQueue是通过数组实现的队列，而且ArrayQueue中使用到了泛型，因此它支持任意类型的数据。
2. Java实现二：Java的 Collection集合 中自带的”队列”(LinkedList)的示例
实现代码(QueueTest.java)
1 import java.util.Stack; 2 3 /** 4 * 用“栈”实现队列 5 * 6 * @author skywang 7 */ 8 public class StackList<T> { 9 10 // 向队列添加数据时：(01) 将“已有的全部数据”都移到mIn中。 (02) 将“新添加的数据”添加到mIn中。 11 private Stack<T> mIn = null; 12 // 从队列获取元素时：(01) 将“已有的全部数据”都移到mOut中。(02) 返回并删除mOut栈顶元素。 13 private Stack<T> mOut = null; 14 // 统计计数 15 private int mCount = 0; 16 17 public StackList() { 18 mIn = new Stack<T>(); 19 mOut = new Stack<T>(); 20 mCount = 0; 21 } 22 23 private void add(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 private T get() { 35 // 将“已有的全部数据”都移到mOut中 36 while (!mIn.empty()) 37 mOut.push(mIn.pop()); 38 // 统计数-1 39 mCount--; 40 41 // 返回并删除mOut栈顶元素 42 return mOut.pop(); 43 } 44 45 private int size() { 46 return mCount; 47 } 48 private boolean isEmpty() { 49 return mCount==0; 50 } 51 52 public static void main(String[] args) { 53 StackList slist = new StackList(); 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=10 tmp=20 isEmpty()=false size()=3 tmp=20 tmp=30 tmp=40
