中国海军百年军服——人民海军65式与74式军服
& & 65式海军服
& & 1966年，中国共产党中央政治局扩大会议和八届十一中全会相继通过了&五一六通知&和&关于无产阶级文化革命的决定&2个重要文件，标志着历时10年、席卷全国的政治运动&文化大革命正式开始。与这一政治运动几乎同步，在早已经越聚越浓的极左政治空气中，中国海军的制服也发生了特殊变化。
& & 旨在体现官兵一致的无产阶级革命传统，日，第八届全国人民代表大会常务委员会第九次会议做出决定，取消人民解放军的军衔制度，自55式军服开始逐渐成熟、完善的各种军衔徽记设计退出历史舞台。与之相配套，5月24日，国务院即公布了一套全新的军服制度，并通知于当年的6月1日正式施行。按照人民解放军军服的命名传统，这套诞生于1965年的军服规范，称为65式军服。
& & 与陆、空军制度的变化相比，人民解放军海军65式军服较55式军服的变化最大，可谓面目全新，完全清除了苏式海军服装传统的影响，干部、战土服都改成了人民军队传统的中山装、解放帽样式(女军人的军服采用西装领口上衣，无檐圆形软军帽)，与65式陆、空军制服相同，而且不再有礼服、常服等服装种类，只有单一的一种制服，显出了极为朴素的风格。
& & 人民解放军海军的制服整体颜色为蓝灰色，以区别服装裁剪样式完全相同的陆、空军制服。军帽统一是解放帽，帽徽改用三军统一的红五星徽，材料为铝制烤漆，这种帽徽诞生于江西苏区工农红军时代。军服采用工农红军时就曾使用过的中山装式样，棉布面料，前襟钉5颗棕褐色胶木钮扣，服装上不再有任何军衔符号、徽记，只是在衣领上装饰了红色领章，与帽徽一样，都是仿工
& & 农红军时代的军服，有所区别的是，在领章的反面还印有供填写部队番号、姓名、血型的表格，用意与西方军队的&狗牌&相同。帽徽上的红星和领口的红领章，让人恍若又回到了两万五千里长征的火热岁月，这种独特的军服佩饰符合无产阶级革命时代的审美和政治要求，时称&一颗红星头上戴，革命红旗挂两边&。尽管着重体现革命军队官兵一致的政治诉求，但是考虑到具体识别时的需要，干部、战士服在细微处仍然保留了一些区别，主要是干部制服的上衣有4个口袋，战士制服则只有胸前的2个口袋，另外干部配发皮鞋，战士大部分只有俗称为&解放鞋&的作训胶鞋以及黑布鞋。
& & 65式军服换装不久，人民解放军海军接连在东南沿海进行了&八&六海战&和&崇武以东海战&，采用鱼雷艇、护卫艇集群编队出击战术，以大量小型高速舰艇围攻数量上呈劣势的敌方大型军舰，先后击沉了国民党海军的&剑门&、&章江&、&永昌&军舰。伴随着辉煌的战绩，样式奇特、不同于世界海军的中国工农红军式特殊海军服开始引起世人注目。
& & 74式海军服
& & 随着政治运动的变化，在林彪集团倒台、&四人帮&结成、文化大革命进行到&批林批孔&时期后，人民解放军的65式军服又进行了改良。经中央军委主席毛泽东批准，日，人民解放军的军服样式部分恢复到65式军服诞生以前的状态，这一对65式军服的改良样式，又可称为74式军服。
& & 74式军服取消了65式军服官兵一式的设计，重又分为了干部服、战士服。同时改变了65式军服四季一式的单调外观，重新按照春、秋、冬和夏季，在色泽搭配上有所区别。74式海军干部服的军帽改作了类似55式的大檐帽，帽徽仍然还是65式的红色五角星。其中春、秋、冬季军帽帽顶为藏青色，缀有白色牙线，帽墙、风带均为黑色。夏季军帽的帽顶戴白色帽罩。
& & 海军干部服的服装裁剪和65式基本相同，领口还是装饰红领章，只是色泽搭配进行了变化。春、秋、冬季军服上下均为藏青色，夏季军服则改作上衣白色、军裤藏青色的苏式半白服设计。
& & 74式海军战土服的军帽改回了55式的苏式水兵帽，春、秋、冬季帽顶藏青色，缀白色牙线，夏季戴白色帽罩，均佩65式的红五星帽徽。帽墙钉一圈黑色飘带，飘带上的文字仍然是简化字&中国人民解放军海军&，但是改成成本较低的金粉印刷，不再使用刺绣。非常突兀的是，在极左思维下，一方面由于过于&洋气&的水兵帽在当时的审美氛围中显得格格不入，另外根据欧式水兵帽飘带的历史渊源是纪念特拉法尔加海战中阵亡的英国海军名将纳尔逊这一寓意，&四人帮&以不能为帝国主义披麻带孝为由，将水兵帽上的飘带缩短，不再有飘在脑后显得&洋气&、&张扬&的部分，而只围绕帽墙一圈。
& & 战士服的上衣再次采用苏式的套头衫，样式与55式基本相同，也是V字领，带披肩，只是在原先肩章的位置上，改佩戴2块全红色的肩章，用意与65式军服的红领章相同。74式战士服春、秋、冬季上下均为藏青色，夏季则是上白下蓝的半白式。
& & 日，为捍卫领海主权，人民解放军海军舰艇部队与入侵中国西沙群岛海域的南越海军展开激战，击沉了南越海军&怒涛&号护卫舰，收复甘泉、珊瑚、金银3座被侵占的岛礁。作为文化大革命时期重要的对外自卫作战，中央媒体对西沙海战胜利的消息长期重点报道。非常有趣的是，在早期的摄影报道中，参加作战的干部战士身着的都是65式军服，而之后大量出现的宣传照片则全改作了海战之后才换装的74式海军服，又因为&四人帮&的个人好恶，对外公布的照片中，身着74式军服的海军干部战土大都头戴钢盔，很少出现带有&苏修&和&帝国主义&嫌疑的大檐帽、水兵帽形象。成了特殊历史时期的一种特殊现象。
& & 日，毛泽东逝世，10月&四人帮&被粉碎，文化大革命事实上结束。74式军服再次改进，水兵帽后的飘带得以恢复，同时海军战士夏季增发短袖衬衫。伴随着政治运动出现的65式军服在数次改良后逐渐淡化着最初的设计，中国海军的制服即将迎来又一次全面变革。
责任编辑：Larry Gates
相关推荐：
看完这篇文章有何感觉？已经有0人表态
北京市海淀区中科资源大厦南楼4层 水木汇咖啡馆热门搜索：
购物车中还没有商品，赶紧选购吧！
& 65式指北针(地质罗盘仪）
65式指北针(地质罗盘仪）户外出行最佳伴侣
号：YS000561
市 场 价：￥173元
米 尔 价：￥108.00
评&&&&分：
库&&&&存：总仓有货（支持货到付款）
月 销 量：12 件
数&&&&量：
退换货服务
还没有人购买过此商品
暂时还没有任何用户咨询
没有您需要的答案？您可以提问，客服将在1个工作日内回复您。
订单查询、物流配送、退换货、商品损坏等售后问题，您可以拨打7x12小时客服电话：400- 。
65式指北针(地质罗盘仪）
客服将在24小时内回复您，请在“用户中心>评论咨询”中查看
登录之后才能咨询
1.购买流程:
2.配送信息:
配送物流：
本站默认顺丰，同时支持宅急送、申通、EMS
配送范围：
全国大部分地区均可送达
始发货地：
总仓北京发货。
延迟说明：
如遇国家法定节假日或异常天气状况，订单配送
可能会出现一定的延迟，届时米尔君品要塞会在
第一时间联系您，与您沟通！
3.支付信息:
第三方支付平台
只要您开通了以下银行的"网上支付"功能，即可进行在线支付，无需手续费，实时到帐，方便快捷！
您可以到银行通过"转账"进行支付。查看详细方式&&
快递公司送货上门，客户收单验货后，直接将货款交付给配送员的结算方式。
（注：目前暂未开通刷卡服务，货到后需要现金支付）
您的任何疑问均可致电我们的客服电话 400- 咨询（仅收市话费）
1.发票制度
当您购买了商品后，告知客服，本商品是否需要开发票，开发票需要补税点，也可通过电话咨询：400-（免长途费）
2.退换货保障
退货时间限制：自该商品购买之日（客户收货日期）起7天
换货时间限制：自购买商品之日（客户收货日期）起15天
100%用户满意
写评价，赢金币！前5名双倍哟！更多金币轻松拿~
全部评论(4)
不错就是没送到地方
害我跑好多地方才接到
但是东西质量不错 很好用
店小二：您好，谢谢您对米尔要塞的支持，我们只卖正品的，质量您可放心，由于送货让您跑远我们表示歉意，请您谅解，我们会努力完善，谢谢您的关注和支持。
绝不心软****
重在实用啊！很不错也很好用！
店小二：谢谢您对米尔君品要塞的支持，我们会更加努力为顾客服务！
为爱而生****
很好!质量不错！
店小二：您好！此款 65式指北针 品质优良，做工精细。感谢您对米尔君品要塞的支持，我们会努力做得更好。
达盖尔****
指南针很实用！还有测量功能很是喜欢！出行帮手啊！
店小二：您好！本款指北针是出行必备工具。感谢您对米尔君品要塞的支持，请您继续关注米尔君品要塞，祝您购物愉快。
商品名称：
65式指北针(地质罗盘仪） 户外出行最佳伴侣
可选属性：
尺&&&&码：
选择城市：
--请选择国家--
--请选择省--
--请选择市--
收货人姓名：
收件人地址：
快速订购只是针对单个商品购物，如果您想获得优惠，或者订购多个商品请加入购物车后选择注册会员结算。(注册会员购物将会有更多精美礼品赠送！)
配送与支付
关注微信有奖
米尔君品要塞 版权所有，并保留所有权利，
京ICP备号 京ICP证120085号 京公网安备70队列的图文解析 和 对应3种语言的实现(C/C++/Java) - 如果天空不死 - 推酷
队列的图文解析 和 对应3种语言的实现(C/C++/Java) - 如果天空不死
本章和介绍&栈&时的流程一样，先对队列进行介绍，然后分别给出队列的C、C++和Java三种语言的实现。内容包括：
1.&队列的介绍
2.&队列的C实现
3.&队列的C++实现
4.&队列的Java实现
转载请注明出处：
更多内容:&
队列（Queue），是一种线性存储结构。它有以下几个特点：
(01) 队列中数据是按照&先进先出（FIFO, First-In-First-Out）&方式进出队列的。
(02) 队列只允许在&队首&进行删除操作，而在&队尾&进行插入操作。
队列通常包括的两种操作：
1. 队列的示意图
队列中有10，20，30共3个数据。
：队首是10，队尾是30。
：出队列(队首)之后。队首是20，队尾是30。
：队首是20，队尾是30。
：40入队列(队尾)之后。队首是20，队尾是40。
下面介绍队列的实现，分别介绍C/C++/Java三种实现
共介绍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&
* C 语言: 数组实现的队列，只能存储int数据。
* @author skywang
11 // 保存数据的数组
12 static int *arr=NULL;
13 // 队列的实际大小
14 static int
16 // 创建“队列”
17 int create_array_queue(int sz)
arr = (int *)malloc(sz*sizeof(int));
printf(&arr malloc error!&);
return -1;
count = 0;
30 // 销毁“队列”
31 int destroy_array_queue()
free(arr);
arr = NULL;
42 // 将val添加到队列的末尾
43 void add(int val)
arr[count++] =
48 // 返回“队列开头元素”
49 int front()
return arr[0];
54 // 返回并删除“队列开头元素”
55 int pop()
int i = 0;;
int ret = arr[0];
while (i++&count)
arr[i-1] = arr[i];
67 // 返回“队列”的大小
68 int size()
73 // 返回“队列”是否为空
74 int is_empty()
return count==0;
79 void main()
int tmp=0;
// 创建“队列”
create_array_queue(12);
// 将10, 20, 30 依次推入队列中
// 将“队列开头的元素”赋值给tmp，并删除“该元素”
tmp = pop();
printf(&tmp=%d\n&, tmp);
// 只将“队列开头的元素”赋值给tmp，不删除该元素.
tmp = front();
printf(&tmp=%d\n&, tmp);
// 打印队列
printf(&is_empty()=%d\n&, is_empty());
printf(&size()=%d\n&, size());
while (!is_empty())
printf(&%d\n&, pop());
// 销毁队列
destroy_array_queue();
is_empty()=0
该示例中的队列，是通过&数组&来实现的！
由于代码中已经给出了详细了注释，这里就不再对函数进行说明了。仅对主函数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&
* C 语言: 单链表实现“队列”，只能存储int数据。
* @author skywang
11 // 单链表节点
12 struct node {
struct node*
17 // 表头
18 static struct node *phead=NULL;
20 // 创建节点，val为节点值
21 static struct node* create_node(val)
struct node *pnode=NULL;
pnode = (struct node*)malloc(sizeof(struct node));
if (!pnode)
return NULL;
pnode-&val =
pnode-&next = NULL;
33 // 销毁单向链表
34 static int destroy_single_link()
struct node *pnode=NULL;
while (phead != NULL)
phead = phead-&
free(pnode);
47 // 将val添加到队列的末尾
48 static void add(int val)
if (!phead)
phead = create_node(val);
struct node *pnode = create_node(val);
struct node *pend =
while (pend-&next)
pend = pend-&
pend-&next =
64 // 返回“队列开头元素”
65 int front()
return phead-&
70 // 返回并删除“队列开头元素”
71 static int pop()
int ret = phead-&
struct node *pnode =
phead = phead-&
free(pnode);
82 // 返回链表中节点的个数
83 static int size()
int count=0;
struct node *pend =
while (pend)
pend = pend-&
97 // 链表是否为空
98 static int is_empty()
return size()==0;
103 void main()
int tmp=0;
// 将10, 20, 30 依次加入到队列中
// 将“队列开头元素”赋值给tmp，并删除“该元素”
tmp = pop();
printf(&tmp=%d\n&, tmp);
// 只将“队列开头的元素”赋值给tmp，不删除该元素.
tmp = front();
printf(&tmp=%d\n&, tmp);
printf(&is_empty()=%d\n&, is_empty());
printf(&size()=%d\n&, size());
while (!is_empty())
printf(&%d\n&, pop());
// 销毁队列
destroy_single_link();
&运行结果& 以及 &主函数main的逻辑&都和&C语言实现一&的一样。
不同的是，该示例中的队列是通过单向链表实现的。
3. C语言实现三：双向链表实现的队列，并且只能存储int数据
双向链表的头文件(
double_link.h)
1 #ifndef _DOUBLE_LINK_H
2 #define _DOUBLE_LINK_H
4 // 新建“双向链表”。成功，返回表头；否则，返回NULL
5 extern int create_dlink();
6 // 撤销“双向链表”。成功，返回0；否则，返回-1
7 extern int destroy_dlink();
9 // “双向链表是否为空”。为空的话返回1；否则，返回0。
10 extern int dlink_is_empty();
11 // 返回“双向链表的大小”
12 extern int dlink_size();
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();
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);
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();
35 // 打印“双向链表”
36 extern void print_dlink();
双向链表的实现文件(
double_link.c)
1 #include &stdio.h&
2 #include &malloc.h&
* C 语言: 双向链表，只能存储int数据。
* @author skywang
11 // 双向链表节点
12 typedef struct tag_node
struct tag_node *
struct tag_node *
19 // 表头。注意，表头不存放元素值！！！
20 static node *phead=NULL;
21 // 节点个数。
22 static int
24 // 新建“节点”。成功，返回节点指针；否则，返回NULL。
25 static node* create_node(int value)
node *pnode=NULL;
pnode = (node *)malloc(sizeof(node));
if (!pnode)
printf(&create node error!\n&);
return NULL;
// 默认的，pnode的前一节点和后一节点都指向它自身
pnode-&prev = pnode-&next =
// 节点的值为value
pnode-&value =
42 // 新建“双向链表”。成功，返回0；否则，返回-1。
43 int create_dlink()
// 创建表头
phead = create_node(-1);
if (!phead)
return -1;
// 设置“节点个数”为0
count = 0;
56 // “双向链表是否为空”
57 int dlink_is_empty()
return count == 0;
62 // 返回“双向链表的大小”
63 int dlink_size() {
67 // 获取“双向链表中第index位置的节点”
68 static node* get_node(int index)
if (index&0 || index&=count)
printf(&%s failed! the index in out of bound!\n&, __func__);
return NULL;
// 正向查找
if (index &= (count/2))
node *pnode=phead-&
while ((i++) & index)
pnode = pnode-&
// 反向查找
int rindex = count - index - 1;
node *rnode=phead-&
while ((j++) & rindex)
rnode = rnode-&
97 // 获取“第一个节点”
98 static node* get_first_node()
return get_node(0);
103 // 获取“最后一个节点”
104 static node* get_last_node()
return get_node(count-1);
109 // 获取“双向链表中第index位置的元素的值”。成功，返回节点值；否则，返回-1。
110 int dlink_get(int index)
node *pindex=get_node(index);
if (!pindex)
printf(&%s failed!\n&, __func__);
return -1;
return pindex-&
123 // 获取“双向链表中第1个元素的值”
124 int dlink_get_first()
return dlink_get(0);
129 // 获取“双向链表中最后1个元素的值”
130 int dlink_get_last()
return dlink_get(count-1);
135 // 将“value”插入到index位置。成功，返回0；否则，返回-1。
136 int dlink_insert(int index, int value)
// 插入表头
if (index==0)
return dlink_insert_first(value);
// 获取要插入的位置对应的节点
node *pindex=get_node(index);
if (!pindex)
return -1;
// 创建“节点”
node *pnode=create_node(value);
if (!pnode)
return -1;
pnode-&prev = pindex-&
pnode-&next =
pindex-&prev-&next =
pindex-&prev =
// 节点个数+1
162 // 将“value”插入到表头位置
163 int dlink_insert_first(int value)
node *pnode=create_node(value);
if (!pnode)
return -1;
pnode-&prev =
pnode-&next = phead-&
phead-&next-&prev =
phead-&next =
177 // 将“value”插入到末尾位置
178 int dlink_append_last(int value)
node *pnode=create_node(value);
if (!pnode)
return -1;
pnode-&next =
pnode-&prev = phead-&
phead-&prev-&next =
phead-&prev =
192 // 删除“双向链表中index位置的节点”。成功，返回0；否则，返回-1。
193 int dlink_delete(int index)
node *pindex=get_node(index);
if (!pindex)
printf(&%s failed! the index in out of bound!\n&, __func__);
return -1;
pindex-&next-&prev = pindex-&
pindex-&prev-&next = pindex-&
free(pindex);
210 // 删除第一个节点
211 int dlink_delete_first()
return dlink_delete(0);
216 // 删除组后一个节点
217 int dlink_delete_last()
return dlink_delete(count-1);
222 // 撤销“双向链表”。成功，返回0；否则，返回-1。
223 int destroy_dlink()
if (!phead)
printf(&%s failed! dlink is null!\n&, __func__);
return -1;
node *pnode=phead-&
node *ptmp=NULL;
while(pnode != phead)
pnode = pnode-&
free(ptmp);
free(phead);
phead = NULL;
count = 0;
247 // 打印“双向链表”
248 void print_dlink()
if (count==0 || (!phead))
printf(&%s dlink is empty!\n&, __func__);
printf(&%s dlink size()=%d\n&, __func__, count);
node *pnode=phead-&
while(pnode != phead)
printf(&%d\n&, pnode-&value);
pnode = pnode-&
双向链表的测试程序(
dlink_queue.c)
1 #include &stdio.h&
2 #include &double_link.h&
* C 语言: 双向链表实现“队列”，只能存储int数据。
* @author skywang
11 // 创建队列
12 int create_dlink_queue()
return create_dlink();
17 // 销毁队列
18 int destroy_dlink_queue()
return destroy_dlink();
23 // 将val添加到队列的末尾
24 int add(int val)
return dlink_append_last(val);
29 // 返回“队列开头元素”
30 int front()
return dlink_get_first();
35 // 返回并删除“队列开头元素”
36 int pop()
int ret = dlink_get_first();
dlink_delete_first();
43 // 返回“队列”的大小
44 int size()
return dlink_size();
49 // 返回“队列”是否为空
50 int is_empty()
return dlink_is_empty();
55 void main()
int tmp=0;
// 创建“队列”
create_dlink_queue();
// 将10, 20, 30 依次队列中
// 将“队列开头的元素”赋值给tmp，并删除“该元素”
tmp = pop();
printf(&tmp=%d\n&, tmp);
// 只将“队列开头的元素”赋值给tmp，不删除该元素.
tmp = front();
printf(&tmp=%d\n&, tmp);
printf(&is_empty()=%d\n&, is_empty());
printf(&size()=%d\n&, size());
while (!is_empty())
printf(&%d\n&, pop());
// 销毁队列
destroy_dlink_queue();
&运行结果& 以及 &主函数main的逻辑&都和前两个示例的一样。
不同的是，该示例中的队列是通过双向链表实现的。
4. C语言实现四：双向链表实现的队列，能存储任意类型的数据
双向链表的头文件(
double_link.h)
1 #ifndef _DOUBLE_LINK_H
2 #define _DOUBLE_LINK_H
4 // 新建“双向链表”。成功，返回表头；否则，返回NULL
5 extern int create_dlink();
6 // 撤销“双向链表”。成功，返回0；否则，返回-1
7 extern int destroy_dlink();
9 // “双向链表是否为空”。为空的话返回1；否则，返回0。
10 extern int dlink_is_empty();
11 // 返回“双向链表的大小”
12 extern int dlink_size();
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();
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);
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();
双向链表的实现文件(
double_link.c)
1 #include &stdio.h&
2 #include &malloc.h&
* C 语言: 双向链表，能存储任意数据。
* @author skywang
11 // 双向链表节点
12 typedef struct tag_node
struct tag_node *
struct tag_node *
19 // 表头。注意，表头不存放元素值！！！
20 static node *phead=NULL;
21 // 节点个数。
22 static int
24 // 新建“节点”。成功，返回节点指针；否则，返回NULL。
25 static node* create_node(void *pval)
node *pnode=NULL;
pnode = (node *)malloc(sizeof(node));
if (!pnode)
printf(&create node error!\n&);
return NULL;
// 默认的，pnode的前一节点和后一节点都指向它自身
pnode-&prev = pnode-&next =
// 节点的值为pval
pnode-&p =
42 // 新建“双向链表”。成功，返回0；否则，返回-1。
43 int create_dlink()
// 创建表头
phead = create_node(NULL);
if (!phead)
return -1;
// 设置“节点个数”为0
count = 0;
56 // “双向链表是否为空”
57 int dlink_is_empty()
return count == 0;
62 // 返回“双向链表的大小”
63 int dlink_size() {
67 // 获取“双向链表中第index位置的节点”
68 static node* get_node(int index)
if (index&0 || index&=count)
printf(&%s failed! index out of bound!\n&, __func__);
return NULL;
// 正向查找
if (index &= (count/2))
node *pnode=phead-&
while ((i++) & index)
pnode = pnode-&
// 反向查找
int rindex = count - index - 1;
node *rnode=phead-&
while ((j++) & rindex)
rnode = rnode-&
97 // 获取“第一个节点”
98 static node* get_first_node()
return get_node(0);
103 // 获取“最后一个节点”
104 static node* get_last_node()
return get_node(count-1);
109 // 获取“双向链表中第index位置的元素”。成功，返回节点值；否则，返回-1。
110 void* dlink_get(int index)
node *pindex=get_node(index);
if (!pindex)
printf(&%s failed!\n&, __func__);
return NULL;
return pindex-&p;
123 // 获取“双向链表中第1个元素的值”
124 void* dlink_get_first()
return dlink_get(0);
129 // 获取“双向链表中最后1个元素的值”
130 void* dlink_get_last()
return dlink_get(count-1);
135 // 将“pval”插入到index位置。成功，返回0；否则，返回-1。
136 int dlink_insert(int index, void* pval)
// 插入表头
if (index==0)
return dlink_insert_first(pval);
// 获取要插入的位置对应的节点
node *pindex=get_node(index);
if (!pindex)
return -1;
// 创建“节点”
node *pnode=create_node(pval);
if (!pnode)
return -1;
pnode-&prev = pindex-&
pnode-&next =
pindex-&prev-&next =
pindex-&prev =
// 节点个数+1
162 // 将“pval”插入到表头位置
163 int dlink_insert_first(void *pval)
node *pnode=create_node(pval);
if (!pnode)
return -1;
pnode-&prev =
pnode-&next = phead-&
phead-&next-&prev =
phead-&next =
177 // 将“pval”插入到末尾位置
178 int dlink_append_last(void *pval)
node *pnode=create_node(pval);
if (!pnode)
return -1;
pnode-&next =
pnode-&prev = phead-&
phead-&prev-&next =
phead-&prev =
192 // 删除“双向链表中index位置的节点”。成功，返回0；否则，返回-1。
193 int dlink_delete(int index)
node *pindex=get_node(index);
if (!pindex)
printf(&%s failed! the index in out of bound!\n&, __func__);
return -1;
pindex-&next-&prev = pindex-&
pindex-&prev-&next = pindex-&
free(pindex);
210 // 删除第一个节点
211 int dlink_delete_first()
return dlink_delete(0);
216 // 删除组后一个节点
217 int dlink_delete_last()
return dlink_delete(count-1);
222 // 撤销“双向链表”。成功，返回0；否则，返回-1。
223 int destroy_dlink()
if (!phead)
printf(&%s failed! dlink is null!\n&, __func__);
return -1;
node *pnode=phead-&
node *ptmp=NULL;
while(pnode != phead)
pnode = pnode-&
free(ptmp);
free(phead);
phead = NULL;
count = 0;
双向链表的测试程序(
dlink_queue.c)
1 #include &stdio.h&
2 #include &double_link.h&
* C 语言: 双向链表实现“队列”，能存储任意数据。
* @author skywang
11 // 创建队列
12 int create_dlink_queue()
return create_dlink();
17 // 销毁队列
18 int destroy_dlink_queue()
return destroy_dlink();
23 // 将p添加到队列的末尾
24 int add(void *p)
return dlink_append_last(p);
29 // 返回“队列开头元素”
30 void* front()
return dlink_get_first();
35 // 返回“队列开头的元素”，并删除“该元素”
36 void* pop()
void *p = dlink_get_first();
dlink_delete_first();
43 // 返回“队列”的大小
44 int size()
return dlink_size();
49 // 返回“队列”是否为空
50 int is_empty()
return dlink_is_empty();
56 typedef struct tag_stu
char name[20];
62 static stu arr_stu[] =
{10, &sky&},
{20, &jody&},
{30, &vic&},
{40, &dan&},
69 #define ARR_STU_SIZE ( (sizeof(arr_stu)) / (sizeof(arr_stu[0])) )
71 static void print_stu(stu *p)
printf(&id=%d, name=%s\n&, p-&id, p-&name);
79 void main()
stu *pval=NULL;
// 创建“队列”
create_dlink_queue();
// 将10, 20, 30 依次推入队列中
for (i=0; i&ARR_STU_SIZE-1; i++)
add(&arr_stu[i]);
// 将“队列开头的元素”赋值给tmp，并删除“该元素”
pval = (stu*)pop();
print_stu(pval) ;
// 只将“队列开头的元素”赋值给tmp，不删除该元素.
pval = front();
print_stu(pval) ;
add(&arr_stu[ARR_STU_SIZE-1]);
printf(&is_empty()=%d\n&, is_empty());
printf(&size()=%d\n&, size());
// 打印队列中的所有元素
while (!is_empty())
pval = pop();
print_stu(pval) ;
// 销毁队列
destroy_dlink_queue();
id=10, name=sky
id=20, name=jody
is_empty()=0
id=20, name=jody
id=30, name=vic
id=40, name=dan
该示例中的队列是通过双向链表实现的，并且能存储任意类型的数据。
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
4 #include &iostream&
5 using namespace
7 template&class T& class ArrayQueue{
ArrayQueue();
~ArrayQueue();
void add(T t);
T front();
int size();
int is_empty();
23 // 创建“队列”，默认大小是12
24 template&class T&
25 ArrayQueue&T&::ArrayQueue()
arr = new T[12];
cout&&&arr malloc error!&&&
34 // 销毁“队列”
35 template&class T&
36 ArrayQueue&T&::~ArrayQueue()
arr = NULL;
45 // 将val添加到队列的末尾
46 template&class T&
47 void ArrayQueue&T&::add(T t)
arr[count++] =
53 // 返回“队列开头元素”
54 template&class T&
55 T ArrayQueue&T&::front()
return arr[0];
60 // 返回并删除“队列末尾的元素”
61 template&class T&
62 T ArrayQueue&T&::pop()
int i = 0;;
T ret = arr[0];
while (i++&count)
arr[i-1] = arr[i];
74 // 返回“队列”的大小
75 template&class T&
76 int ArrayQueue&T&::size()
81 // 返回“队列”是否为空
82 template&class T&
83 int ArrayQueue&T&::is_empty()
return count==0;
队列的测试程序(
1 #include &iostream&
2 #include &ArrayQueue.h&
3 using namespace
* C++ : 数组实现“队列”，能存储任意数据。
* @author skywang
11 int main()
int tmp=0;
ArrayQueue&int& *astack = new ArrayQueue&int&();
// 将10, 20, 30 依次推入队列中
astack-&add(10);
astack-&add(20);
astack-&add(30);
// 将“队列开头元素”赋值给tmp，并删除“该元素”
tmp = astack-&pop();
cout&&&tmp=&&&tmp&&
// 只将“队列开头的元素”赋值给tmp，不删除该元素.
tmp = astack-&front();
cout&&&tmp=&&&tmp&&
astack-&add(40);
cout&&&is_empty()=&&&astack-&is_empty()&&
cout&&&size()=&&&astack-&size()&&
while (!astack-&is_empty())
tmp = astack-&pop();
cout&&tmp&&
is_empty()=0
关于&队列的声明和实现都在头文件中&的原因，是因为队列的实现利用了C++模板，而&C++编译器不能支持对模板的分离式编译&。
2. C++实现二：C++的 STL 中自带的&队列&(list)的示例
StlQueue.cpp)
1 #include &iostream&
2 #include &queue&
3 using namespace
* C++ : STL中的队列(queue)的演示程序。
* @author skywang
11 int main ()
int tmp=0;
queue&int&
// 将10, 20, 30 依次加入队列的末尾
iqueue.push(10);
iqueue.push(20);
iqueue.push(30);
// 删除队列开头的元素
iqueue.pop();
// 将“队列开头的元素”赋值给tmp，不删除该元素.
tmp = iqueue.front();
cout&&&tmp=&&&tmp&&
// 将40加入到队列的末尾
iqueue.push(40);
cout && &empty()=& && iqueue.empty() &&
cout && &size()=& && iqueue.size() &&
while (!iqueue.empty())
tmp = iqueue.front();
cout&&tmp&&
iqueue.pop();
和C++一样，JDK包Queue中的也提供了&队列&的实现。JDK中的Queue接口就是&队列&，它的实现类也都是队列，用的最多的是LinkedList。
本部分介绍给出2种Java实现
1. Java实现一：数组实现的队列，能存储任意类型的数据。
2. Java实现二：Java的 Collection集合 中自带的&队列&(LinkedList)的示例。
1. Java实现一：数组实现的队列，能存储任意类型的数据
ArrayQueue.java)
* Java : 数组实现“队列”，只能存储int数据。
* @author skywang
7 public class ArrayQueue {
private int[] mA
private int mC
public ArrayQueue(int sz) {
mArray = new int[sz];
mCount = 0;
// 将val添加到队列的末尾
public void add(int val) {
mArray[mCount++] =
// 返回“队列开头元素”
public int front() {
return mArray[0];
// 返回“栈顶元素值”，并删除“栈顶元素”
public int pop() {
int ret = mArray[0];
for (int i=1; i&=mC i++)
mArray[i-1] = mArray[i];
// 返回“栈”的大小
public int size() {
// 返回“栈”是否为空
public boolean isEmpty() {
return size()==0;
public static void main(String[] args) {
int tmp=0;
ArrayQueue astack = new ArrayQueue(12);
// 将10, 20, 30 依次推入栈中
astack.add(10);
astack.add(20);
astack.add(30);
// 将“栈顶元素”赋值给tmp，并删除“栈顶元素”
tmp = astack.pop();
System.out.printf(&tmp=%d\n&, tmp);
// 只将“栈顶”赋值给tmp，不删除该元素.
tmp = astack.front();
System.out.printf(&tmp=%d\n&, tmp);
astack.add(40);
System.out.printf(&isEmpty()=%b\n&, astack.isEmpty());
System.out.printf(&size()=%d\n&, astack.size());
while (!astack.isEmpty()) {
System.out.printf(&size()=%d\n&, astack.pop());
isEmpty()=false
：ArrayQueue是通过数组实现的队列，而且ArrayQueue中使用到了泛型，因此它支持任意类型的数据。
2. Java实现二：Java的 Collection集合 中自带的&队列&(LinkedList)的示例
QueueTest.java)
1 import java.util.S
* 用“栈”实现队列
* @author skywang
8 public class StackList&T& {
// 向队列添加数据时：(01) 将“已有的全部数据”都移到mIn中。 (02) 将“新添加的数据”添加到mIn中。
private Stack&T& mIn
// 从队列获取元素时：(01) 将“已有的全部数据”都移到mOut中。(02) 返回并删除mOut栈顶元素。
private Stack&T& mOut = null;
// 统计计数
private int mCount = 0;
public StackList() {
mIn = new Stack&T&();
mOut = new Stack&T&();
mCount = 0;
private void add(T t) {
// 将“已有的全部数据”都移到mIn中
while (!mOut.empty())
mIn.push(mOut.pop());
// 将“新添加的数据”添加到mIn中
mIn.push(t);
// 统计数+1
private T get() {
// 将“已有的全部数据”都移到mOut中
while (!mIn.empty())
mOut.push(mIn.pop());
// 统计数-1
// 返回并删除mOut栈顶元素
return mOut.pop();
private int size() {
private boolean isEmpty() {
return mCount==0;
public static void main(String[] args) {
StackList slist = new StackList();
// 将10, 20, 30 依次推入栈中
slist.add(10);
slist.add(20);
slist.add(30);
System.out.printf(&isEmpty()=%b\n&, slist.isEmpty());
System.out.printf(&size()=%d\n&, slist.size());
while(!slist.isEmpty()) {
System.out.printf(&%d\n&, slist.get());
isEmpty()=false
已发表评论数()
已收藏到推刊！
请填写推刊名
描述不能大于100个字符!
权限设置： 公开
仅自己可见
正文不准确
标题不准确
排版有问题
没有分页内容
图片无法显示
视频无法显示
与原文不一致