• 顺序队列与链式队列--C语言实现


    关于队列,因为我自己在平时使用不多,所以在这里直接将队列的两种存储方式放在一起,作为一篇随笔,这两份代码均可直接运行,亲测。注释写的应该也算比较详细了,就不过多的解释了

    顺序队列

     1 #include<stdio.h>
     2 #define MAXSIZE 100                            //队列最大空间
     3 typedef int QElemType;                        //队列中元素类型
     4 typedef int Status;                            //返回值类型
     5 #define OK 1                                //操作成功
     6 #define ERROR 0                                //操作失败
     7 
     8 typedef struct                                //队列结点结构
     9 {
    10     QElemType date[MAXSIZE];                //结点元素
    11     int front;                                //队头
    12     int rear;                                //队尾
    13 }SqQueue;
    14 
    15 /*队列的初始化*/
    16 Status InitQue(SqQueue *Q)                    
    17 {                                            //因为这是一个int型队列,,所以
    18     Q->front = 0;                            //队头指向0
    19     Q->rear = 0;                            //队尾指向0
    20     return OK;
    21 }
    22 
    23 /*队列的入队操作*/
    24 Status EnQueue(SqQueue *Q, QElemType e)
    25 {
    26     if((Q->rear + 1) % MAXSIZE == Q->front)                //判断队列是否已满
    27         return ERROR;
    28     Q->date[Q->rear] = e;                                //队尾赋值为e
    29     Q->rear = (Q->rear + 1) % MAXSIZE;                    //队尾后移
    30     return OK;
    31 }
    32 
    33 /*队列的出队操作*/
    34 Status DeQueue(SqQueue *Q, QElemType *e)
    35 {
    36     if(Q->front == Q->rear)                                //判断队列是否为空
    37         return ERROR;
    38     *e = Q->date[Q->front];                                //将队头元素取出
    39     Q->front = (Q->front + 1) % MAXSIZE;                //队头后移
    40     return OK;
    41 }
    42 
    43 /*获取队列的长度*/
    44 int LengthQue(SqQueue Q)
    45 {
    46     return (Q.rear - Q.front + MAXSIZE) % MAXSIZE;
    47 }
    48 
    49 void main()
    50 {
    51     SqQueue Q;            //创建队Q
    52     int e;                //入队与出队的元素
    53 
    54     while(true)
    55     {
    56         printf("请选择对顺序栈的操作:
    ");
    57         printf("1.初始化
    ");
    58         printf("2.入队
    ");
    59         printf("3.出队
    ");
    60         printf("4.队列长度
    ");
    61         printf("5.退出
    ");
    62         int a;
    63         scanf("%d", &a);
    64         switch(a)
    65         {
    66             case 1:
    67                 if(InitQue(&Q))
    68                     printf("初始化成功
    ");
    69                 else
    70                     printf("初始化失败
    ");
    71                 break;
    72             case 2:
    73                 printf("请输入入队的元素:");
    74                 scanf("%d", &e);
    75                 if(EnQueue(&Q, e))
    76                     printf("入队成功
    ");
    77                 else
    78                     printf("入队失败
    ");
    79                 break;
    80             case 3:
    81                 if(DeQueue(&Q, &e))
    82                     printf("出队的元素为:%d
    ",e);
    83                 else
    84                     printf("队空
    ");
    85                 break;
    86             case 4:
    87                 printf("当前队列长度为:%d
    ",LengthQue(Q));
    88                 break;
    89             case 5:
    90                 return;
    91             default:
    92                 printf("选择错误
    ");
    93                 break;
    94         }
    95     }
    96 }

    链式队列

      1 #include<stdio.h>
      2 #include<malloc.h>
      3 typedef int QElemType;                    //队列的结点元素类型
      4 typedef int Status;                        //函数返回值类型
      5 #define OK 1                            //操作成功返回值
      6 #define ERROR 0                            //操作失败返回值
      7 
      8 typedef struct QNode                    //结点结构体
      9 {
     10     QElemType date;                        //结点数据
     11     struct QNode *next;                    //结点指针
     12 }QNode, *LinkQuePtr;                            //结点名
     13 
     14 typedef struct                            //链队结构体
     15 {
     16     LinkQuePtr front;                    //队头结点
     17     LinkQuePtr rear;                    //队尾结点
     18 }LinkQue;                                //队名
     19 
     20 LinkQuePtr head = (LinkQuePtr)malloc(sizeof(QNode));                        //头结点
     21 
     22 /*链队的初始化*/
     23 Status InitQue(LinkQue *Q)
     24 {
     25     Q->front = head;                    //使头结点指向空
     26     Q->rear = head;                        //使尾结点指向空
     27     return OK;
     28 }
     29 
     30 /*链队的入队操作*/
     31 Status EnQueue(LinkQue *Q, QElemType e)
     32 {
     33     LinkQuePtr s = (LinkQuePtr)malloc(sizeof(QNode));            //申请新结点空间
     34     if(!s)
     35         return ERROR;
     36     s->date = e;                        //新结点的数据等于e
     37     s->next = NULL;                        //新结点的指针指向空
     38     Q->rear->next = s;                    //原队尾结点的指针指向新结点
     39     Q->rear = s;                        //队尾指针指向新结点(使新结点成为队尾结点)
     40     return OK;
     41 }
     42 
     43 /*链队的出队操作*/
     44 Status DeQueue(LinkQue *Q, QElemType *e)
     45 {
     46     if(Q->front == Q->rear)                //判断队列是否为空
     47         return ERROR;
     48     LinkQuePtr s = (LinkQuePtr)malloc(sizeof(QNode));        //申请结点空间s
     49     s = Q->front->next;                    //s结点等于队头结点(头指针所指向的结点)
     50     *e = s->date;                        //e等于s结点的数据域
     51     Q->front->next = s->next;            //头结点的指针指向s结点的下一结点(使s结点的下一结点成为队头元素)
     52     if(Q->rear == s)                    //判断s是否为队尾元素,若是,说明队列中仅有一个结点
     53         Q->rear = Q->front;                //使队尾结点指向头结点
     54     free(s);                            //释放s结点
     55     return OK;
     56 }
     57 
     58 void main()
     59 {
     60     LinkQue Q;            //创建队Q
     61     int e;                //入队与出队的元素
     62 
     63     while(true)
     64     {
     65         printf("请选择对顺序栈的操作:
    ");
     66         printf("1.初始化
    ");
     67         printf("2.入队
    ");
     68         printf("3.出队
    ");
     69 //        printf("3.遍历
    ");
     70         printf("4.退出
    ");
     71         int a;
     72         scanf("%d", &a);
     73         switch(a)
     74         {
     75             case 1:
     76                 if(InitQue(&Q))
     77                     printf("初始化成功
    ");
     78                 else
     79                     printf("初始化失败
    ");
     80                 break;
     81             case 2:
     82                 printf("请输入入队的元素:");
     83                 scanf("%d", &e);
     84                 if(EnQueue(&Q, e))
     85                     printf("入队成功
    ");
     86                 else
     87                     printf("入队失败
    ");
     88                 break;
     89             case 3:
     90                 if(DeQueue(&Q, &e))
     91                     printf("出队的元素为:%d
    ",e);
     92                 else
     93                     printf("队空
    ");
     94                 break;
     95             case 4:
     96                 return;
     97             default:
     98                 printf("选择错误
    ");
     99                 break;
    100         }
    101     }
    102 }
  • 相关阅读:
    2017-2018 ACM-ICPC, NEERC, Moscow Subregional Contest
    2017-2018 ACM-ICPC, NEERC, Northern Subregional Contest
    BZOJ5104 : Fib数列
    2017-2018 ACM-ICPC Southeast Regional Contest (Div. 1)
    2017 ACM Jordanian Collegiate Programming Contest
    BZOJ4910 : [Sdoi2017] 苹果树
    2017-2018 ACM-ICPC Pacific Northwest Regional Contest (Div. 1)
    BZOJ4912 : [Sdoi2017]天才黑客
    BZOJ4739 : 定向越野
    概率笔记11——一维正态分布的最大似然估计
  • 原文地址:https://www.cnblogs.com/yurui/p/10356693.html
Copyright © 2020-2023  润新知