顺序队列和链式队列_顺序队列与链队列-优快云博客

文章介绍了队列的概念，强调其先进先出(FIFO)特性，并通过两种方式——顺序队列和链式队列——展示了如何在实际中表示和操作队列。顺序队列使用数组实现，通过队头和队尾的变量进行管理；链式队列则利用链表结构，方便插入和删除操作。文章还提供了相应的C语言实现代码示例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1.队列的概念 first int first out
队列是一种数据逻辑结构，要求先进先出(FIFO)
只要符合先进先出的逻辑，那么这种数据结构就叫做队列
队首：出队的时候，从队首位置出队
队尾：入队的时候，从队尾位置入队
2.如何表示队列--》queue
写法一：用顺序表来表示队列 --》顺序队列
struct 顺序队列的名字
{
//数组存放真实数据
int buf[50];
//定义变量标记队首位置
int queuehead;
//定义变量标记队尾位置
int queuetail;
}
分析：把数组最后一个有效成员的下标作为队尾比较合适
把数组下标为零的作为队首比较合适
写法二：用单链表表示队列 --》链式队列
struct 链式队列的名字
{
//存放真实数据
int data;
//指向队首位置的指针
struct 链式栈的名字 *queuehead;
//指向队尾位置的指针
struct 链式栈的名字 *queuetail;
//指向下一个结点的指针
struct 链式栈的名字 *next;
}

3.顺序队列的实现
队列的初始化
入队 --》就是把数据存放到队列里面(队尾的后面存放)
出队 --》把数据从队列中取出来,删除(队首的位置取出数据)
4.链式队列的实现

顺序队列实现思路一

#include "myhead.h"

//定义一个结构体来表示顺序队列
struct sequeue
{
	//存放真实的数据
	int buf[50];
	//定义变量标记队首位置
	int queuehead;
	//定义变量标记队尾位置
	int queuetail;
};

//队列的初始化
struct sequeue *queue_init()
{
	struct sequeue *queue=malloc(sizeof(struct sequeue));
	queue->queuehead=0;  //数组下标为0的永远作为队首
	queue->queuetail=-1;
	return queue;
}

//入队
int in_queue(struct sequeue *queue,int newdata)
{
	//更新队尾
	queue->queuetail++;
	queue->buf[queue->queuetail]=newdata;
	return 0;
}

//出队
int out_queue(struct sequeue *queue)
{
	int i;
	//先备份队首的数据
	int temp=queue->buf[queue->queuehead];
	//队首后面的元素往前挪动--》覆盖掉原来的队首元素
	for(i=0; i<queue->queuetail; i++)
		queue->buf[i]=queue->buf[i+1];
	//更新一下新的队尾
	queue->queuetail--;
	return temp;
}

int main()
{
	//初始化队列
	struct sequeue *myqueue=queue_init();
	
	//入队4个数据
	in_queue(myqueue,18);
	in_queue(myqueue,28);
	in_queue(myqueue,38);
	in_queue(myqueue,48);
	
	//出队4个数据
	for(int i=0; i<4; i++)
		printf("出队的数据是:%d\n",out_queue(myqueue));
}

顺序队列实现的思路二

#include "myhead.h"

//定义一个结构体来表示顺序队列
struct sequeue
{
	//存放真实的数据
	int buf[50];
	//定义变量标记队首位置
	int queuehead;
	//定义变量标记队尾位置
	int queuetail;
};

//队列的初始化
struct sequeue *queue_init()
{
	struct sequeue *queue=malloc(sizeof(struct sequeue));
	queue->queuehead=-1;  
	queue->queuetail=-1;
	return queue;
}

//入队
int in_queue(struct sequeue *queue,int newdata)
{
	//更新队尾
	queue->queuetail++;
	queue->buf[queue->queuetail]=newdata;
	return 0;
}

//出队
int out_queue(struct sequeue *queue)
{
	if(queue->queuehead==queue->queuetail)
	{
		printf("队首和队尾相遇，此时剩下最后一个数据!\n");
	}
	else 
	{
		//更新队首
		queue->queuehead++;
	}
	printf("队首目前的位置:%d\n",queue->queuehead);
	return queue->buf[queue->queuehead];
}

int main()
{
	//初始化队列
	struct sequeue *myqueue=queue_init();
	
	//入队4个数据
	in_queue(myqueue,18);
	in_queue(myqueue,28);
	in_queue(myqueue,38);
	in_queue(myqueue,48);
	
	//出队4个数据
	for(int i=0; i<5; i++)
		printf("出队的数据是:%d\n",out_queue(myqueue));
}

链式队列的实现

#include "myhead.h"

//定义结构体表示链式队列
struct listqueue
{
	int data;
	//定义指针标记队尾位置
	struct listqueue *queuetail;
	//定义指针标记队首位置
	struct listqueue *queuehead;
	struct listqueue *next;
};

//初始化
struct listqueue *queue_init()
{
	struct listqueue *queue=malloc(sizeof(struct listqueue));
	queue->queuetail=NULL;
	queue->queuehead=NULL;
	queue->next=NULL;
	return queue;
}

//入队
int in_queue(struct listqueue *queue,int newdata)
{
	//准备新节点
	struct listqueue *newnode=malloc(sizeof(struct listqueue));
	newnode->data=newdata;
	newnode->queuetail=NULL;
	newnode->queuehead=NULL;
	newnode->next=NULL;
	
	//寻找尾部
	struct listqueue *p=queue;
	while(p->next!=NULL)
		p=p->next;
	p->next=newnode;
	
	//更新队首和队尾
	queue->queuetail=newnode;
	queue->queuehead=queue->next;
	return 0;
}

//出队
int out_queue(struct listqueue *queue)
{
	if(queue->next==NULL)
	{
		printf("出队结束了!\n");
		return -1;
	}
	//备份队首元素
	int temp=queue->queuehead->data;
	
	//删除队首这个结点
	queue->next=queue->queuehead->next;
	queue->queuehead->next=NULL;
	free(queue->queuehead);
	
	//更新队首
	queue->queuehead=queue->next;
	return temp;
}

int main()
{
	//初始化
	struct listqueue *myqueue=queue_init();
	
	//入队4个数据
	in_queue(myqueue,18);
	in_queue(myqueue,28);
	in_queue(myqueue,38);
	in_queue(myqueue,48);
	
	//出队4个数据
	for(int i=0; i<5; i++)
		printf("出队的数据是:%d\n",out_queue(myqueue));
}

链式队列修正二

#include <stdio.h>
#include <stdlib.h>

// 定义队列节点结构
struct node
{
    int data;
    struct node *next;
};

// 定义链式队列结构
struct listqueue
{
    struct node *queuehead;
    struct node *queuetail;
};

// 初始化队列
struct listqueue *queue_init()
{
    struct listqueue *queue = malloc(sizeof(struct listqueue));
    if (queue == NULL) {
        return NULL; // 内存分配失败
    }
    queue->queuehead = NULL;
    queue->queuetail = NULL;
    return queue;
}

// 入队操作
int in_queue(struct listqueue *queue, int newdata)
{
    struct node *newnode = malloc(sizeof(struct node));
    if (newnode == NULL) {
        return -1; // 内存分配失败
    }
    newnode->data = newdata;
    newnode->next = NULL;
    
    if (queue->queuetail == NULL) {
        queue->queuehead = newnode;
        queue->queuetail = newnode;
    } else {
        queue->queuetail->next = newnode;
        queue->queuetail = newnode;
    }
    return 0;
}

// 出队操作
int out_queue(struct listqueue *queue)
{
    if (queue->queuehead == NULL)
    {
        printf("出队结束了!\n");
        return -1;
    }
    struct node *temp = queue->queuehead;
    int data = temp->data;
    queue->queuehead = queue->queuehead->next;
    
    if (queue->queuehead == NULL) {
        queue->queuetail = NULL;
    }
    free(temp);
    return data;
}

int main()
{
    // 初始化
    struct listqueue *myqueue = queue_init();
    if (myqueue == NULL) {
        printf("内存分配失败，队列初始化失败！\n");
        return -1;
    }
    
    // 入队4个数据
    in_queue(myqueue, 18);
    in_queue(myqueue, 28);
    in_queue(myqueue, 38);
    in_queue(myqueue, 48);
    
    // 出队5个数据
    for (int i = 0; i < 5; i++)
    {
        int result = out_queue(myqueue);
        if (result != -1) {
            printf("出队的数据是: %d\n", result);
        }
    }
    
    // 释放队列
    free(myqueue);
    return 0;
}