精华内容
下载资源
问答
  • [C] 纯文本查看 复制代码#include#include#include"queueDAT2.h"#define MAX 10/*定义结构体*/struct node{Item *.../*创建队列*/Queue create(void){Queue q;q = (struct node *)malloc(sizeof(struct node));q-...

    [C] 纯文本查看 复制代码#include

    #include

    #include"queueDAT2.h"

    #define MAX 10

    /*定义结构体*/

    struct node

    {

    Item *value;

    int front, rear;

    };

    /*创建队列*/

    Queue create(void)

    {

    Queue q;

    q = (struct node *)malloc(sizeof(struct node));

    q->value = (Item *)malloc(sizeof(Item));

    q->front = MAX - 1;

    q->rear = MAX - 1;

    return q;

    }

    /*队空*/

    bool is_empty(Queue q)

    {

    return q->front == q->rear;

    }

    /*队满*/

    bool is_full(Queue q)

    {

    return (q->rear + 1) % MAX == q->front;

    }

    /*入队*/

    void push(Queue q, Item x)

    {

    if (is_full(q))

    printf("队满!");

    q->rear = (q->rear + 1) % MAX;

    q->value[q->rear] = x;

    }

    /*出队*/

    Item pop(Queue q)

    {

    Item x;

    if (is_empty(q))

    printf("队空!");

    q->front = (q->front + 1) % MAX;

    x = q->value[q->front];

    return x;

    }

    /*显示队列元素*/

    void showqueue(Queue q)

    {

    int n=0,m;

    while (!is_empty(q))

    {

    q->front = (q->front + 1) % MAX;

    m = q->value[q->front];

    printf(" %d ", m);

    n++;

    }

    for (int i = 0; i < n; i++)

    {

    q->front = (q->front - 1) % MAX;

    }

    }

    展开全文
  • C语言 实现循环队列

    2021-09-25 14:00:07
    文章目录C语言 实现循环队列一、基本概念及注意事项1.基本概念2.注意事项二、C语言实现一个简单的循环队列 C语言 实现循环队列 一、基本概念及注意事项 1.基本概念 队列是一种特殊的线性表结构,特殊之处在于它只...

    C语言 实现循环队列

    一、基本概念及注意事项

    1.基本概念

    队列是一种特殊的线性表结构,特殊之处在于它只允许在表的前端(front)删除元素,在表的尾端(rear)插入元素。因此队列是一种先入先出(FIFO)的数据结构。进行插入操作的端称为队尾,进行删除操作的端称为队头。

    循环队列就是将队列存储空间的最后一个位置绕到第一个位置,形成逻辑上的环状空间,供队列循环使用。

    2.注意事项

    1.在循环队列中,当队列为空时,有front=rear;而当队列满时,也有front=rear。为了区别这两种情况,规定循环队列最多只能有MaxSize-1个队列元素,当循环队列中只剩下一个空存储单元时,队列就已经满了。因此,队列判空的条件是front=rear,而队列判满的条件是front=(rear+1)%MaxSize。
    2.计算循环队列中的元素个数,有rear>front,元素个数为:rear-front;也有rear<fornt,这时元素个数为:(rear-fornt+MaxSize)%MaxSize。

    二、C语言实现一个简单的循环队列

    #include <stdio.h>
    #include <stdlib.h>
    #include <stdbool.h>
    
    typedef struct Queue
    {
    	void** arr;
    	size_t cal;
    	int rear;
    	int front;	
    }Queue;
    
    // 创建队列
    Queue* create_queue(size_t cal)
    {
    	Queue* queue = malloc(sizeof(Queue));
    	queue->arr = malloc(sizeof(void*)*(cal+1));
    	queue->cal = cal+1;
    	queue->rear = 0;
    	queue->front = 0;
    	
    	return queue; 
    }
    
    // 销毁队列
    void destroy_queue(Queue* queue)
    {
    	free(queue->arr);
    	free(queue);
    }
    
    // 判断队列是否已满
    bool full_queue(Queue* queue)
    {
    	return (queue->rear+1)%queue->cal == queue->front;
    }
    
    // 判断队列是否为空
    bool empty_queue(Queue* queue)
    {
    	return queue->rear == queue->front;
    }
    
    // 入队
    void push_queue(Queue* queue,void* ptr)
    {
    	queue->arr[queue->rear] = ptr;
    	queue->rear = (queue->rear+1)%queue->cal;
    }
    
    // 出队
    void pop_queue(Queue* queue)
    {
    	queue->front = (queue->front+1)%queue->cal;
    }
    
    // 获取对头元素
    void* front_queue(Queue* queue)
    {
    	return queue->arr[queue->front];
    }
    
    // 获取队尾元素
    void* rear_queue(Queue* queue)
    {
    	return queue->arr[(queue->rear-1+queue->cal)%queue->cal];
    }
    
    // 计算队列的元素数量
    size_t size_queue(Queue* queue)
    {
    	return (queue->rear-queue->front+queue->cal)%queue->cal;
    }
    
    展开全文
  • C语言实现循环队列

    2019-11-16 14:09:51
    通过C语言实现顺序循环队列和链式队列思想解读 1:链式循环队列思想 总的来说和顺序循环队列是一样的, 1:我们需要首先定义一个数据的结构体 struct link_data { int data; struct link_data *next; } 2:再定义...

    通过C语言实现顺序循环队列和链式队列思想解读

    1:链式循环队列思想

    总的来说和顺序循环队列是一样的,
    1:我们需要首先定义一个数据的结构体

    struct link_data
    {
    	int data;
    	struct link_data *next;
    }
    

    2:再定义一个队列结构体

    struct queue
    {
    	struct link_data *head; //用来接收链表的头节点,方便遍历链表
    	struct link_data *front; //记录链式队列的前端指针
    	struct link_data *base;//巨鹿链式队列的后端指针
    }
    

    3:在初始化的时候就是创建一个链表,并返回头节点,并将链式队列的前后端指针都指向头节点。
    4:判断队列为空:front指针指向的位置要等于base指针指向的位置
    5:判断队列为满:front->next=base;
    6:当指针走到了链表的末尾,则需要循环到开头,也就是头节点位置。

    if(front->next==NULL)
    	front=head;
    if(base->next==NULL)
    	base=head;
    

    7:最后再将所有空间释放就可以完成了。

    注意:因为前面只是思想的表述,有的代码表述跟实现链式队列肯定有不同,但这是我对链式循环队列实现的理解,可能有不足甚至是错误,毕竟我只是一个小小白。

    顺序循环队列的C语言实现

    #include<stdio.h>
    #include<stdlib.h>
    #define MAXSIZE 10
    typedef struct queue
    {
        int *data; //存放数据的
        int front;//队列的前指针
        int base;//队列的后指针
    }Queue;
    
    
    void init_queue(Queue *myqueue)
    {
        myqueue->data=(int *)malloc(sizeof(int)*10);
        if(myqueue->data==NULL)
        {
            exit(0);
        }
        myqueue->front=0;
        myqueue->base=0;
    }
    void input_queue(Queue *myqueue,int data)
    {
        /*1:首先需要判断队列是否是满的
        2:在进行数据的插入
        3:我们实现的是循环队列,所以要注意判断指针的位置
        */
        if((myqueue->front+1)%MAXSIZE==myqueue->base)
        {
            printf("对不起,队列已经满了,不能在插入了!\n");
        }
        else
        {
            myqueue->data[myqueue->front]=data;
            if(myqueue->front==MAXSIZE-1)//说明前端的指针都应经知道数组的最顶端了
                myqueue->front=0; //让他换换链接上,从而实现循环队列
            else
                myqueue->front++;
            printf("myqueue->front:%d\n",myqueue->front);
        }
    }
    
    void output_queue(Queue *myqueue)
    {
        /*1:在出队的时候要注意,判断队列是否为空*/
        if(myqueue->front==myqueue->base)
        {
            printf("队列为空哟,没有可以出队的元素!\n");
        }
        else
        {
            printf("你从队列中取出的元素是:%d\n",myqueue->data[myqueue->base]);
            if(myqueue->base==MAXSIZE-1)
                myqueue->base=0;
            else
                myqueue->base++;
            printf("myqueue->base=%d\n",myqueue->base);
        }
    }
    
    void free_func(Queue *myqueue)
    {
        myqueue->base=NULL;
        myqueue->front=0;
        myqueue->base=0;
        free(myqueue->data);
    }
    int main()
    {
        Queue myqueue;
        int data,i;
        init_queue(&myqueue); //初始化队列
        output_queue(&myqueue);//出队
        for(i=0;i<MAXSIZE-1;i++)
        {
            printf("请输入需要插入的数据:");
            scanf("%d",&data);
            input_queue(&myqueue,data); //入队
        }
        for(i=0;i<7;i++)
        {
            output_queue(&myqueue);//出队
        }
        for(i=0;i<6;i++)
        {
            printf("请输入需要插入的数据:");
            scanf("%d",&data);
            input_queue(&myqueue,data); //入队
        }
        for(i=0;i<10;i++)
        {
            output_queue(&myqueue);
        }
        free_func(&myqueue);
        return 0;
    }
    
    
    展开全文
  • c语言实现循环队列

    2020-06-18 21:27:19
    c语言循环队列的实现 头文件 //循环队列结构 typedef unsigned int size_t; typedef struct Aqueue { void *data[MAXQUEUE]; //数据域 int front; int rear; size_t length; //队列长度 } AQueue; ...

    c语言循环队列的实现

    头文件

     //循环队列结构
    typedef unsigned int size_t;
     typedef struct Aqueue
     {
         void *data[MAXQUEUE];      //数据域
         int front;
         int rear;
         size_t length;        //队列长度
     } AQueue;
     
     typedef enum
     {
         FALSE=0, TRUE=1
     } Status;
     long typeSize;
     char type;
     char datatype[MAXQUEUE];
     /**************************************************************
     
      *    Prototype Declare Section
            **************************************************************/
     
     /**
     
      *  @name        : void InitAQueue(AQueue *Q)
      *  @description : 初始化队列
      *  @param         Q 队列指针Q
      *  @notice      : None
         */
         void InitAQueue(AQueue *Q);
     
     
     /**
     
      *  @name        : void DestoryAQueue(AQueue *Q)
      *  @description : 销毁队列
      *  @param         Q 队列指针Q
      *  @notice      : None
         */
         void DestoryAQueue(AQueue *Q);
     
     
     
     /**
     
      *  @name        : Status IsFullAQueue(const AQueue *Q)
      *  @description : 检查队列是否已满
      *  @param         Q 队列指针Q
      *  @return         : 满-TRUE; 未满-FALSE
      *  @notice      : None
         */
         Status IsFullAQueue(const AQueue *Q);
     
     /**
     
      *  @name        : Status IsEmptyAQueue(const AQueue *Q)
      *  @description : 检查队列是否为空
      *  @param         Q 队列指针Q
      *  @return         : 空-TRUE; 未空-FALSE
      *  @notice      : None
         */
         Status IsEmptyAQueue(const AQueue *Q);
     
     
     
     /**
     
      *  @name        : Status GetHeadAQueue(AQueue *Q, void *e)
      *  @description : 查看队头元素
      *  @param         Q 队列指针Q,存放元素e
      *  @return         : 成功-TRUE; 失败-FALSE
      *  @notice      : 队列是否空
         */
         Status GetHeadAQueue(AQueue *Q, void *e);
     
     
     
     /**
     
      *  @name        : int LengthAQueue(AQueue *Q)
      *  @description : 确定队列长度
      *  @param         Q 队列指针Q
      *  @return         : 队列长度count
      *  @notice      : None
         */
         int LengthAQueue(AQueue *Q);
     
     
     
     /**
     
      *  @name        : Status EnAQueue(AQueue *Q, void *data)
      *  @description : 入队操作
      *  @param         Q 队列指针Q,入队数据指针data
      *  @return         : 成功-TRUE; 失败-FALSE
      *  @notice      : 队列是否满了或为空
         */
         Status EnAQueue(AQueue *Q, void *data);
     
     
     
     /**
     
      *  @name        : Status DeAQueue(AQueue *Q)
      *  @description : 出队操作
      *  @param         Q 队列指针Q
      *  @return         : 成功-TRUE; 失败-FALSE
      *  @notice      : None
         */
         Status DeAQueue(AQueue *Q);
     
     
     
     /**
     
      *  @name        : void ClearAQueue(Queue *Q)
      *  @description : 清空队列
      *  @param         Q 队列指针Q
      *  @notice      : None
         */
         void ClearAQueue(AQueue *Q);
     
     
     
     /**
     
      *  @name        : Status TraverseAQueue(const AQueue *Q, void (*foo)(void *q))
      *  @description : 遍历函数操作
      *  @param         Q 队列指针Q,操作函数指针foo
      *  @return         : None
      *  @notice      : None
         */
         Status TraverseAQueue(const AQueue *Q, void (*foo)(void *q));
     
     
     
     /**
     
      *  @name        : void APrint(void *q)
      *  @description : 操作函数
      *  @param         q 指针q
      *  @notice      : None
         */
         void APrint(void *q);
    
    
     
     头文件的实现
     
     ```c
     #include "AQueue.h"
     #include <stdio.h>
     #include <stdlib.h>
     #include <string.h>
     
     void InitAQueue(AQueue *Q)
     {
         for(int i = 0; i < MAXQUEUE; i++)
             Q->data[i] = (void *)malloc(typeSize);
     	Q->front = Q->rear = Q->length = 0;
     }
     
     void DestoryAQueue(AQueue *Q)
     {
         int i = 0;
     	while (Q->length--)
             free(Q->data[i++]);
     	exit(0);
     }
     
     Status IsFullAQueue(const AQueue *Q)
     {
         if (Q->length == MAXQUEUE)
             return TRUE;
         return FALSE;
     }
     
     Status IsEmptyAQueue(const AQueue *Q)
     {
         if (!Q->length) return TRUE;
         return FALSE;
     }
     
     Status GetHeadAQueue(AQueue *Q, void *e)
     {
         if (IsEmptyAQueue(Q)) return FALSE;
         memcpy(e,Q->data[0],typeSize);
         return TRUE;
     }
     
     int LengthAQueue(AQueue *Q)
     {
         return Q->length;
     }
     
     Status EnAQueue(AQueue *Q, void *data)
     {
         if (IsFullAQueue(Q))
     	{
     		printf("队列满了\n");
     		return FALSE;
     	}
     	memcpy(Q->data[Q->rear], data, typeSize);
         Q->rear = (Q->rear + 1) % MAXQUEUE;
     	Q->length++;
     	return TRUE;
     }
     
     Status DeAQueue(AQueue *Q)
     {
         if (IsEmptyAQueue(Q))
         {
             printf("队列是空的!\n");
             return FALSE;
         }
         Q->front = (Q->front+1)%MAXQUEUE;
         Q->length--;
         return TRUE;
     }
     
     void ClearAQueue(AQueue *Q)
     {
         Q->front = Q->rear = Q->length = 0;
     }
     
     Status TraverseAQueue(const AQueue *Q, void (*foo)(void *q))
     {
         if (IsEmptyAQueue(Q))
         {
             puts("队列为空!");
             return FALSE;
         }
         for (int i = Q->front,j = Q->length;j > 0;j--)
         {
             foo(Q->data[i]);
             i = (i+1)%MAXQUEUE;
         }
             return TRUE;
     }
     
     void APrint(void *q)
     {
          if  (type == 'd')
                 printf("--> %.2lf", *(double*)q);
         else if (type == 'c')
                 printf("--> %c", *(char*)q);
         else if (type == 'i')
                 printf("--> %d ", *(int*)q);
         else if (type == 's')
                 printf("--> %s ", (char*)q);
         else if (type == '*')
                 printf("--> %p ", *(char *)q);
     }
    

    具体调用函数测试

    #include "AQueue.h"
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    char * s_gets(char *st,int n);
    void setType();
    int getInt();
    void menu();
    void select(AQueue * Q);
    void setVoid(AQueue * Q);
    
    int main()
    {
        AQueue * Q;
    
        Q = (AQueue *)malloc(sizeof(AQueue));
        puts("欢迎使用泛型队列(循环)ADT测试系统");
        puts("现在先确定队列要存取哪种数据类型:\n a.int型\t b.char型 \n c.double型\t d.string型 \n e.指针类(系统将简单创建测试用例)");
        setType();
        puts("好的,接下来你可以选择测试操作。");
        InitAQueue(Q);
        menu();
        select(Q);
        return 0;
    
    }
    
    //选择操作
    void select(AQueue * Q)
    {
        int i =0;
        void *t;
    
        puts("请选择你的操作");
        switch(getInt())
        {
            case 1:DestoryAQueue(Q);
            case 2:if (IsEmptyAQueue(Q)) puts("队列为空");
                    else puts("队列不为空");
                    break;
            case 3:if (IsFullAQueue(Q)) puts("队列已满");
                    else puts("队列未满");
                    break;
            case 4:if (GetHeadAQueue(Q,t))
                    {
                        printf("操作成功,头结点数据为");
                        APrint(t);
                        printf("\n");
                    }
                    else puts("操作失败,队列为空");
                    break;
            case 5:i = LengthAQueue(Q);printf("队列长度为%d\n",i);
                    break;
            case 6:if (IsFullAQueue(Q)) puts("操作失败,队列已满");
                    else {
                        setVoid(Q);
                        puts("操作成功");
                    }
                    break;
            case 7:if (DeAQueue(Q)) puts("操作成功");
                    else puts("操作失败,队列为空");
                    break;
            case 8:ClearAQueue(Q);puts("已清空");break;
            case 9:if (TraverseAQueue(Q,APrint)) puts("操作成功");
                    else puts("操作失败");
                    break;
            case 10:system("cls");menu();break;
            default :puts("输入错误");
        }
        select(Q);
    
    }
    
    //打印菜单
    void menu()
    {
        puts("\t\t1.删除队列并退出系统");
        puts("\t\t2.判断队列是否为空");
        puts("\t\t3.判断队列是否已满");
        puts("\t\t4.输出头结点数据");
        puts("\t\t5.输出队列现存长度");
        puts("\t\t6.入队操作");
        puts("\t\t7.出队操作");
        puts("\t\t8.清空队列");
        puts("\t\t9.遍历队列并输入元素");
        puts("\t\t10.清空记录");
    }
    
    //确定泛型
    void setType()
    {
        char t[3];
    
        s_gets(t,3);
        if (t[0] == 'a' && t[1] == '\0')
        {
            type = 'i';
            typeSize = sizeof(int);
        }
        else if (t[0] == 'b' && t[1] == '\0')
        {
            type = 'c';
            typeSize = sizeof(char);
        }
        else if (t[0] == 'c' && t[1] == '\0')
        {
            type = 'd';
            typeSize = sizeof(double);
        }
        else if (t[0] == 'd' && t[1] == '\0')
        {
            type = 's';
            typeSize = sizeof(char)*100;
        }
        else if (t[0] == 'e' && t[1] == '\0')
        {
            type = '*';
            typeSize = sizeof(char *);
        }
        else {
            puts("输入错误!请重新输入");
            setType();
        }
    
    }
    
    //获得int
    int getInt()
    {
        char in[11];
        int t;
    
        s_gets(in,11);
        t = atoi(in);
        if (t == 0) {
                if (in[1] != 0 || in[2] != '\0')
                {
                    printf("输入错误,请重新输入!\n");
                    t = getInt();
                }
        }
        return t;
    
    }
    
    //读取键盘输入
    char * s_gets(char *st,int n)
    {
        char * ret_val;
        char * find;
    
        fflush(stdin);
        ret_val = fgets(st,n,stdin);
        if (ret_val)
        {
            find = strchr(st,'\n');
            if (find)
                *find = '\0';
            else
                while (getchar() != '\n')
                        continue;
        }
        return ret_val;
    
    }
    
    //入队数据操作
    void setVoid(AQueue * Q)
    {
        char c[100];
    
        if (type == 'i')
        {
            int a = 0;
        
            puts("请输入数据");
            a = getInt();
            EnAQueue(Q,&a);
        }
        else if (type == 'c')
        {
            puts("请输入数据");
            s_gets(c,3);
            if (c[2] != '\0')
            {
                puts("类型错误,请重新输入");
                s_gets(c,3);
            }
            EnAQueue(Q,&c[0]);
        }
        else if (type == 'd')
        {
            double d;
    
    
            puts("请输入数据");
            s_gets(c,100);
    
    skip :  d = atof(c);
            if (d == 0 ) {
                int i = 0;
                while (c[i++] != '\0')
                {
                    if (c[i] != '0' && c[i] != '.')
                    {
                        puts("输入错误,请重新输入\n");
                        s_gets(c,100);
                        goto skip;
                    }
                }
            }
            EnAQueue(Q,&d);
        }
        else if (type == 's')
        {
            puts("请输入数据");
            s_gets(c,100);
            EnAQueue(Q,&c);
        }
        else if (type == '*')
        {
            EnAQueue(Q,&c[Q->length]);
    
        }
    
    }
    
    展开全文
  • 循环队列就是队列首尾相连,容量固定的环 对于循环队列 需要判断当前是否队列可以插入 也就是队是否满了 通常有以下三种方法判断 设置一个标志位表示栈空或满 设置一个插入元素个数计数器 采用余数法 对每次插入的...
  • 为了防止“假溢出”,顺序存储我们用循环队列来实现,为了便于辨别队列是否已满,通常要保证循环队列满的时候,数组仍有一个空闲空间。 判断循环队列: 队列已满:( rear + 1 ) % MAXIZE = front 队列为空:rear = ...
  • 循环队列 //Authors:xiaobei #include<stdio.h> #include<stdlib.h> #include<string.h> #define MAXSIZE 6 #define OK 1 #define ERROR 0 typedef struct { char *base; int ...
  • 1.创建循环队列并初始化。 2.入队。 3.出队。 4.取对头元素。 为什么我们要使用循环队列? 1.普通顺序队列: 在使用普通顺序队列的时,判断队空的操作是rear==front,判断队满的操作是判断rear是否在队列尾部我们不...
  • 用一个数组实现的循环队列来实现就比较简单。根结点进入队列,然后出队,根节的左孩子不为空的话左孩子进队,后孩子不为空的话右孩子进队。然后循环如此直到循环队列空为止。 代码如下: #include<stdio.h> #...
  • //创建一个循环队列 void Print_Sqqueue(Sqqueue &q); //以此输出循环队列的值 //函数定义 void Error(char *s) { cout ; exit(1); } Sqqueue Creat_Sqqueue() { Sqqueue q; q.data = new int[QUEUE_...
  • C语言实现循环队列的构建、入队、出队、扩容、遍历等操作 一 队列的定义和初始化   在C++的STL中有queue可以直接使用,小编这里采用C语言实现队列的基本操作,毕竟学会自己“造轮子”而不是拿来主义,可以更深刻的...
  • 队列是另一种经典数据结构,也是有两种,一是静态队列,即数组实现的循环队列,二是用链表实现的动态队列,今天我写的是循环队列,下面我就详细分析一下循环队列我认为不太好理解的几个点 第零,循环队列的构成,用...
  • #include"stdio.h"#include"stdlib.h"//这... //定义一个队列元素类型,这种编程思路很好,程序有扩展空间//声明一个有关循环队列的数据块,注意每个元素的意义!struct Queue{ElemType *base;//数据类型头指针int f...
  • if(Q->front==(Q->rear+1)%maxsize) //判断循环链表是否满,留一个预留空间不用 return 1; else return 0; } int EmptyQueue(PQUEUE Q) { if(Q->front==Q->rear) //判断是否为空 return 1; else return 0; }...
  • 通过此程序可以实现循环队列初始化,循环队列入队,循环队列出队,判断循环队列是否为空,求循环队列长度,循环队列输出,循环队列销毁,杨辉三角。 代码如下 #include"malloc.h" #include"stdio.h" #include...
  • 循环队列的存储结构的特点我们知道:顺序存储必须分配一块连续的内存,不够灵活,并且还要担心数组越界的问题,链式存储就体现出了它的优势。 链队列初始化: void InitLinkQueue( LinkQueue *Q ) { int i ; ...
  • C语言实现顺序队列

    千次阅读 2020-06-24 12:51:10
    C语言详解顺序队列
  • c语言循环队列的建立

    千次阅读 2018-09-04 11:30:26
    对于队列来说,出队列就是在队列头部出来,然后将...循环队列就可以解决这个问题,‘’队满‘’时从头部开始重新插入 #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #define max 5 typ...
  • # 下面给出的代码是循环队列的基础操作,代码注释写的还算详细,帮助大家理解,同时也有助我回忆 在这里插入代码片 #include<stdio.h> #define qsize 5 int qdata[5],i=0; struct cell///单个结点 { int data;...
  • /* *循环队列的创建 *循环队列的初始化 ...*创建循环队列的结构体 *求循环队列的长度 */ #include<stdio.h> #include<stdlib.h> #include<time.h> #include<string.h> #define OK 1 #def...
  • c语言实现的链式队列、顺序队列还有循环队列的建立。代码完整可以直接运行的。
  • C语言数组实现循环队列

    千次阅读 2016-09-12 09:30:05
    ********************************************数组实现循环队列.h******************************************** //循环队列(数组实现) #include <stdlib.h> #include <stdio.h> #define MAXSIZE 5 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 23,425
精华内容 9,370
关键字:

c语言创建循环队列

c语言 订阅