devbox
小舞很执着
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

链式队列的基本操作（详细）_链队列的基本操作

作者：小舞很执着 | 2024-07-26 10:43:24

赞

踩

链队列的基本操作

 

目录

1.实现功能

2.建队列

3.进队列

4.打印队列信息

5.队列的判空

6.求队列的长度

7.求队尾元素

8.删除队列元素同时返回队尾元素的值

9.求队头元素

10.输入队列元素

11.摧毁一个队列

12.请空队列

13.switch case选择

14.全部代码内容

15.运行图片

本帖可以实现的功能

1.实现功能

  1. void pro()
  2. {
  3.     printf("0.退出\n");
  4.     printf("1.建立一个新队列\n");
  5.     printf("2.按照输出方式打印队列信息\n");
  6.     printf("3.求队列长度\n");
  7.     printf("4.获取对头元素\n");
  8.     printf("5.获取队尾元素\n");
  9.     printf("6.删除对头元素\n");
  10.     printf("7.判断队列是否为空\n");
  11.     printf("8.在队尾插入一个数\n");
  12.     printf("9.清空一个队列\n");
  13.     printf("10.摧毁一个队列\n");
  14. }

2.建队列

  1. void InitQueue(LinkQueue &Q)
  2. {
  3.     //建立链队列
  4.     Q.front = Q.rear = (QueuePtr)malloc(sizeof(QNode));
  5.     Q.front = Q.rear;
  6.     if (!Q.front)
  7.         printf("开辟空间失败\n");
  8.     Q.front->next = NULL;
  9.     printf("链式队列存储空间开辟完成\n");
  10.     // Q.front->next=Q.rear->next;
  11. }

3.进队列

  1. Status EnQueue(LinkQueue &Q, int e)
  2. {
  3.     //在队列的尾部插入元素
  4.     QueuePtr p = (QueuePtr)malloc(sizeof(QNode));
  5.     p->data = e;
  6.     p->next = NULL;
  7.     Q.rear->next = p;
  8.     Q.rear = p;
  9. }

4.打印队列信息

  1. void print(LinkQueue Q)
  2. {
  3.     //打印对列信息，按照输出方向
  4.     QueuePtr p;
  5.     p = Q.front->next;
  6.     while (p != NULL)
  7.     {
  8.         printf("%d ", p->data);
  9.         p = p->next;
  10.     }
  11.     printf("\n");
  12. }

5.队列的判空

  1. void QueueEmpty(LinkQueue Q)
  2. {
  3.     //判断是否为空队列
  4.     if (Q.front == Q.rear)
  5.     {
  6.         printf("空\n");
  7.     }
  8.     else
  9.     {
  10.         printf("不空\n");
  11.     }
  12. }

6.求队列的长度

  1. void QueueLength(LinkQueue Q)
  2. {
  3.     //求队列的长度
  4.     int length = 0;
  5.     QueuePtr p, q;
  6.     p = Q.front->next;
  7.     while (p != NULL)
  8.     {
  9.         p = p->next;
  10.         length++;
  11.     }
  12.     printf("长度为%d\n", length);
  13. }

7.求队尾元素

  1. void QueueRear(LinkQueue Q)
  2. {
  3.     //求队尾
  4.     printf("队尾元素是：%d\n", Q.rear->data);
  5. }

8.删除队列元素同时返回队尾元素的值

  1. Status DeQueue(LinkQueue &Q)
  2. {
  3.     int e;
  4.     if (Q.front == Q.rear)
  5.     {
  6.         printf("这个队列为空\n");
  7.     }
  8.     QueuePtr p = Q.front->next;
  9.     e = p->data;
  10.     Q.front->next = p->next;
  11.     if (Q.rear == p)
  12.     {
  13.         Q.rear = Q.front;
  14.     }
  15.     free(p);
  16.     return e;
  17. }

9.求队头元素

  1. void QueueFront(LinkQueue Q)
  2. {
  3.     //求对头
  4.     printf("对头元素为:%d\n", Q.front->next->data);
  5. }

10.输入队列元素

  1. Status CreatQueue(LinkQueue &Q)
  2. {
  3.     //输入队列元素
  4.     printf("请输入队列里面的元素\n");
  5.     int e;
  6.     scanf("%d", &e);
  7.     while (e != -1)
  8.     {
  9.         EnQueue(Q, e);
  10.         scanf("%d", &e);
  11.     }
  12. }

11.摧毁一个队列

  1. Status DestoryQueue(LinkQueue &Q)
  2. {
  3.     QueuePtr p;
  4.     while(!p)
  5.     {
  6.         p=Q.front;
  7.         Q.front=Q.front->next;
  8.         free(p);
  9.     }
  10.     printf("摧毁队列完成\n");
  11. }

12.请空队列

  1. Status ClearQueue(LinkQueue &Q)
  2. {
  3.     Q.rear=Q.front->next=NULL;
  4.     printf("清空操作已经完成\n");
  5. }

13.switch case选择

  1. void swi(LinkQueue Q)
  2. {
  3.     int num;
  4.     pro();
  5.     printf("请输入功能数字:");
  6.     scanf("%d", &num);
  7.     while (num)
  8.     {
  9.         switch (num)
  10.         {
  11.         case 0:
  12.             num = 0;
  13.             break;
  14.         case 1:
  15.             printf("建立一个新队列\n");
  16.             InitQueue(Q);
  17.             printf("\n\n");
  18.             CreatQueue(Q);
  19.             printf("建立成功\n");
  20.             break;
  21.         case 2:
  22.             if (Q.rear == NULL)
  23.             {
  24.                 printf("在进行操作二时，需要进行操作一\n");
  25.             }
  26.             else
  27.             {
  28.                 printf("队列信息如下：\n");
  29.                 print(Q);
  30.             }
  31.             break;
  32.         case 3:
  33.             if (Q.rear == NULL)
  34.             {
  35.                 printf("在进行操作三时，需要进行操作一\n");
  36.             }
  37.             else
  38.             {
  39.                 printf("队列");
  40.                 QueueLength(Q);
  41.             }
  42.             break;
  43.         case 4:
  44.             if (Q.rear == NULL)
  45.             {
  46.                 printf("在进行操作四时，需要进行操作一\n");
  47.             }
  48.             else
  49.             {
  50.                 printf("获取对头元素\n");
  51.                 QueueFront(Q);
  52.             }
  53.             break;
  54.         case 5:
  55.             if (Q.rear == NULL)
  56.             {
  57.                 printf("在进行操作五时，需要进行操作一\n");
  58.             }
  59.             else
  60.             {
  61.                 printf("获取队尾元素\n");
  62.                 QueueRear(Q);
  63.             }
  64.             break;
  65.         case 6:
  66.             if (Q.rear == NULL)
  67.             {
  68.                 printf("在进行操作六时，需要进行操作一\n");
  69.             }
  70.             else
  71.             {
  72.                 printf("删除对头元素，");
  73.                 int e;
  74.                 e = DeQueue(Q);
  75.                 printf("删除的对头元素是：%d\n", e);
  76.             }
  77.             break;
  78.         case 7:
  79.             if (Q.rear == NULL)
  80.             {
  81.                 printf("在进行操作七时，需要进行操作一\n");
  82.             }
  83.             else
  84.             {
  85.                 printf("判断队列是否为空\n");
  86.                 QueueEmpty(Q);
  87.             }
  88.             break;
  89.         case 8:
  90.             if (Q.rear == NULL)
  91.             {
  92.                 printf("在进行操作八时，需要进行操作一\n");
  93.             }
  94.             else
  95.             {
  96.                 printf("在队尾插入一个数\n");
  97.                 int n;
  98.                 printf("请输入一个数字:");
  99.                 scanf("%d", &n);
  100.                 printf("\n");
  101.                 EnQueue(Q, n);
  102.                 printf("插入成功\n");
  103.             }
  104.             break;
  105.         case 9:
  106.             if (Q.rear == NULL)
  107.             {
  108.                 printf("在进行操作九时，需要进行操作一\n");
  109.             }
  110.             else
  111.             {
  112.                 ClearQueue(Q);
  113.             }
  114.         break;
  115.         case 10:
  116.             if (Q.rear == NULL)
  117.             {
  118.                 printf("在进行操作十时，需要进行操作一\n");
  119.             }
  120.             else
  121.             {
  122.                 DestoryQueue(Q);
  123.                 Q.rear=NULL;
  124.             }
  125.             break;
  126.         default:
  127.             printf("输入错误，请重新输入\n");
  128.         }
  129.         printf("\n\n");
  130.         pro();
  131.         printf("请输入功能数字:");
  132.         scanf("%d", &num);
  133.     }
  134. }

14.全部代码内容

  1. // define区
  2. #define Stack_Init_Size 100
  3. #define Stack_Increment 10
  4. #define OK 1
  5. #define OVERFLOW -2
  6. #define ERROR 0
  7.  
  8. //预处理
  9. #include <stdio.h>
  10. #include <stdlib.h>
  11.  
  12. //typedef
  13. typedef int Status;
  14. typedef struct QNode
  15. {
  16.     int data;
  17.     struct QNode *next;
  18. } QNode, *QueuePtr;
  19. typedef struct
  20. {
  21.     QueuePtr front;
  22.     QueuePtr rear;
  23. } LinkQueue;
  24.  
  25. //函数区声明
  26. void InitQueue(LinkQueue &Q);               //建立链队列
  27. Status EnQueue(LinkQueue &Q, int e);        //在队列的尾部插入元素
  28. void print(LinkQueue Q);                    //打印对列信息，按照输出方向
  29. void QueueEmpty(LinkQueue Q);                //判断是否为空队列
  30. void QueueLength(LinkQueue Q);              //求队列的长度
  31. void QueueRear(LinkQueue Q);                //求队尾
  32. Status DeQueue(LinkQueue &Q);               //求对头
  33. void QueueFront(LinkQueue Q);               //输入队列元素
  34. Status CreatQueue(LinkQueue &Q);            //创建队列
  35. Status DestoryQueue(LinkQueue &Q);          //摧毁队列
  36. Status ClearQueue(LinkQueue &Q);            //请空队列
  37. void pro();                                 //功能  
  38. void swi(LinkQueue Q);                      //switch
  39.  
  40. //主函数
  41. int main()
  42. {
  43.     LinkQueue Q;
  44.     Q.rear = NULL;
  45.     swi(Q);
  46. }
  47.  
  48.  
  49. void InitQueue(LinkQueue &Q)
  50. {
  51.     //建立链队列
  52.     Q.front = Q.rear = (QueuePtr)malloc(sizeof(QNode));
  53.     Q.front = Q.rear;
  54.     if (!Q.front)
  55.         printf("开辟空间失败\n");
  56.     Q.front->next = NULL;
  57.     printf("链式队列存储空间开辟完成\n");
  58.     // Q.front->next=Q.rear->next;
  59. }
  60.  
  61. Status EnQueue(LinkQueue &Q, int e)
  62. {
  63.     //在队列的尾部插入元素
  64.     QueuePtr p = (QueuePtr)malloc(sizeof(QNode));
  65.     p->data = e;
  66.     p->next = NULL;
  67.     Q.rear->next = p;
  68.     Q.rear = p;
  69. }
  70.  
  71. void print(LinkQueue Q)
  72. {
  73.     //打印对列信息，按照输出方向
  74.     QueuePtr p;
  75.     p = Q.front->next;
  76.     while (p != NULL)
  77.     {
  78.         printf("%d ", p->data);
  79.         p = p->next;
  80.     }
  81.     printf("\n");
  82. }
  83.  
  84. void QueueEmpty(LinkQueue Q)
  85. {
  86.     //判断是否为空队列
  87.     if (Q.front == Q.rear)
  88.     {
  89.         printf("空\n");
  90.     }
  91.     else
  92.     {
  93.         printf("不空\n");
  94.     }
  95. }
  96.  
  97. void QueueLength(LinkQueue Q)
  98. {
  99.     //求队列的长度
  100.     int length = 0;
  101.     QueuePtr p, q;
  102.     p = Q.front->next;
  103.     while (p != NULL)
  104.     {
  105.         p = p->next;
  106.         length++;
  107.     }
  108.     printf("长度为%d\n", length);
  109. }
  110.  
  111. void QueueRear(LinkQueue Q)
  112. {
  113.     //求队尾
  114.     printf("队尾元素是：%d\n", Q.rear->data);
  115. }
  116.  
  117. Status DeQueue(LinkQueue &Q)
  118. {
  119.     int e;
  120.     if (Q.front == Q.rear)
  121.     {
  122.         printf("这个队列为空\n");
  123.     }
  124.     QueuePtr p = Q.front->next;
  125.     e = p->data;
  126.     Q.front->next = p->next;
  127.     if (Q.rear == p)
  128.     {
  129.         Q.rear = Q.front;
  130.     }
  131.     free(p);
  132.     return e;
  133. }
  134.  
  135. void QueueFront(LinkQueue Q)
  136. {
  137.     //求对头
  138.     printf("对头元素为:%d\n", Q.front->next->data);
  139. }
  140. /*
  141. int DeQueue(LinkQueue &Q)
  143. {
  144.     //删除对列的对头元素
  145.     QNode *p;
  146.     p = Q.front->next;
  147.     int e = p->data;
  148.     Q.front->next = p->next;
  149.     free(p);
  150.     return e;
  151. }*/
  152.  
  153. Status CreatQueue(LinkQueue &Q)
  154. {
  155.     //输入队列元素
  156.     printf("请输入队列里面的元素\n");
  157.     int e;
  158.     scanf("%d", &e);
  159.     while (e != -1)
  160.     {
  161.         EnQueue(Q, e);
  162.         scanf("%d", &e);
  163.     }
  164. }
  165.  
  166. Status DestoryQueue(LinkQueue &Q)
  167. {
  168.     QueuePtr p;
  169.     while(!p)
  170.     {
  171.         p=Q.front;
  172.         Q.front=Q.front->next;
  173.         free(p);
  174.     }
  175.     printf("摧毁队列完成\n");
  176. }
  177.  
  178. Status ClearQueue(LinkQueue &Q)
  179. {
  180.     Q.rear=Q.front->next=NULL;
  181.     printf("清空操作已经完成\n");
  182. }
  183.  
  184. void pro()
  185. {
  186.     printf("0.退出\n");
  187.     printf("1.建立一个新队列\n");
  188.     printf("2.按照输出方式打印队列信息\n");
  189.     printf("3.求队列长度\n");
  190.     printf("4.获取对头元素\n");
  191.     printf("5.获取队尾元素\n");
  192.     printf("6.删除对头元素\n");
  193.     printf("7.判断队列是否为空\n");
  194.     printf("8.在队尾插入一个数\n");
  195.     printf("9.清空一个队列\n");
  196.     printf("10.摧毁一个队列\n");
  197. }
  198.  
  199. void swi(LinkQueue Q)
  200. {
  201.     int num;
  202.     pro();
  203.     printf("请输入功能数字:");
  204.     scanf("%d", &num);
  205.     while (num)
  206.     {
  207.         switch (num)
  208.         {
  209.         case 0:
  210.             num = 0;
  211.             break;
  212.         case 1:
  213.             printf("建立一个新队列\n");
  214.             InitQueue(Q);
  215.             printf("\n\n");
  216.             CreatQueue(Q);
  217.             printf("建立成功\n");
  218.             break;
  219.         case 2:
  220.             if (Q.rear == NULL)
  221.             {
  222.                 printf("在进行操作二时，需要进行操作一\n");
  223.             }
  224.             else
  225.             {
  226.                 printf("队列信息如下：\n");
  227.                 print(Q);
  228.             }
  229.             break;
  230.         case 3:
  231.             if (Q.rear == NULL)
  232.             {
  233.                 printf("在进行操作三时，需要进行操作一\n");
  234.             }
  235.             else
  236.             {
  237.                 printf("队列");
  238.                 QueueLength(Q);
  239.             }
  240.             break;
  241.         case 4:
  242.             if (Q.rear == NULL)
  243.             {
  244.                 printf("在进行操作四时，需要进行操作一\n");
  245.             }
  246.             else
  247.             {
  248.                 printf("获取对头元素\n");
  249.                 QueueFront(Q);
  250.             }
  251.             break;
  252.         case 5:
  253.             if (Q.rear == NULL)
  254.             {
  255.                 printf("在进行操作五时，需要进行操作一\n");
  256.             }
  257.             else
  258.             {
  259.                 printf("获取队尾元素\n");
  260.                 QueueRear(Q);
  261.             }
  262.             break;
  263.         case 6:
  264.             if (Q.rear == NULL)
  265.             {
  266.                 printf("在进行操作六时，需要进行操作一\n");
  267.             }
  268.             else
  269.             {
  270.                 printf("删除对头元素，");
  271.                 int e;
  272.                 e = DeQueue(Q);
  273.                 printf("删除的对头元素是：%d\n", e);
  274.             }
  275.             break;
  276.         case 7:
  277.             if (Q.rear == NULL)
  278.             {
  279.                 printf("在进行操作七时，需要进行操作一\n");
  280.             }
  281.             else
  282.             {
  283.                 printf("判断队列是否为空\n");
  284.                 QueueEmpty(Q);
  285.             }
  286.             break;
  287.         case 8:
  288.             if (Q.rear == NULL)
  289.             {
  290.                 printf("在进行操作八时，需要进行操作一\n");
  291.             }
  292.             else
  293.             {
  294.                 printf("在队尾插入一个数\n");
  295.                 int n;
  296.                 printf("请输入一个数字:");
  297.                 scanf("%d", &n);
  298.                 printf("\n");
  299.                 EnQueue(Q, n);
  300.                 printf("插入成功\n");
  301.             }
  302.             break;
  303.         case 9:
  304.             if (Q.rear == NULL)
  305.             {
  306.                 printf("在进行操作九时，需要进行操作一\n");
  307.             }
  308.             else
  309.             {
  310.                 ClearQueue(Q);
  311.             }
  312.         break;
  313.         case 10:
  314.             if (Q.rear == NULL)
  315.             {
  316.                 printf("在进行操作十时，需要进行操作一\n");
  317.             }
  318.             else
  319.             {
  320.                 DestoryQueue(Q);
  321.                 Q.rear=NULL;
  322.             }
  323.             break;
  324.         default:
  325.             printf("输入错误，请重新输入\n");
  326.         }
  327.         printf("\n\n");
  328.         pro();
  329.         printf("请输入功能数字:");
  330.         scanf("%d", &num);
  331.     }
  332. }

15.运行图片

在没有建立队列时：

建立队列

打印队列

求长度

获取对头元素

获取队尾元素

删除对头元素

队尾插入一个数字

 验证

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小舞很执着/article/detail/884852
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号