链队列

链队列就是简化了的单链表

nodequeue.h

  1. #ifndef __NODEQUEUE__
  2. #define __NODEQUEUE__
  3. #include <stdio.h>
  4. #include <malloc.h>
  5. #include <assert.h>
  6. #include <memory.h>
  7. #include <stdbool.h>
  8. #define ElemType int
  9. typedef struct Node{
  10. ElemType data;
  11. struct Node* next;
  12. }Node;
  13. typedef struct NodeQueue{
  14. Node* front;
  15. Node* tail;
  16. size_t size;
  17. }NodeQueue;
  18. void init(NodeQueue*);
  19. void enQueue(NodeQueue*, ElemType);
  20. void deQueue(NodeQueue*);
  21. void show_list(NodeQueue*);
  22. int length(NodeQueue*);
  23. void clear(NodeQueue*);
  24. void destroy(NodeQueue*);
  25. #endif

nodequeue.c

  1. #include "nodequeue.h"
  2. void init(NodeQueue* queue){
  3. queue->front = queue->tail = (Node*)malloc(sizeof(Node));
  4. queue->tail->next = NULL;
  5. queue->size = 0;
  6. }
  7. //入队(尾插)
  8. void enQueue(NodeQueue* queue, ElemType val){
  9. Node* p = (Node*)malloc(sizeof(Node));
  10. p->data = val;
  11. if(queue->front->next == NULL){
  12. queue->front->next = p;
  13. }
  14. else{
  15. queue->tail->next = p;
  16. }
  17. queue->tail = p;
  18. p->next = NULL;
  19. queue->size++;
  20. }
  21. //出队(头删)
  22. void deQueue(NodeQueue* queue){
  23. if(queue->size == 0)return;
  24. Node* tmp = queue->front->next;
  25. queue->front->next = queue->front->next->next;
  26. free(tmp);
  27. queue->size--;
  28. }
  29. int length(NodeQueue* queue){
  30. return queue->size;
  31. }
  32. void show_list(NodeQueue* queue){
  33. Node* p = queue->front;
  34. while(p->next != NULL){
  35. printf("%d\n", p->next->data);
  36. p = p->next;
  37. }
  38. }
  39. void clear(NodeQueue* queue){
  40. if(queue->size == 0)return;
  41. Node* p = queue->front;
  42. Node* tmp;
  43. while(p->next != NULL){
  44. tmp = p->next;
  45. p = p->next;
  46. free(tmp);
  47. }
  48. queue->tail = queue->front;
  49. queue->tail->next = NULL;
  50. queue->size = 0;
  51. }
  52. void destroy(NodeQueue* queue){
  53. clear(queue);
  54. free(queue->front);
  55. }

nodequeuemain.c

  1. include "nodequeue.h"
  2. int main(){
  3. NodeQueue list;
  4. init(&list);
  5. int select = 1;
  6. ElemType item;
  7. int index;
  8. while(select){
  9. printf("*****************************************\n");
  10. printf("*** [1] push [2] pop ***\n");
  11. printf("*** [3] show_list [4] length ***\n");
  12. printf("*** [5] clear [6] destroy ***\n");
  13. printf("*** [0] quit ***\n");
  14. printf("*****************************************\n");
  15. printf("请选择:>");
  16. scanf("%d", &select);
  17. if(0 == select)
  18. break;
  19. switch(select){
  20. case 1:
  21. printf("请输入要插入的数据>\n");
  22. scanf("%d",&item);
  23. enQueue(&list, item);
  24. show_list(&list);
  25. break;
  26. case 2:
  27. deQueue(&list);
  28. show_list(&list);
  29. break;
  30. case 3:
  31. show_list(&list);
  32. break;
  33. case 4:
  34. printf("length is %d\n", length(&list));
  35. break;
  36. case 5:
  37. clear(&list);
  38. show_list(&list);
  39. break;
  40. case 6:
  41. destroy(&list);
  42. break;
  43. default:
  44. printf("输入的选择错误,请重新选择\n");
  45. break;
  46. }
  47. }
  48. destroy(&list);
  49. }

c/c++链队列的更多相关文章

  1. javascript实现数据结构与算法系列:队列 -- 链队列和循环队列实现及示例

    1 队列的基本概念 队列(Queue):也是运算受限的线性表.是一种先进先出(First In First Out ,简称FIFO)的线性表.只允许在表的一端进行插入,而在另一端进行删除. 队首(fr ...

  2. java与数据结构(8)---java实现链队列

    链队列 实际上就是单链表,只是规定了删除在队头进行,添加在队尾进行. 链队列代码结构 package list.queue; public interface Queuable<T>; p ...

  3. 链队列之C++实现

    链队列时建立在单链表的基础之上的.由于是动态分配节点内存,所以无需判满. 链队列的形式如下: 1.队列空 2.队列存在数据 下面介绍下C++实现的链队列,VC6下调试通过. 1.文件组织 2.lq.h ...

  4. C语言实现链队列的初始化&进队&出队

    /*链表实现队列的一系列操作*/ #include<stdio.h> #include<stdlib.h> #define OK 1 #define ERROR 0 typed ...

  5. 【Java】 大话数据结构(7) 循环队列和链队列

    本文根据<大话数据结构>一书,实现了Java版的循环队列.链队列. 队列:只允许在一端进行插入操作,而在另一端进行删除操作的线性表. 1.循环队列 队列的顺序储存结构:用数组存储队列,引入 ...

  6. 队列的理解和实现(二) ----- 链队列(java实现)

    什么是链队列 链队是指采用链式存储结构实现的队列,通常链队用单链表俩表示.一个链队显然需要两个分别指示队头和队尾的指针,也称为头指针和尾指针,有了这两个指针才能唯一的确定. package 链队列; ...

  7. C语言——循环队列和链队列的基本运算

    // 循环队列#include <stdio.h> #include "SeqQue.h" // 循环队列的基本运算 /* const int maxsize = 20 ...

  8. C语言链队列

    链队列类似于单链表,为了限制只能从两端操作数据,其结构体内有2个指针分别指向头尾,但队列里的节点用另一种结构体来表示,头尾指针则为指向该结构体的类型.只能通过操作头尾指针来操作队列. typedef ...

  9. java实现链队列

    java实现链队列的类代码: package linkqueue; public class LinkQueue { class Element { Object elem; Element next ...

随机推荐

  1. 【原创】USART异步模式配置

        特性: (1)USART只能一位一位地发送和接受数据,在起始位期间,TX端处于低电平:当闲置时,TX端为高. (2)发送和接受由一共用的波特率发生器驱动,当发送器和接收器的使能位分别置位时,分 ...

  2. 如何一步步在生产环境上部署django和vue

    本文由云+社区发表 本文主要讲述了如何一步步在生产环境上部署django和vue,操作系统默认为centos 说明:后文中出现的以下字符串均表示具体的路径或者名称,含义如下: DJANGO_DIR-- ...

  3. 创业公司都在使用的3款Python库

    Instavest上发表了一篇博文,文章分享了深受创业公司喜爱的3款Python库,该文章在Hacker News上引发了开发者的激烈探讨,如果你也对此感兴趣,不妨移步去看下.笔者将该文简译过来以分享 ...

  4. MySQL抓包工具:MySQL Sniffer【转】

    本文来自:https://github.com/Qihoo360/mysql-sniffer 简介 MySQL Sniffer 是一个基于 MySQL 协议的抓包工具,实时抓取 MySQLServer ...

  5. 分享一个爬取HUST(哈理工)学生成绩的Python程序(OCR自动识别验证码)

    Python版本:3.5.2 日期:2018/1/21 __Author__ = "Lance#" # -*- coding = utf-8 -*- from urllib imp ...

  6. Django 系列博客(六)

    Django 系列博客(六) 前言 本篇博客介绍 Django 中的路由控制部分,一个网络请求首先到达的就是路由这部分,经过路由与视图层的映射关系再执行相应的代码逻辑并将结果返回给客户端. Djang ...

  7. Docker在Linux上运行NetCore系列(一)配置运行DotNetCore控制台

    转发请注明此文章作者与路径,请尊重原著,违者必究. 系列文章:https://www.cnblogs.com/alunchen/p/10121379.html 本篇文章操作系统信息 Linux:ubu ...

  8. [转]玩转Angular2(4)--制作左侧自动定位菜单

    本文转自:https://godbasin.github.io/2017/06/02/angular2-free-4-create-sidebar/ 因为项目原因又玩上了Angular2(v4.0+) ...

  9. [Linux] 简单安装和使用composer

    wget https://getcomposer.org/installer //下载一个脚本文件 php installer //php执行下这个php脚本 mv composer.phar /us ...

  10. CSS概念【记录】

    1.CSS语法 2.@规则 3.注释 4.层叠 5.优先级 6.继承 7.值 8.块格式化上下文 9.盒模型 10.层叠上下文 11.可替换元素 12.外边距合并 13.包含块 14.视觉格式化模型 ...