C语言中的循环队列与栈、队列之间的转换实现

已于 2024-05-14 19:47:44 修改
阅读量432 收藏 9
点赞数 11
文章标签： c语言 开发语言
于 2024-05-14 19:45:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79642159/article/details/138866529
版权

引言

在数据结构的学习中，栈（Stack）和队列（Queue）是两个非常重要的概念。它们分别遵循着后进先出（LIFO）和先进先出（FIFO）的原则。在某些情况下，我们可能需要通过栈来模拟队列，或者通过队列来模拟栈的行为。本文将详细介绍这两种数据结构，并提供相应的C语言实现代码和图解。

一、栈（Stack）

栈是一种后进先出（LIFO）的数据结构，只允许在一端进行操作，这一端被称为栈顶（top）。栈的基本操作包括入栈（push）和出栈（pop）。

C语言实现栈：

// 支持动态增长的栈
typedef int STDataType;
typedef struct Stack
{
	STDataType* _a;
	int _top;		// 栈顶
	int _capacity;  // 容量 
}Stack;

// 初始化栈 
void StackInit(Stack* ps)
{
	assert(ps);
	ps->_a = NULL;
	//top指向栈顶数据的下一个位置
	ps->_top = 0;
	//top指向栈顶数据
	//ps->_top = -1;
	ps->_capacity = 0;
}
// 入栈 
void StackPush(Stack* ps, STDataType data)
{
	assert(ps);
	if (ps->_top == ps->_capacity)
	{
		int newcapacity = ps->_capacity == 0 ? 4 : ps->_capacity * 2;
		STDataType* tmp = (STDataType*)realloc(ps->_a, newcapacity * (sizeof(STDataType)));
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		ps->_a = tmp;
		ps->_capacity = newcapacity;
	}
	ps->_a[ps->_top] = data;
	ps->_top++;
}
// 出栈 
void StackPop(Stack* ps)
{
	assert(ps);
	assert(ps->_top > 0);
	ps->_top--;
}
// 获取栈顶元素 
STDataType StackTop(Stack* ps)
{
	assert(ps);
	assert(ps->_top > 0);
	return ps->_a[ps->_top - 1];
}
// 获取栈中有效元素个数 
int StackSize(Stack* ps)
{
	assert(ps);
	return ps->_top;
}
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
int StackEmpty(Stack* ps)
{
	assert(ps);
	assert(ps);
	return ps->_top == 0;
}
// 销毁栈 
void StackDestroy(Stack* ps)
{
	assert(ps);
	free(ps->_a);
	ps->_a = NULL;
	ps->_top = ps->_capacity = 0;
}

栈的图解：

（可以想象一个竖直的容器，新元素从顶部加入，也是从顶部取出。）

二、队列（Queue）

队列是一种先进先出（FIFO）的数据结构，只允许在两端进行操作，一端为队头（front），另一端为队尾（rear）。队列的基本操作包括入队（enqueue）和出队（dequeue）。C语言实现队列：

#include <stdio.h>  
#include <stdlib.h>  
#define MAX_SIZE 100  
  
typedef struct 
{  
    int data[MAX_SIZE];  
    int front, rear;  
} Queue;  
  
void initQueue(Queue *q) 
{  
    q->front = q->rear = -1;  
}  
  
int isFull(Queue *q) 
{  
    return (q->rear + 1) % MAX_SIZE == q->front;  
}  
  
int isEmpty(Queue *q) 
{  
    return q->front == -1;  
}  
  
void enqueue(Queue *q, int value) 
{  
    if (!isFull(q)) 
    {  
        q->data[++q->rear] = value;  
    } 
    else 
    {  
        printf("Queue is full!\n");  
    }  
}  
  
int dequeue(Queue *q) 
{  
    if (!isEmpty(q)) 
    {  
        int value = q->data[q->front++];  
        if (q->front > q->rear) q->front = q->rear = -1; // 处理队列为空的情况  
        return value;  
    } else 
    {  
        printf("Queue is empty!\n");  
        return -1;  
    }  
}  
  
// ... 其他队列操作函数 ...

队列的图解：

（可以想象一个水平的容器，新元素从尾部加入，从头部取出。）

三、循环队列

循环队列是对普通队列的一种改进，通过取模运算实现队首和队尾的循环，从而更高效地利用存储空间。相当于队列头尾相接,同时容量固定.

（代码与上面的队列实现类似，主要区别在于isFull和isEmpty的判断，以及front和rear的更新方式。）

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

typedef struct
{
    int* a;
    int head; //指向头
    int tail; //指向尾下一个
    int k; //容量
} MyCircularQueue;


MyCircularQueue* myCircularQueueCreate(int k)
{
    MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    if (obj == NULL)
    {
        return;
    }
    
    //多开一个解决假溢出问题
    obj->a = (int*)malloc(sizeof(int)*(k + 1));
    obj->head = 0;
    obj->tail = 0;
    obj->k = k;
    return obj;
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) 
{
    return obj->head == obj->tail;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) 
{
    return (obj->tail + 1) % (obj->k + 1) == obj->head;
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) 
{
    if (myCircularQueueIsFull(obj))
    {
        return false;
    }
    obj->a[obj->tail] = value;
    obj->tail++;
    obj->tail %= (obj->k + 1);
    return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) 
{
    if (myCircularQueueIsEmpty(obj))
    {
        return false;
    }
    ++obj->head;
    obj->head %= (obj->k + 1);
    return true;
}

int myCircularQueueFront(MyCircularQueue* obj) 
{
    if (myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    else
    {
        return obj->a[obj->head];
    }
}

int myCircularQueueRear(MyCircularQueue* obj) 
{
    if (myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    else
    {
        return obj->a[(obj->tail + obj->k) % (obj->k + 1)];
    }
}

void myCircularQueueFree(MyCircularQueue* obj) 
{
    free(obj->a);
    free(obj);
}
四、栈实现队列

虽然栈是后进先出的数据结构，但我们可以通过两个栈（一个作为输入栈，一个作为输出栈）来模拟队列的先进先出特性。

代码实现：

（主要涉及两个栈的push和pop操作，以及如何在适当的时候交换两个栈的角色。）

// 支持动态增长的栈
typedef int STDataType;
typedef struct Stack
{
	STDataType* _a;
	int _top;		// 栈顶
	int _capacity;  // 容量 
}Stack;
// 初始化栈 
void StackInit(Stack* ps)
{
	assert(ps);
	ps->_a = NULL;
	//top指向栈顶数据的下一个位置
	ps->_top = 0;
	//top指向栈顶数据
	//ps->_top = -1;
	ps->_capacity = 0;
}
// 入栈 
void StackPush(Stack* ps, STDataType data)
{
	assert(ps);
	if (ps->_top == ps->_capacity)
	{
		int newcapacity = ps->_capacity == 0 ? 4 : ps->_capacity * 2;
		STDataType* tmp = (STDataType*)realloc(ps->_a, newcapacity * (sizeof(STDataType)));
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		ps->_a = tmp;
		ps->_capacity = newcapacity;
	}
	ps->_a[ps->_top] = data;
	ps->_top++;
}
// 出栈 
void StackPop(Stack* ps)
{
	assert(ps);
	assert(ps->_top > 0);
	ps->_top--;
}
// 获取栈顶元素 
STDataType StackTop(Stack* ps)
{
	assert(ps);
	assert(ps->_top > 0);
	return ps->_a[ps->_top - 1];
}
// 获取栈中有效元素个数 
int StackSize(Stack* ps)
{
	assert(ps);
	return ps->_top;
}
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
int StackEmpty(Stack* ps)
{
	assert(ps);
	assert(ps);
	return ps->_top == 0;
}
// 销毁栈 
void StackDestroy(Stack* ps)
{
	assert(ps);
	free(ps->_a);
	ps->_a = NULL;
	ps->_top = ps->_capacity = 0;
}

//leetcode

typedef struct 
{
	Stack pushst;
	Stack popst;
} MyQueue;


MyQueue* myQueueCreate() 
{
	MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue)); 
	if (obj == NULL)
	{
		return;
	}
	StackInit(&(obj->popst));
	StackInit(&(obj->pushst));
	return obj;
}

void myQueuePush(MyQueue* obj, int x) 
{
	StackPush(&(obj->pushst), x);
}

int myQueuePeek(MyQueue* obj) 
{
	if (StackEmpty(&(obj->popst)))
	{
		//倒数据
		while (!StackEmpty(&(obj->pushst)))
		{
			int top = StackTop(&(obj->pushst));
			StackPush(&(obj->popst), top);
			StackPop(&(obj->pushst));
		}
	}
	return StackTop(&(obj->popst));
}

int myQueuePop(MyQueue* obj) 
{
	int front = myQueuePeek(obj);
	StackPop(&(obj->popst));
	return front;
}

bool myQueueEmpty(MyQueue* obj) 
{
	return StackEmpty(&(obj->popst)) && StackEmpty(&(obj->pushst));
}

void myQueueFree(MyQueue* obj) 
{
	StackDestroy(&(obj->popst));
	StackDestroy(&(obj->pushst));
	free(obj);
}
五、队列实现栈

队列是先进先出的数据结构，但通过两个队列（或者一个队列和一个辅助栈）也可以模拟栈的后进先出特性。

代码实现：

typedef char QDataType;
typedef struct QueueNode
{
	struct QueueNode* next;
	QDataType val;
}QNode;

typedef struct Queue
{
	QNode* phead;
	QNode* ptail;
	int size;
}Queue;
void QueueInit(Queue* pq)
{
	assert(pq);
	pq->phead = NULL;
	pq->ptail = NULL;
	pq->size = 0;
}

void QueueDestroy(Queue* pq)
{
	assert(pq);

	QNode* cur = pq->phead;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);

		cur = next;
	}

	pq->phead = pq->ptail = NULL;
	pq->size = 0;
}

// 队尾插入
void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);

	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return;
	}

	newnode->next = NULL;
	newnode->val = x;

	if (pq->ptail == NULL)
	{
		pq->phead = pq->ptail = newnode;
	}
	else
	{
		pq->ptail->next = newnode;
		pq->ptail = newnode;
	}

	pq->size++;
}

// 队头删除
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(pq->size != 0);

	/*QNode* next = pq->phead->next;
	free(pq->phead);
	pq->phead = next;

	if (pq->phead == NULL)
		pq->ptail = NULL;*/

		// 一个节点
	if (pq->phead->next == NULL)
	{
		free(pq->phead);
		pq->phead = pq->ptail = NULL;
	}
	else // 多个节点
	{
		QNode* next = pq->phead->next;
		free(pq->phead);
		pq->phead = next;
	}

	pq->size--;
}

QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(pq->phead);

	return pq->phead->val;
}

QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(pq->ptail);

	return pq->ptail->val;
}


int QueueSize(Queue* pq)
{
	assert(pq);

	return pq->size;
}

bool QueueEmpty(Queue* pq)
{
	assert(pq);

	return pq->size == 0;
}
typedef struct
{
	Queue q1;
	Queue q2;
} MyStack;
//leetcode
MyStack* myStackCreate()
{
	MyStack* pst = (MyStack*)malloc(sizeof(MyStack));
	QueueInit(&(pst->q1));
	QueueInit(&(pst->q2));
	return pst;
}

void myStackPush(MyStack* obj, int x)
{
	if (!QueueEmpty(&(obj->q1)))
	{
		QueuePush(&(obj->q1), x);
	}
	else
	{
		QueuePush(&(obj->q2), x);
	}
}

int myStackPop(MyStack* obj)
{
	//假设法
	Queue* empty = &(obj->q1);
	Queue* nonempty = &(obj->q2);
	if (!QueueEmpty(&(obj->q1)))
	{
		nonempty = &(obj->q1);
		empty = &(obj->q2);
	}
	//不为空前size-1导走,删除最后一个就是栈顶数据
	while (QueueSize(nonempty) > 1)
	{
		QueuePush(empty, QueueFront(nonempty));
		QueuePop(nonempty);
	}
	int top = QueueFront(nonempty);
	QueuePop(nonempty);
	return top;
}

int myStackTop(MyStack* obj)
{
	if (!QueueEmpty(&(obj->q1)))
	{
		return QueueBack(&(obj->q1));
	}
	else
	{
		return QueueBack(&(obj->q2));
	}
}

bool myStackEmpty(MyStack* obj)
{
	return QueueEmpty(&(obj->q1)) && QueueEmpty(&(obj->q2));
}

void myStackFree(MyStack* obj)
{
	QueueDestroy(&(obj->q1));
	QueueDestroy(&(obj->q2));
	free(obj);
}

分享到这里,欢迎翻阅我的文章.

小志biubiu
关注
  • 11
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
队列fifo和lifo C语言数组实现
lala0903的博客
06-11 794
#define QUEUE_SIZE 20 typedef struct queue{ unsigned int array[QUEUE_SIZE]; /* 队列数组 */ int front; /* 队列首指针 */ int rear; /* 队列尾指针 */ unsigned int counter; /* 队列元素计数 */ } ARRAY_QUEUE_S; /* 数组下标小为前，大为后 0到1后移一位 1到0前移1位*/ /******************************
数据结构——堆栈和队列
02-06
总的来说，这个压缩包提供了关于数据结构——堆栈和队列的C语言实现，以及额外的数字转换和字符串处理功能。这些基础知识对于理解和编写高效的计算机程序至关重要。通过学习和理解这些内容，开发者能够更好地解决...
入门数据结构，c语言实现循环队列实现（详细篇）。
A2202333的博客
11-08 4964
队列中的一个分支循环队列，运用了一些技巧降低了其时间复杂度与空间复杂度，学会循环队列可以帮助更好的学习后面复杂的结构（如：树，二叉树，图等）。
数据结构：栈和队列(Stack & Queue)【详解】
热门推荐
UniqueUnit的博客
02-19 22万+
栈和队列知识框架 栈 一、栈的基本概念 1、栈的定义 栈（Stack）：是只允许在一端进行插入或删除的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除操作。 栈顶（Top）：线性表允许进行插入删除的那一端。 栈底（Bottom）：固定的，不允许进行插入和删除的另一端。 空栈：不含任何元素的空表。 栈又称为先进先出（Last In First Out）的线性表，简称LIFO结构 2、栈的基本操作 InitStack(&S)：初始化一个空栈S。 StackEmpty(S)：
《数据结构C语言版》——栈和队列详解(图文并茂)，从零开始的学习
青春无问西东 岁月自成芳华
04-20 4614
一文搞懂数据结构系列之栈和队列部分，从0基础到快速手敲数据结构，小白也能轻松看懂的宝典！
【栈和队列】C语言简单应用 ⌊栈和队列互相实现，循环队列⌉
qq_62852431的博客
04-19 2024
栈和队列简单应用
C语言使用栈和队列实现二进制与十进制的互转(带小数)
一碗单炒饭的专栏
12-29 3986
使用栈和队列的特性来实现进制转换 需要看普通C语言版的看这里 C语言实现二进制与十进制的互转(带小数) 全部代码 #include <stdio.h> #include <stdlib.h> #include <math.h> #define M 100 typedef long ElemType; // 栈 typedef struct { El...
C语言数据结构：栈和队列
qq_42319810的博客
07-02 1029
define MaxSzie 10 //定义栈中元素的最大个数//静态数组存放栈中元素int top;//栈顶指针}SqStack;//初始化栈S.top = -1;//初始化栈顶指针SqStack S;//声明一个顺序栈（分配空间）.....//判空操作else//数据域//指针域}*LiStack;//栈类型定义队列（Queue）是只允许在一端进行插入，在另一端删除的线性表重要术语：队头、队尾、空队列。
【数据结构与算法】栈与队列【C语言版】
胡毛毛的博客
10-23 2578
目录3.1 栈和队列的定义和特点3.2 栈、队列与一般线性表的区别3.3 栈的表示和操作的实现顺序栈与顺序表=================顺序栈的表示顺序栈初始化判断顺序栈是否为空求顺序栈的长度清空顺序栈销毁顺序栈顺序栈进栈顺序栈出栈取顺序栈栈顶元素==================链栈的表示链栈的初始化判断链栈是否为空链栈进栈链栈出栈取链栈栈顶元素3.4 　栈与递归以下三种情况常常用到递归方法1. 递归定义的数学函数:2. 具有递归特性的数据结构:3. 可递归求解的问题:递归算法的效率分析递归的优缺
C语言实现栈和队列【数据结构/初阶】
Man9o
04-22 2502
C语言实现栈和队列
duilie.rar_c循环队列
09-19
循环队列在C语言中的实现通常涉及到数组，并利用数组的特性形成一个看似无限循环的队列。以下是对"duilie.rar_c循环队列"相关知识点的详细解释。 首先，我们来理解循环队列的基本概念。循环队列是一种线性数据结构...
C语言从txt文件中逐行读入数据存到数组中的实现方法
08-31
在C语言中，从文本文件（如`.txt`文件）中读取数据并存储到数组是一种常见的操作。这里我们将详细探讨如何实现这个过程，特别是在处理包含二维数据的文件时。 首先，我们需要打开文件并检查是否成功打开。使用`...
循环队列生成杨辉三角
04-15
本代码使用循环队列来生成杨辉三角，通过循环队列的实现、杨辉三角的生成、QueueLength函数的实现、EnQueue和DeQueue函数的实现、print_n函数的实现和main函数的实现，展示了C语言的编程能力和数据结构的应用。
基于C语言的进制转换器.zip
06-15
C语言的基本语法包括变量、数据类型、运算符、控制结构（如if语句、循环语句等）、函数、指针等。在编写C程序时，需要注意变量的声明和定义、指针的使用、内存的分配与释放等问题。C语言中常用的数据结构包括： 1. ...
C基础day7
qq_55245263的博客
07-09 318
/二维数组输入i
java内部类的本质
qq_43593646的博客
07-12 445
可以定义一个类Pair，包括最大值和最小值，但Pair这个名字太普遍，而且它主要是类内部使用的，就可以定义为一个静态内部类。内部类访问了外部类的一个私有静态变量shared，而我们知道私有变量是不能被类外部访问的，Java的解决方法是：自动为Outer生成一个非私有访问方法access$0，它返回这个私有静态变量shared。外部类的一些方法的返回值可能是某个接口，为了返回这个接口，外部类方法可能使用内部类实现这个接口，这个内部类可以被设为private，对外完全隐藏。
html css js网页设计
最新发布
07-12
HTML、CSS和JavaScript是构建网页和网站的基本技术，它们共同工作来创建和设计用户界面。下面是关于这三种技术的详细介绍： ### HTML (HyperText Markup Language) - **定义**：HTML是构建网页内容的标准标记语言。 - **作用**：用于创建网页的结构和内容，如段落、链接、图片、表格等。 - **语法**：使用标签（如 `<p>`, `<div>`, `<a>`, `<img>` 等）来定义网页元素。 ### CSS (Cascading Style Sheets) - **定义**：CSS是一种样式表语言，用于描述HTML文档的呈现方式。 - **作用**：用于设置网页的布局、颜色、字体和其他视觉元素。 - **语法**：通过选择器（如 `p`, `.myclass`, `#myid` 等）应用样式规则。 ### JavaScript - **定义**：JavaScript是一种脚本语言，通常用于网页上实现交互功能。 - **作用**：允许网页与用户进行交互，如响应用户操作、动态更新内容、动画效果等。 - **语法**：Java
如何用C语言实现多级反馈队列调度算法
04-16
多级反馈队列调度算法（Multilevel Feedback Queue Scheduling Algorithm）是一种常见的进程调度算法。实现多级反馈队列调度算法的思路是：将进程分成若干级别，每个级别使用不同的时间片大小，优先级较高的进程使用较小的时间片，优先级较低的进程使用较大的时间片，同时，每个级别内部使用先进先出（FIFO）队列进行调度。 在C语言中实现多级反馈队列调度算法，需要定义进程结构体、就绪队列、运行队列等数据结构，同时，使用循环和条件语句实现进程调度的逻辑。具体实现过程包括以下步骤： 1. 定义进程结构体：包括进程名称、进程状态、优先级等属性。 2. 初始化多个就绪队列：根据设定的进程级别，初始化多个就绪队列。可以使用数组或链表等数据结构来存储就绪队列。 3. 将进程加入就绪队列：在进程创建或者进程状态转换时，将进程加入对应的就绪队列。 4. 实现调度函数：根据多级反馈队列调度算法的逻辑，实现调度函数，即选择优先级最高或等级最高的进程进行调度，如果进程未完成，则将该进程插入到合适的下一级就绪队列中，继续等待调度。 5. 实现时间片轮转：在进程使用时间片用完或者进程等待时间过长时，使用时间片轮转（Round-Robin）算法，将该进程插入到下一个就绪队列中，等待调度。 6. 实现进程挂起和恢复：在某些特定情况下，需要将进程挂起或恢复，例如I/O操作等。这个可以通过修改进程状态和队列中进程位置来实现。 总体来说，C语言实现多级反馈队列调度算法需要灵活运用数据结构和逻辑控制，正确处理进程状态和就绪队列，使得系统的进程调度可靠高效。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小志biubiu

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值