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

引言

在数据结构的学习中，栈（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;
}//leetcodetypedef 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);
}

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

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/837849.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

C++——超简单登录项目

C++——超简单登录项目

程序入口文件 #include <QtWidgets/QApplication> // 包含登录页面头文件 #include "DlgLogin.h"int main(int argc, char *argv[]) {QApplication a(argc, argv);// 程序入口// 调页面起来//DlgMain w;//w.show();// 换成登录页面DlgLogin w;w.show();return…
阅读更多...
QT状态机6-无目标切换

QT状态机6-无目标切换

一个切换也可以没有目标状态，一个没有目标状态的切换也可以像其他切换那样被触发。 其不同之处在于，当一个没有目标的切换被触发时，它不会引起任何的状态变化， 这样便可以让状态机在一个特定的状态时响应信号或者事件而不用离开这个状态。 回顾之前的学习，如下所示：当我…
阅读更多...
开源禅道zentao的使用

开源禅道zentao的使用

很不幸禅道因为漏洞被人进攻了&#xff0c;被迫研究。 1.安装 直接使用docker进行部署&#xff0c;这里有非常多门道。官网的镜像easysoft-zentao是属于docker安装&#xff0c;而idoop的镜像虽然也是docker安装&#xff0c;但是实际是使用官网linux一键安装的版本&#xff0c…
阅读更多...
一周学习总结：数组与链表

一周学习总结：数组与链表

学习内容&#xff1a;数组与链表、计算机网络知识 数组&#xff1a; 从数组的基础知识到相关应用 数组的基础知识&#xff1a;数组在内存中的存储、数组的相关操作&#xff08;获取与更新&#xff09;、数组的相关应用&#xff1a; 二分查找法⭐⭐⭐⭐⭐ ● 掌握左闭右闭的…
阅读更多...
2024第16届四川教育后勤装备展6月1日举办 欢迎参观

2024第16届四川教育后勤装备展6月1日举办 欢迎参观

2024第16届四川教育后勤装备展6月1日举办 欢迎参观 邀请函 主办单位&#xff1a; 中国西部教体融合博览会组委会 承办单位&#xff1a;重庆港华展览有限公司 博览会主题&#xff1a;责任教育 科教兴邦 组委会&#xff1a;交易会159交易会2351交易会9466 展会背景 成都…
阅读更多...
[报告购买] 2021新版知识付费行业报告-艾媒咨询,教育产品运营体系下，如何利用平台寻找私域流量的出路？

[报告购买] 2021新版知识付费行业报告-艾媒咨询,教育产品运营体系下，如何利用平台寻找私域流量的出路？

对教育机构来说&#xff0c;现在既是一个流量充沛的时代&#xff0c;又是一个流量稀缺的时代。互联网环境下&#xff0c;各平台流量数以亿计&#xff0c;为了获客&#xff0c;各教育品牌机构投放、冠名、代言、竞价已成常态化&#xff0c;公域平台的流量争夺如火如荼。 一轮一轮…
阅读更多...
Spring之bean的细节（创建方式、作用范围、生命周期）

Spring之bean的细节（创建方式、作用范围、生命周期）

在Spring框架中&#xff0c;Bean是一个非常重要的概念&#xff0c;它代表了应用程序中需要被管理的对象。关于Bean的细节&#xff0c;我们可以从创建方式、作用范围以及生命周期三个方面进行阐述。 创建方式 Spring支持以下三种方式创建Bean&#xff1a; 调用构造器创建Bean…
阅读更多...
Chatgpt教你使用Python开发iPhone风格计算器

Chatgpt教你使用Python开发iPhone风格计算器

上次使用Chatgpt写爬虫&#xff0c;虽然写出来的代码很多需要修改后才能运行&#xff0c;但Chatgpt提供的思路和框架都是没问题。 这次让Chatgpt写一写GUI程序&#xff0c;也就是你常看到的桌面图形程序。 由于第一次测试&#xff0c;就来个简单点的&#xff0c;用Python写用…
阅读更多...
GPU Burn测试指导

GPU Burn测试指导

工具下载链接&#xff1a; https://codeload.github.com/wilicc/gpu-burn/zip/master测试方法&#xff1a; 上传工具到操作系统下&#xff0c;解压缩工具&#xff0c;使用make命令完成编译&#xff08;确保cuda环境变量已经配置成功、 nvcc -v能显示结果&#xff09;。 如果安…
阅读更多...
文献速递：多模态深度学习在医疗中的应用--多模式婴儿脑分割技术：模糊引导深度学习

文献速递：多模态深度学习在医疗中的应用--多模式婴儿脑分割技术：模糊引导深度学习

Title 题目 Multimodal Infant Brain Segmentation by Fuzzy-informed Deep Learning 多模式婴儿脑分割技术&#xff1a;模糊引导深度学习 01 文献速递介绍 日益普及的非侵入式婴儿脑磁共振图像&#xff08;MRI&#xff09;为准确理解脑主要发展轨迹的动态性提供了机会&…
阅读更多...
树莓派|串口通信协议

树莓派|串口通信协议

1、串口通信原理 串口通讯(Serial Communication)&#xff0c;是指外设和计算机间&#xff0c;通过数据信号线、地线等&#xff0c;按位进行传输数据的一种通讯方式。串口是一种接口标准&#xff0c;它规定了接口的电气标准&#xff0c;没有规定接口插件电缆以及使用的协议。串…
阅读更多...
Flutter 中的 SwitchListTile 小部件：全面指南

Flutter 中的 SwitchListTile 小部件：全面指南

Flutter 中的 SwitchListTile 小部件&#xff1a;全面指南 在Flutter的Material组件库中&#xff0c;SwitchListTile是一个包含开关&#xff08;Switch&#xff09;的列表项&#xff0c;非常适合用来创建带有标题、副标题以及开关的列表项&#xff0c;常用于设置界面&#xff…
阅读更多...
图的遍历最小生成树问题

图的遍历最小生成树问题

遍历和最小生成树是图论中常见的问题。下面我将分别介绍如何在 Java 中实现图的遍历和最小生成树算法&#xff0c;包括深度优先搜索&#xff08;DFS&#xff09;、广度优先搜索&#xff08;BFS&#xff09;以及最小生成树算法之一的Prim算法。 1. 图的遍历 a. 深度优先搜索&a…
阅读更多...
“ModuleNotFoundError: No module named ‘selenium‘”报错如何解决

“ModuleNotFoundError: No module named ‘selenium‘”报错如何解决

接上节&#xff1a;测试平台开发之测试框架改造并发执行及结果隔离(1) 上节博客的末尾提到&#xff1a;在命令窗口执行python main.py 可是执行的时候遇到了如下报错&#xff1a; ERRORS _____________________________________________________________ ERROR collecting te…
阅读更多...
如何安全高效地进行4S店文件分发，保护核心资产？

如何安全高效地进行4S店文件分发，保护核心资产？

4S店与总部之间的文件分发是确保双方沟通顺畅、信息共享和决策支持的重要环节。4S店文件分发涉及到以下文件类型&#xff1a; 销售报告&#xff1a;4S店需要定期向总部提交销售报告&#xff0c;包括销售数量、销售额、市场份额等关键指标。 库存管理文件&#xff1a;包括车辆库…
阅读更多...
使用docker创建hadoop集群：Couldn‘t upload the file

使用docker创建hadoop集群：Couldn‘t upload the file

运行的环境; Windows10 Docker Desktopdocker-hadoop 出现的问题如下: 解决方法 https://github.com/big-data-europe/docker-hadoop/issues/98
阅读更多...
Unity Pixels Per Unit 与 Sprite Renderer Scale的逻辑关系，为什么平铺的Sprite Renderer会变形？

Unity Pixels Per Unit 与 Sprite Renderer Scale的逻辑关系，为什么平铺的Sprite Renderer会变形？

SpriteRenderer之前用的比较基础&#xff0c;没遇到过什么问题&#xff0c;这几天使用SpriteRenderer的平铺时发现平铺变形了&#xff0c;研究了一下&#xff0c;原来有这么多在逻辑在里面。 当我们导入图片选择Texture Type为Sprite时表示我们的图片用途是UI或者SpriteRendere…
阅读更多...
【go项目01_学习记录12】

【go项目01_学习记录12】

代码组织 1 代码结构2 重构与测试2.1 安装测试功能2.2 testify 的常用断言函数 3 表组测试 1 代码结构 所有的代码写在一个main.go文件里面&#xff0c;GO编译器也是可以正常执行的。但是当代码量很庞大时&#xff0c;很难进行维护。 Go Web 程序的代码组织 单文件——反模式…
阅读更多...
C语言笔记15

C语言笔记15

指针2 1.数组名的理解 int arr[ 10 ] { 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 }; int *p &arr[ 0 ];17391692786 arr是数组名&#xff0c;数组名是首元素地址&#xff0c;&arr[0]就是取出首元素的地址放在指针变量p中。 #include <stdio.h> int main()…
阅读更多...
基于GWO灰狼优化的CNN-GRU-Attention的时间序列回归预测matlab仿真

基于GWO灰狼优化的CNN-GRU-Attention的时间序列回归预测matlab仿真

目录 1.算法运行效果图预览 2.算法运行软件版本 3.部分核心程序 4.算法理论概述 4.1卷积神经网络&#xff08;CNN&#xff09;在时间序列中的应用 4.2 GRU网络 4.3 注意力机制&#xff08;Attention&#xff09; 4.4 GWO优化 5.算法完整程序工程 1.算法运行效果图预览…
阅读更多...
最新文章

Copyright @ 2022~2023