精华内容
下载资源
问答
  • [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-04-06 18:18:49
    不同于无锁队列,有锁队列是在入列或者出列时,为队列上锁,这样保证代码在运行时同一时间只能有一种操作,因此避免了资源的抢占。 使用场景 生产消费者模型之类的场景可以使用。 二、代码 头文件定义 我们定义一...

    一、前言

    1. 有锁队列
      不同于无锁队列,有锁队列是在入列或者出列时,为队列上锁,这样保证代码在运行时同一时间只能有一种操作,因此避免了资源的抢占。
    2. 使用场景
      生产消费者模型之类的场景可以使用。

    二、代码演示

    1. 场景
      创建两个工作线程,一个每隔一秒往队列里面写数据,一个每隔三秒从队列往外读取数据,当写入数据达到10次后,线程停止工作。

    2. 队列头文件定义
      我们定义一个USER_INFO结构体数据类型,里面存储了一些信息,用单向链表的形式在队列中进行存储。
      queue.h代码如下:

      //
      // Created by jerry on 2021/4/6.
      //
      
      #ifndef C_QUEUE_DEMO_QUEUE_H
      #define C_QUEUE_DEMO_QUEUE_H
      
      #include <stddef.h>
      #include <pthread.h>
      #include <stdbool.h>
      
      #include "queue.h"
      
      /**
       * 用户信息
       * */
      struct USER_INFO
      {
          int id;
          char *name;
          int age;
          int sex;
      };
      
      /**
       *  链表节点(单向)
       *  在队列中以此结构存储
       * */
      struct NODES
      {
          struct USER_INFO *userInfo;
          struct NODES     *next;
      };
      
      /**
       *  队列句柄
       * */
      struct QUEUE
      {
          size_t qCount;           // 队列长度
          pthread_mutex_t *qMutex; // Mutex锁
      
          /* 函数指针,初始化后可通过QUEUE->xxx 方式调用 */
          void   (* ENQUEUE)     (struct QUEUE *, struct USER_INFO *); // 入列
          struct USER_INFO * (* DEQUEUE) (struct QUEUE *);             // 出列
          size_t (* QUEUE_COUNT) (struct QUEUE *);                     // 队列长度
          size_t (* QUEUE_COUNT_DEBUG) (struct QUEUE *);               // 队列长度
          void   (* QUEUE_FREE)  (struct QUEUE **, bool);              // 释放队列
      
          struct NODES *head; // 链表头部
      };
      
      /* 队列初始化 */
      struct QUEUE *queue_init();
      /* 入列 */
      void enqueue(struct QUEUE *queue, struct USER_INFO *userInfo);
      /* 出列 */
      struct USER_INFO *dequeue(struct QUEUE *queue);
      /* 查询队列长度 */
      size_t queue_count(struct QUEUE *queue);
      /* 查询队列长度 */
      size_t queue_count_debug(struct QUEUE *queue);
      /* 释放队列 */
      void queue_free(struct QUEUE **queue, bool freeData);
      
      #endif //C_QUEUE_DEMO_QUEUE_H
      
      
    3. 定义queue.c文件
      此文件详细写出有锁队列是怎样存储数据的,代码如下:

      //
      // Created by jerry on 2021/4/6.
      //
      #include <stdio.h>
      #include <stdlib.h>
      
      #include "queue.h"
      
      #define DEBUG 1
      #define LOGD(fmt, ...) {if (DEBUG == 1 ) printf("[D][%s:%d] "fmt"\n", __FUNCTION__, __LINE__, ##__VA_ARGS__);}
      
      /*************************************************************************
      * Function:    struct QUEUE *queue_init()
      * Description: 初始化队列
      * Input:       无
      * Return:      struct QUEUE * 初始化完成的队列
      * Others:      NULL
      **************************************************************************/
      struct QUEUE *queue_init()
      {
          LOGD("queue init.");
      
          struct QUEUE *queue = (struct QUEUE *)calloc(1, sizeof(struct QUEUE)); // 申请QUEUE空间
          queue->qMutex = (pthread_mutex_t *)calloc(1, sizeof(pthread_mutex_t)); // 申请Mutex空间
          pthread_mutex_init(queue->qMutex, NULL); // 初始化Mutex
          queue->qCount = 0;  // 初始化count数值
          queue->head = NULL; // 消息节点置空
      
          /* 回调函数指针赋值 */
          queue->ENQUEUE           = enqueue;           // 入列
          queue->DEQUEUE           = dequeue;           // 出列
          queue->QUEUE_COUNT       = queue_count;       // 队列长度
          queue->QUEUE_COUNT_DEBUG = queue_count_debug; // 队列长度
          queue->QUEUE_FREE        = queue_free;        // 释放对列
      
          return queue;
      }
      
      /*************************************************************************
      * Function:    void enqueue(struct QUEUE *queue,
      *                                     struct USER_INFO *userInfo)
      * Description: 数据压入队列
      * Input:
      *              struct QUEUE *queue          队列句柄
      *              struct USER_INFO *userInfo   需要入列的数据
      * Return:      NULL
      * Others:      NULL
      **************************************************************************/
      void enqueue(struct QUEUE *queue, struct USER_INFO *userInfo)
      {
          pthread_mutex_lock(queue->qMutex); // 上锁
      
          /* 为新来的数据申请空间且赋值 */
          struct NODES *newNodes = (struct NODES *)calloc(1, sizeof(struct NODES));
          newNodes->userInfo = userInfo; // 赋值
      
          /* 数据入列 */
          if (!queue->head)
          {
              queue->head    = newNodes;
              newNodes->next = NULL;
          }
          else
          {
              struct NODES *tmp = queue->head;
              while (tmp->next)
              {
                  tmp = tmp->next;
              }
      
              tmp->next      = newNodes;
              newNodes->next = NULL;
          }
      
          ++ queue->qCount; // 队列长度 + 1
          pthread_mutex_unlock(queue->qMutex); // 解锁
      }
      
      /*************************************************************************
      * Function:    struct USER_INFO *dequeue(struct QUEUE *queue)
      * Description: 数据出列
      * Input:
      *              struct QUEUE *queue 队列句柄
      * Return:      struct USER_INFO *  队列中的数据
      * Others:      NULL
      **************************************************************************/
      struct USER_INFO *dequeue(struct QUEUE *queue)
      {
          pthread_mutex_lock(queue->qMutex); // 上锁
      
          /* head为空即队列中没有数据 */
          if (!queue->head)
          {
              pthread_mutex_unlock(queue->qMutex);
              return NULL;
          }
      
          /* 取出头部数据 */
          struct NODES *tmp = queue->head;
          queue->head       = tmp->next;
          tmp->next         = NULL;
      
          struct USER_INFO *userInfo = tmp->userInfo;
          free(tmp);
          tmp = NULL;
      
          -- queue->qCount;
          pthread_mutex_unlock(queue->qMutex);
      
          return userInfo;
      }
      
      
      /*************************************************************************
      * Function:    size_t queue_count(struct QUEUE *queue)
      * Description: 获取队列长度
      * Input:
      *              struct QUEUE *queue 队列句柄
      * Return:      size_t 队列实际长度
      * Others:      NULL
      **************************************************************************/
      size_t queue_count(struct QUEUE *queue)
      {
          pthread_mutex_lock(queue->qMutex); // 上锁
      
          if (queue == NULL)
          {
              pthread_mutex_unlock(queue->qMutex);
              return 0;
          }
      
          size_t count = queue->qCount;
          pthread_mutex_unlock(queue->qMutex);
          return count;
      }
      
      /*************************************************************************
      * Function:    size_t queue_count_debug(struct QUEUE *queue)
      * Description: 获取队列长度
      * Input:
      *              struct QUEUE *queue 队列句柄
      * Return:      size_t 队列实际长度
      * Others:      NULL
      **************************************************************************/
      size_t queue_count_debug(struct QUEUE *queue)
      {
          pthread_mutex_lock(queue->qMutex); // 上锁
      
          if (queue == NULL)
          {
              pthread_mutex_unlock(queue->qMutex);
              return 0;
          }
      
          size_t count = 0;
          struct NODES *tmp = queue->head;
          while (tmp)
          {
              tmp = tmp->next;
              ++ count;
          }
      
          pthread_mutex_unlock(queue->qMutex);
          return count;
      }
      
      /*************************************************************************
      * Function:    void queue_free(struct QUEUE **queue, bool freeData)
      * Description: 释放队列
      * Input:
      *              struct QUEUE **queue 队列句柄
      *              bool freeData        是否需要释放队列中的数据
      * Return:      NULL
      * Others:      NULL
      **************************************************************************/
      void queue_free(struct QUEUE **queue, bool freeData)
      {
          pthread_mutex_lock((*queue)->qMutex); // 上锁
      
          struct NODES *tmp = NULL;
          while ((*queue)->head)
          {
              tmp = (*queue)->head;
              (*queue)->head = tmp->next;
              tmp->next = NULL;
      
              if (freeData)
              {
                  free(tmp->userInfo->name);
                  tmp->userInfo->name = NULL;
                  free(tmp->userInfo);
                  tmp->userInfo = NULL;
              }
      
              free(tmp);
              tmp = NULL;
          }
      
          /* 释放锁 */
          pthread_mutex_unlock((*queue)->qMutex);
          pthread_mutex_destroy((*queue)->qMutex);
          free((*queue)->qMutex);
          (*queue)->qMutex = NULL;
      
          /* 释放整个队列 */
          free(*queue);
          *queue = NULL;
      }
      
    4. 使用方法
      参考代码:gitee
      (1) 初始化队列

      struct QUEUE *mQueue = NULL;
      mQueue = queue_init();
      

      (2) 消息入列

      static int id = 0;
      
      struct USER_INFO *userInfo = (struct USER_INFO *)calloc(1, sizeof(struct USER_INFO));
      userInfo->id = id;
      userInfo->name = get_string();
      userInfo->sex  = rand() % 2;
      userInfo->age  = rand() % 30;
      mQueue->ENQUEUE(mQueue, userInfo);
      

      (3) 消息出列

      struct USER_INFO *userInfo = mQueue->DEQUEUE(mQueue);
      

      (4) 查询长度

      mQueue->QUEUE_COUNT(mQueue);
      mQueue->QUEUE_COUNT_DEBUG(mQueue);
      

      (5) 释放队列

      mQueue->QUEUE_FREE(mQueue, false);
      mQueue = NULL;
      

    三、代码移植事项

    1. 可将struct USER_INFO{} 改成用户需要的数据结构,然后在代码中做相应的替换即可。
    2. 注意申请的空间要释放,否则会造成内存泄漏。QUEUE_FREE中若userInfo->name是申请的空间,则第二个参数为true,否则为false
    展开全文
  • C语言实现顺序队列

    千次阅读 2020-06-24 12:51:10
    C语言详解顺序队列


    队列的示意图

    顺序队列常规操作

    /********************* 顺序队列的常规操作 *************************/
    
    Queue    InitSeQueue();             // 初始化顺序队列
    int      QueueFull();               // 判断顺序队列满
    int      QueueEmpty();              // 判断顺序队列空
    int      QueueLength();             // 求顺序队列长度(元素个数)
    int      EnQueue();                 // 入队
    int      DeQueue();                 // 出队
    
    /****************************************************************/
    

    定义顺序队列结构体

    #include "stdio.h"
    #include "malloc.h"
    
    #define TRUE  1
    #define FALSE 0
    #define MAXSIZE 10      // 队列最大的存储量
    
    typedef int ElemType;
    
    
    // 定义顺序队列结构体
    typedef struct SeQueue{
        ElemType *base; // 队列首地址
        int front;      // 队列头下标
        int rear;       // 队列尾下标
    }*Queue;
    

    顺序队列和顺序栈相类似,在队列的顺序存储结构中,除了用一组地址连续的存储单元依次存放从队列头到队列尾的元素之外,尚需附设两个 “指针” frontrear 分别指示队列头元素及队列尾元素的位置。

    为了在C语言中描述方便起见,初始化建空队列时,令 front = rear = 0;

    每当插入新的队尾元素时 “尾指针增1”;每当删除队头元素时 “头指针增1”

    因此,在非空队列中,头指针始终指向队列头元素,而尾指针始终指向队列尾元素的下一个位置


    初始化顺序队列

    /*
     *  初始化顺序队列
    */
    Queue InitSeQueue(){
        Queue q;
        // 分配队列空间
        q -> base = (ElemType *)malloc(sizeof(ElemType) * MAXSIZE);
        q -> front = q -> rear = 0; // 开始队列的头尾下标相等
        return q;
    }
    

    顺序队列判满

    /*  
     *  顺序队列判满
     *  q 顺序队列
    */
    int QueueFull(Queue q){
        if(q == NULL){
            return FALSE;
        }
        // 判断队列尾下标是否超过最大容量
        if(q -> rear >= MAXSIZE){
            return TRUE;
        }
        return FALSE;
    }
    

    顺序队列判空

    /*
     *  顺序队列判空
     *  q 顺序队列
    */
    int QueueEmpty(Queue q){
        if(q == NULL){
            return FALSE;
        }
        return q -> front == q -> rear;
    }
    

    计算顺序队列的长度

    /*
     *  求顺序队列的长度(元素个数)
     *  q 顺序队列
    */
    int QueueLength(Queue q){
        if(q == NULL){
            return FALSE;
        }
        return q -> rear - q -> front;
    }
    

    顺序队列入队(EnQueue)

    /*
     *  入队
     *  q 顺序队列
     *  data 入队元素
    */
    int EnQueue(Queue q, ElemType data){
        // 队列判满
        if(QueueFull(q)){
            return FALSE;
        }
        // 把元素插入队尾
        q -> base[q -> rear] = data;    
        q -> rear++;
        return TRUE;
    }
    

    顺序队列出队(DeQueue)

    /*
     *  出队  
     *  q 顺序队列
     *  *val 用来存出队元素的数据 
    */
    int DeQueue(Queue q, ElemType *val){
        // 队列判空
        if(QueueEmpty(q)){
            return FALSE;
        }
        // 把队头元素取出来并利用指针返回去
        *val = q -> base[q -> front];
        q -> front ++;
        return TRUE;
    }
    

    顺序队列各操作测试

    /*
     * 打印队满、队空、队长状态
     * q 顺序队列
    */
    void QueueStatus(Queue q){
        printf("QueueFull():%d\n", QueueFull(q));
        printf("QueueEmpty():%d\n", QueueEmpty(q));
        printf("QueueLength():%d\n\n", QueueLength(q));
    }
    
    // 程序主入口
    int main(int argc, char const *argv[])
    {   
        Queue q = InitSeQueue();
        printf("QueueMaxSize: %d\n\n", MAXSIZE);
        QueueStatus(q); // 打印队满、队空、队长状态
    
        // 入队
        printf("EnQueue():");
        for(int i = 1; i < MAXSIZE * 2; i+=2){
            printf("%d\t", i);
            EnQueue(q, i);
        }
    
        printf("\n");
        QueueStatus(q);
    
        // 出队
        int val;
        printf("DeQueue():");
        while(!QueueEmpty(q)){
            DeQueue(q, &val);
            printf("%d\t", val);
        }
        printf("\n");
        QueueStatus(q);
        
       // 此时队列元素全出队了,测试假溢出
        int num = 20;
        printf("EnQueue(%d): %d\t(0 Failed, 1 Success)\n", num, EnQueue(q, num));
    
        return 0;
    }
    

    结果如下:

    QueueMaxSize: 10
    
    QueueFull():0
    QueueEmpty():1
    QueueLength():0
    
    EnQueue():1     3       5       7       9       11      13      15      17      19
    QueueFull():1
    QueueEmpty():0
    QueueLength():10
    
    DeQueue():1     3       5       7       9       11      13      15      17      19
    QueueFull():1
    QueueEmpty():1
    QueueLength():0
    
    EnQueue(20): 0  (0 Failed, 1 Success)
    

    QueueFull():1EnQueue(20): 0 可以看出顺序队列存在假溢出(实际可用空间并未占满,却不能进行入队操作)

    例如:

    顺序队列假溢出

    1️⃣:初始化空队列,q -> front = q -> rear = 0

    2️⃣:入队a1、a2、a3,q -> front = 0, q -> rear = 3

    3️⃣:出队a1、a2,q -> front = 2, q -> rear = 3

    4️⃣:入队a4、a5、a6,q -> front = 2, q -> rear = 6

    执行 4️⃣ 操作后队列的"尾指针"已经超出对队列的最大范围了,之后无法再进行入队操作,而队列实际空间并未占满,就造成了假溢出。

    循环队列 就可以解决假溢出情况。


    源代码

    源代码已上传到 GitHub Data-Structure-of-C,欢迎大家下载 C语言实现数据结构

    ✍ 码字不易,记得点赞 👍 收藏 ⭐️

    展开全文
  • 队列先入先出 在DFS、图论使用频繁 #include<stdio.h> #include<stdlib.h> typedef struct Node{ int data; struct Node* next; }Node; typedef struct Queue{ Node* front; Node* tail; int ...

    队列先入先出 在DFS、图论使用频繁

    #include<stdio.h> 
    #include<stdlib.h>
    
    typedef struct Node{
    	int data;
    	struct Node* next;
    }Node;
    
    typedef struct Queue{
    	Node* front;
    	Node* tail;
    	int count;
    	
    }Queue;
    
    // 入队
    int push(Queue* q,int data);
    // 遍历
    void walk(Queue* q);
    // 初始化队列
    Queue* init();
    // 出队
    int pop(Queue* q);
    // 队列判空
    bool empty(Queue* q);
    
    int main() {
    	Queue* q = init();
    	int arr[5] = {1,2,3,4,5};
    	for(int i=0; i<5; i++) {
    		push(q,arr[i]);
    	}
    	walk(q);
    	printf("出队%d\n",pop(q));
    	walk(q);
    	return 0;
    } 
    // 出队
    int pop(Queue* q) {
    	if(q->front==NULL){
    		printf("队空\n");
    		return 0; 
    	}
    	Node* temp = q->front;
    	int val = temp->data;
    	q->front = q->front->next;
    	q->count--;
    	free(temp);
    	return val;
    } 
    // 队列判空
    bool empty(Queue* q) {
    	return q->front == NULL; 
    }
    // 入队
    int push(Queue* q,int data) {
    	Node* temp = (Node*)malloc(sizeof(Node));
    	if(temp==NULL){
    		printf("内存申请失败\n");
    		return NULL;
    	}
    	temp->data = data;
    	temp->next = NULL;
    	if(empty(q)) {
    		q->front=q->tail=temp;
    	}else{
    		q->tail->next = temp;
    		q->tail = temp;
    	}
    	return ++(q->count);
    } 
    // 遍历
    void walk(Queue* q) {
    	if(q->front==NULL){
    		printf("队空\n");
    		return; 
    	}
    	Node* cur = q->front;
    	printf("==队列开始==\n");
    	while(cur) {
    		printf("元素:%d\n",cur->data);
    		cur = cur->next; 
    	} 
    	printf("==队列结束==\n");
    } 
    // 初始化队列
    Queue* init() {
    	Queue* q = (Queue*)malloc(sizeof(Queue));
    	if(q==NULL) {
    		printf("内存申请失败\n");
    		return NULL;
    	}
    	q->front = q->tail = NULL;
    	return q;
    	
    } 
    
    展开全文
  • 队列:特殊的线性表,“先进先出”,在尾结点处插入,头节点处删除。它也有有顺序存储和链式...队列为:rear = front 队列长度:( MAXIZE - front + rear ) % MAXIZE 队列的结构定义: typedef int Status ; typedef
  • C语言 实现循环队列

    2021-09-25 14:00:07
    文章目录C语言 实现循环队列一、基本概念及注意事项1.基本概念2.注意事项二、C语言实现一个简单的循环队列 C语言 实现循环队列 一、基本概念及注意事项 1.基本概念 队列是一种特殊的线性表结构,特殊之处在于它只...
  • 循环队列就是队列首尾相连,容量固定的环 对于循环队列 需要判断当前是否队列可以插入 也就是队是否满了 通常有以下三种方法判断 设置一个标志位表示栈或满 设置一个插入元素个数计数器 采用余数法 对每次插入的...
  • C语言实现循环队列

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

    千次阅读 2020-03-19 18:21:53
    数据结构之队列队列是另一种特殊的线性表,是先进先出的,并且出去的元素会被删除。就如同我们真实生活中排队一样,先到的人排在前面,也最先离开队列。...创建一个链表结构 typedef struct QueueNode { int da...
  • C语言设计实现队列

    2021-03-10 16:54:34
    队列相关功能实现3.1 队列的初始化3.2 数据入队3.3 数据出队3.4 获取队头数据3.5 获取队尾数据3.6 检测队列是否为,如果为返回非零结果,如果非空返回03.7 获取队列中有效元素个数3.8 销毁队列 前言 队列是...
  • 创建队列 c语言_在C中创建队列

    千次阅读 2020-07-18 22:14:52
    创建队列 c语言A queue in C is basically a linear data structure to store and manipulate the data elements. It follows the order of First In First Out (FIFO). C语言中的队列基本上是用于存储和操作数据...
  • C语言实现链式队列

    2021-05-02 11:42:38
    C语言实现链式队列 一、头文件、自定义数据类型已经自定义变量 #include<stdio.h> #include<stdlib.h> typedef int QElemType; typedef int Status; #define OK 1 #define ERROR 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语言中的队列、栈和链表: 1. C语言中的队列队列在生活中十分常见,例如排队买票就是一个队列,先排队的人会先买到票,队列就是一个“先到先服务”的处理。 队列一般包含三个元素:队列中存放的数据,队头...
  • - 创建队列时,实际是创建了xLinkQueue,之后对队列的操作都是通过它 - 添加节点时,创建的Node,并将内容复制进它的buff中 - 弹出队列时,将Node中的内容先复制出来,在free释放内存 util.c /** 工具包 */ ...
  • C语言实现链式队列模板 #include <stdio.h> #include <stdlib.h> /************************************************ * C语言链式队列模板 * * 1.InitLinkQueue() 初始化链式队列:为头指针动态分配...
  • c语言下的队列

    2019-04-02 10:16:25
    队列 1.概念 队列也是一种线性数据结构 采用先进先出的方式管理数据,放入数据和取出数据在两个不同的端点进行,实现需要记录两个端点各自的位置 放入数据的一段称之为队尾,取出数据的一端称之为队头 往队列放入...
  • #include"stdio.h"#include"stdlib.h"//这是一个静态队列的例程#define MAXSIZE 10 //队列的最大容量typedef char ElemType; //定义一个队列元素类型,这种编程思路很好,程序有扩展空间//声明一个有关循环队列的...
  • c语言中优先级队列A Priority Queue is a variant of a Queue such that it’s elements are ordered based on their priority. C++ has a built-in priority queue data structure in it’s Standard Template ...
  • 使用单链表就行了。为了实现链式队列, 我先去实现单链表
  • C语言贪吃蛇(队列思想) 用到了队列的出队和入队,对队列不清楚的可以网上看看关于什么是队列 注:其中用到了双缓冲来解决闪屏问题 效果如下 话不多说,代码如下: /******************** *队列思想,根据每移动...
  • C语言——链表队列

    2020-04-08 10:18:07
    #include<stdio.h> #include<stdlib.h> #include<string.h> struct list{ ...struct list* listcreat(int data)//创建节点 ,当要在队列中输入数据时,在此创建节点 { struct list* list...
  • C语言实现顺序队列(环形) 一、头文件、自定义数据类型及自定义变量 #include<stdio.h> #include<stdlib.h> typedef int QElemType; typedef int Status; #define OK 1 #define ERROR 0 #define ...
  • 描述队列的概念在此之前,我们来回顾一下队列的基本概念:队列 (Queue):是一种先进先出(First In First Out ,简称 FIFO)的线性表,只允许在一端插入(入队),在另一端进行删除(出队)。队列的特点队列的常见两种形式...
  • c语言静态数组创建队列

    千次阅读 2013-10-12 12:35:27
    * 使用循环数组带来了队列空队列满时front和rear相同的问题 * 解决方法一:定一个变量queue_size用来记录数据的长度 * * 解决方法二:使用循环数组不填满的技术,保持数组中始终有一个元素不使用,rear从比front小...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 24,761
精华内容 9,904
关键字:

c语言创建空队列

c语言 订阅