AI 助理
备案控制台
开发者社区 云计算 文章 正文

数据结构：栈和队列的实现和图解二者相互实现

2023-10-13 143
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 数据结构：栈和队列的实现和图解二者相互实现

写在前面

栈和队列的实现依托的是顺序表和链表，如果对顺序表和链表不清楚是很难真正理解栈和队列的

下面为顺序表和链表的实现和图解讲解

手撕图解顺序表

手撕图解单链表

栈

什么是栈

栈是一种数据结构，遵循的原则是后入先出，简单来说就是先入栈的最后出，最后入栈的先出

栈在实际应用中也是有很多场景，例如在使用网页时，我们点入了多个网页，退出返回的时候遵循的就是栈的后入先出原则

栈的实现

既然知道了栈的原则，那么就进行栈的实现用什么比较好，首先确定是可以用线性表实现，观察栈的使用原则不难发现，它只涉及一端的输入输出，这就意味着使用顺序表是很好的解决方案

栈的功能也不算多，入栈出栈检查栈满查看栈顶元素…整体看，栈就是顺序表的变形，这里对栈的实现不进行过多补充，重点在于后面和队列的相互实现

首先列出栈的定义和栈要实现的部分，声明和定义分离是个好习惯

// stack.h
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>
// 支持动态增长的栈
typedef int STDataType;
typedef struct Stack
{
  STDataType* _a;
  int _top;   // 栈顶
  int _capacity;  // 容量 
}Stack;
// 初始化栈 
void StackInit(Stack* ps);
// 入栈 
void StackPush(Stack* ps, STDataType data);
// 出栈 
void StackPop(Stack* ps);
// 获取栈顶元素 
STDataType StackTop(Stack* ps);
// 获取栈中有效元素个数 
int StackSize(Stack* ps);
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
int StackEmpty(Stack* ps);
// 销毁栈 
void StackDestroy(Stack* ps);

下面是对栈的实现，几乎都是顺序表的基本操作，实现很简单

// stack.c
#include "stack.h"
void StackInit(Stack* ps)
{
  assert(ps);
  STDataType* tmp = NULL;
  int newcapacity = ps->_capacity == 0 ? 4 : ps->_capacity * 2;
  tmp = (STDataType*)realloc(ps->_a, sizeof(STDataType) * newcapacity);
  if (tmp == NULL)
  {
    perror("realloc fail");
    return;
  }
  ps->_capacity = newcapacity;
  ps->_a = tmp;
}
void StackPush(Stack* ps, STDataType data)
{
  assert(ps);
  if (ps->_capacity == ps->_top)
  {
    STDataType* tmp = NULL;
    int newcapacity = ps->_capacity == 0 ? 4:ps->_capacity * 2;
    tmp = (STDataType*)realloc(ps->_a,sizeof(STDataType)* newcapacity);
    if (tmp == NULL)
    {
      perror("realloc fail");
      return;
    }
    ps->_capacity = newcapacity;
    ps->_a = tmp;
  }
  ps->_a[ps->_top] = data;
  ps->_top++;
}
bool STEmpty(Stack* ps)
{
  assert(ps);
  return ps->_top == 0;
}
void StackPop(Stack* ps)
{
  assert(ps);
  assert(!STEmpty(ps));
  ps->_top--;
}
STDataType StackTop(Stack* ps)
{
  assert(ps);
  assert(!STEmpty(ps));
  return ps->_a[ps->_top-1];
}
int StackSize(Stack* ps)
{
  assert(ps);
  return ps->_top;
}
int StackEmpty(Stack* ps)
{
  assert(ps);
  if (0 == ps->_top)
    return 1;
  else
    return 0;
}
void StackDestroy(Stack* ps)
{
  assert(ps);
  ps->_capacity = 0;
  ps->_top = 0;
  free(ps->_a);
  ps->_a = NULL;
}

整体看，只要掌握了顺序表，栈的实现是很轻松的

队列

什么是队列

从名字来看，队列在日常生活中也经常遇到，不管在哪里都少不了排队的概念，而在有秩序的队列中，进队列都是从后面进队列，出队列都是从头出队列，这就类似于链表中的头删和尾插

那么队列的定义就有了，先进的先出，后进的后出，这就是队列的定义

队列实现还是和线性表有关，具体选顺序表还是链表要进行分析：

如果选用顺序表，顺序表的头删和尾插显然不如链表，你可能有这样的解决方案：我们可以选用数组下标当作头和尾，这样就能模拟头部少一个和尾部加一个，的确，这样可以解决，但是下一个问题是数组的长度并不好管控，如果想要完美的充分利用顺序表，就必须要使用循环数组，循环数组的下标并不好掌控，因此这里使用链表是很合适的选择

这里是关于循环数组的解析和模拟实现队列：

解析循环数组

队列的实现

// queue.h
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
typedef int QDataType;
typedef struct QueueNode
{
  struct QueueNode* next;
  QDataType data;
}QNode;
typedef struct Queue
{
  QNode* phead;
  QNode* ptail;
  int size;
}Queue;
void QueueInit(Queue* pq);
void QueueDestroy(Queue* pq);
void QueuePush(Queue* pq, QDataType x);
void QueuePop(Queue* pq);
QDataType QueueFront(Queue* pq);
QDataType QueueBack(Queue* pq);
int QueueSize(Queue* pq);
bool QueueEmpty(Queue* pq);

上述函数的声明具体实现如下：

// queue.c
#include "queue.h"
#include"Queue.h"
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\n");
    return;
  }
  newnode->data = x;
  newnode->next = NULL;
  if (pq->ptail == NULL)
  {
    assert(pq->phead == NULL);
    pq->phead = pq->ptail = newnode;
  }
  else
  {
    pq->ptail->next = newnode;
    pq->ptail = newnode;
  }
  pq->size++;
}
void QueuePop(Queue* pq)
{
  assert(pq);
  assert(!QueueEmpty(pq));
  // 1、一个节点
  // 2、多个节点
  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(!QueueEmpty(pq));
  return pq->phead->data;
}
QDataType QueueBack(Queue* pq)
{
  assert(pq);
  assert(!QueueEmpty(pq));
  return pq->ptail->data;
}
int QueueSize(Queue* pq)
{
  assert(pq);
  return pq->size;
}
bool QueueEmpty(Queue* pq)
{
  assert(pq);
  return pq->size == 0;
}

栈和队列本身是没有难度的，但是如果使用栈去实现队列，用队列去实现栈呢？

下面分析如何实现队列和栈的相互实现：

用队列实现栈

先看原理图：

代码实现也不算难，实现如下：

#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
typedef int QDataType;
typedef struct QueueNode
{
  struct QueueNode* next;
  QDataType data;
}QNode;
typedef struct Queue
{
  QNode* phead;
  QNode* ptail;
  int size;
}Queue;
#include "queue.h"
#include"Queue.h"
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\n");
    return;
  }
  newnode->data = x;
  newnode->next = NULL;
  if (pq->ptail == NULL)
  {
    assert(pq->phead == NULL);
    pq->phead = pq->ptail = newnode;
  }
  else
  {
    pq->ptail->next = newnode;
    pq->ptail = newnode;
  }
  pq->size++;
}
void QueuePop(Queue* pq)
{
  assert(pq);
  assert(!QueueEmpty(pq));
  // 1、一个节点
  // 2、多个节点
  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(!QueueEmpty(pq));
  return pq->phead->data;
}
QDataType QueueBack(Queue* pq)
{
  assert(pq);
  assert(!QueueEmpty(pq));
  return pq->ptail->data;
}
int QueueSize(Queue* pq)
{
  assert(pq);
  return pq->size;
}
bool QueueEmpty(Queue* pq)
{
  assert(pq);
  return pq->size == 0;
}
typedef struct Mystack
{
  Queue push;
  Queue pop;
}Mystack;
void MsInit(Mystack* ps)
{
  assert(ps);
  QueueInit(&(ps->push));
  QueueInit(&(ps->pop));
}
void MsPush(Mystack* ps,QDataType x)
{
  assert(ps);
  QueuePush(&(ps->push), x);
}
void MsPop(Mystack* ps)
{
  while (QueueSize(&(ps->push)) > 1)
  {
    QueuePush(&(ps->pop), QueueFront(&(ps->push)));
    QueuePop(&(ps->push));
  }
  QueuePop(&(ps->push));
  while (!QueueEmpty(&(ps->pop)))
  {
    QueuePush(&(ps->push), QueueFront(&(ps->pop)));
    QueuePop(&(ps->pop));
  }
}
QDataType MsTop(Mystack* ps)
{
  assert(ps);
  return ps->push.ptail->data;
}
bool MsEmpty(Mystack* ps)
{
  if (ps->push.size == 0)
    return true;
  return false;
}
int main()
{
  Mystack s;
  MsInit(&s);
  MsPush(&s, 1);
  MsPush(&s, 2);
  MsPush(&s, 3);
  MsPush(&s, 4);
  MsPush(&s, 5);
  while (!MsEmpty(&s))
  {
    printf("%d ", MsTop(&s));
    MsPop(&s);
  }
  return 0;
}

用栈模拟队列

和上面的比起来，栈来实现队列就有一些改变：

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>
// 支持动态增长的栈
typedef int STDataType;
typedef struct Stack
{
  STDataType* _a;
  int _top;   // 栈顶
  int _capacity;  // 容量 
}Stack;
void StackInit(Stack* ps)
{
  assert(ps);
  ps->_a = NULL;
  ps->_top = 0;
  ps->_capacity = 0;
}
void StackPush(Stack* ps, STDataType data)
{
  assert(ps);
  if (ps->_capacity == ps->_top)
  {
    STDataType* tmp = NULL;
    int newcapacity = ps->_capacity == 0 ? 4:ps->_capacity * 2;
    tmp = (STDataType*)realloc(ps->_a,sizeof(STDataType)* newcapacity);
    if (tmp == NULL)
    {
      perror("realloc fail");
      return;
    }
    ps->_capacity = newcapacity;
    ps->_a = tmp;
  }
  ps->_a[ps->_top] = data;
  ps->_top++;
}
bool STEmpty(Stack* ps)
{
  assert(ps);
  return ps->_top == 0;
}
void StackPop(Stack* ps)
{
  assert(ps);
  assert(!STEmpty(ps));
  ps->_top--;
}
STDataType StackTop(Stack* ps)
{
  assert(ps);
  assert(!STEmpty(ps));
  return ps->_a[ps->_top-1];
}
int StackSize(Stack* ps)
{
  assert(ps);
  return ps->_top;
}
int StackEmpty(Stack* ps)
{
  assert(ps);
  if (0 == ps->_top)
    return 1;
  else
    return 0;
}
void StackDestroy(Stack* ps)
{
  assert(ps);
  ps->_capacity = 0;
  ps->_top = 0;
  free(ps->_a);
  ps->_a = NULL;
}
typedef struct Myqueue
{
  Stack Push;
  Stack Pop;
}Myqueue;
void MqInit(Myqueue* pq)
{
  assert(pq);
  StackInit(&(pq->Push));
  StackInit(&(pq->Pop));
}
void MqPush(Myqueue* pq,STDataType x)
{
  assert(pq);
  StackPush(&(pq->Push), x);
}
void MqPop(Myqueue* pq)
{
  while (!StackEmpty(&(pq->Push)))
  {
    StackPush(&(pq->Pop), StackTop(&(pq->Push)));
    StackPop(&(pq->Push));
  }
  StackPop(&(pq->Pop));
  while (!StackEmpty(&(pq->Pop)))
  {
    StackPush(&(pq->Push), StackTop(&(pq->Pop)));
    StackPop(&(pq->Pop));
  }
}
STDataType MqTop(Myqueue* pq)
{
  // 把数据从push弄到pop
  while (!StackEmpty(&(pq->Push)))
  {
    StackPush(&(pq->Pop), StackTop(&(pq->Push)));
    StackPop(&(pq->Push));
  }
  STDataType ret = pq->Pop._a[pq->Pop._top-1];
  // 再把数据弄回去
  while (!StackEmpty(&(pq->Pop)))
  {
    StackPush(&(pq->Push), StackTop(&(pq->Pop)));
    StackPop(&(pq->Pop));
  }
  return ret;
}
int MqEmpty(Myqueue* pq)
{
  if (pq->Push._top == 0)
    return 1;
  return 0;
}
int main()
{
  Myqueue q;
  MqInit(&q);
  MqPush(&q, 1);
  MqPush(&q, 2);
  MqPush(&q, 3);
  MqPush(&q, 4);
  MqPush(&q, 5);
  while (!MqEmpty(&q))
  {
    printf("%d ", MqTop(&q));
    MqPop(&q);
  }
  return 0;
}

这样就可以直接实现了

整体来说，栈和队列的相互实现的意义不算很大，但是可以很好的更加深入的理解栈和队列的原理

关键词：
数据结构队列
数据结构栈队列
数据结构栈
数据结构栈和队列
海绵宝宝de派小星
目录
相关文章
大数据文摘
|
5月前
|
前端开发 Java
java实现队列数据结构代码详解
本文详细解析了Java中队列数据结构的实现，包括队列的基本概念、应用场景及代码实现。队列是一种遵循“先进先出”原则的线性结构，支持在队尾插入和队头删除操作。文章介绍了顺序队列与链式队列，并重点分析了循环队列的实现方式以解决溢出问题。通过具体代码示例（如`enqueue`入队和`dequeue`出队），展示了队列的操作逻辑，帮助读者深入理解其工作机制。
大数据文摘
150 1
hahaha无
|
3月前
|
编译器 C语言 C++
栈区的非法访问导致的死循环(x64)
这段内容主要分析了一段C语言代码在VS2022中形成死循环的原因，涉及栈区内存布局和数组越界问题。代码中`arr[15]`越界访问，修改了变量`i`的值，导致`for`循环条件始终为真，形成死循环。原因是VS2022栈区从低地址到高地址分配内存，`arr`数组与`i`相邻，`arr[15]`恰好覆盖`i`的地址。而在VS2019中，栈区先分配高地址再分配低地址，因此相同代码表现不同。这说明编译器对栈区内存分配顺序的实现差异会导致程序行为不一致，需避免数组越界以确保代码健壮性。
hahaha无
44 0
栈区的非法访问导致的死循环(x64)
游客beejssedmb2sq
|
3月前
232.用栈实现队列，225. 用队列实现栈
在232题中，通过两个栈（`stIn`和`stOut`）模拟队列的先入先出（FIFO）行为。`push`操作将元素压入`stIn`，`pop`和`peek`操作则通过将`stIn`的元素转移到`stOut`来实现队列的顺序访问。 225题则是利用单个队列（`que`）模拟栈的后入先出（LIFO）特性。通过多次调整队列头部元素的位置，确保弹出顺序符合栈的要求。`top`操作直接返回队列尾部元素，`empty`判断队列是否为空。 两题均仅使用基础数据结构操作，展示了栈与队列之间的转换逻辑。
游客beejssedmb2sq
62 0
RossyYan
|
8月前
|
存储 C语言 C++
【C++数据结构——栈与队列】顺序栈的基本运算（头歌实践教学平台习题）【合集】
本关任务：编写一个程序实现顺序栈的基本运算。开始你的任务吧，祝你成功！​ 相关知识 初始化栈 销毁栈 判断栈是否为空 进栈 出栈 取栈顶元素 1.初始化栈 概念：初始化栈是为栈的使用做准备，包括分配内存空间（如果是动态分配）和设置栈的初始状态。栈有顺序栈和链式栈两种常见形式。对于顺序栈，通常需要定义一个数组来存储栈元素，并设置一个变量来记录栈顶位置；对于链式栈，需要定义节点结构，包含数据域和指针域，同时初始化栈顶指针。 示例（顺序栈）： 以下是一个简单的顺序栈初始化示例，假设用C语言实现，栈中存储
RossyYan
331 77
蓝易云
|
7月前
|
算法 调度 C++
STL——栈和队列和优先队列
通过以上对栈、队列和优先队列的详细解释和示例，希望能帮助读者更好地理解和应用这些重要的数据结构。
蓝易云
150 11
羑悻的小杀马特
|
7月前
|
DataX
☀☀☀☀☀☀☀有关栈和队列应用的oj题讲解☼☼☼☼☼☼☼
### 简介 本文介绍了三种数据结构的实现方法：用两个队列实现栈、用两个栈实现队列以及设计循环队列。具体思路如下： 1. **用两个队列实现栈**： - 插入元素时，选择非空队列进行插入。 - 移除栈顶元素时，将非空队列中的元素依次转移到另一个队列，直到只剩下一个元素，然后弹出该元素。 - 判空条件为两个队列均为空。 2. **用两个栈实现队列**： - 插入元素时，选择非空栈进行插入。 - 移除队首元素时，将非空栈中的元素依次转移到另一个栈，再将这些元素重新放回原栈以保持顺序。 - 判空条件为两个栈均为空。
羑悻的小杀马特
102 14
RossyYan
|
8月前
|
存储 C++ 索引
【C++数据结构——栈与队列】环形队列的基本运算（头歌实践教学平台习题）【合集】
【数据结构——栈与队列】环形队列的基本运算（头歌实践教学平台习题）【合集】初始化队列、销毁队列、判断队列是否为空、进队列、出队列等。本关任务：编写一个程序实现环形队列的基本运算。(6)出队列序列:yzopq2*(5)依次进队列元素:opq2*(6)出队列序列:bcdef。(2)依次进队列元素:abc。(5)依次进队列元素:def。(2)依次进队列元素:xyz。开始你的任务吧，祝你成功！(4)出队一个元素a。(4)出队一个元素x。
RossyYan
236 13
【C++数据结构——栈与队列】环形队列的基本运算（头歌实践教学平台习题）【合集】
RossyYan
|
8月前
|
C++
【C++数据结构——栈和队列】括号配对（头歌实践教学平台习题）【合集】
【数据结构——栈和队列】括号配对（头歌实践教学平台习题）【合集】（1）遇到左括号：进栈Push()（2）遇到右括号：若栈顶元素为左括号，则出栈Pop()；否则返回false。（3）当遍历表达式结束，且栈为空时，则返回true，否则返回false。本关任务：编写一个程序利用栈判断左、右圆括号是否配对。为了完成本关任务，你需要掌握：栈对括号的处理。（1）遇到左括号：进栈Push()开始你的任务吧，祝你成功！测试输入：(()))
RossyYan
183 7
ephemerals__
|
10月前
|
C语言
【数据结构】栈和队列（c语言实现）（附源码）
本文介绍了栈和队列两种数据结构。栈是一种只能在一端进行插入和删除操作的线性表，遵循“先进后出”原则；队列则在一端插入、另一端删除，遵循“先进先出”原则。文章详细讲解了栈和队列的结构定义、方法声明及实现，并提供了完整的代码示例。栈和队列在实际应用中非常广泛，如二叉树的层序遍历和快速排序的非递归实现等。
ephemerals__
855 9
那年春天
|
10月前
|
存储 算法
非递归实现后序遍历时，如何避免栈溢出？
后序遍历的递归实现和非递归实现各有优缺点，在实际应用中需要根据具体的问题需求、二叉树的特点以及性能和空间的限制等因素来选择合适的实现方式。
那年春天
213 59

热门文章

最新文章

  • 1
    Redis数据库的五类核心数据结构详解
  • 2
    Redis核心数据结构与分布式锁实现详解
  • 3
    MySQL数据库索引的数据结构？
  • 4
    基于跳表数据结构的企业局域网监控异常连接实时检测 C++ 算法研究
  • 5
    企业上网监控系统中红黑树数据结构的 Python 算法实现与应用研究
  • 6
    公司员工泄密防护体系中跳表数据结构及其 Go 语言算法的应用研究
  • 7
    c++数据结构之顺序表
  • 8
    【算法与数据结构】关于代码运行时间复杂度的计算方法
  • 9
    【模板】栈
  • 10
    软考中的数据结构
  • 1
    【数据结构】遍历二叉树（递归思想）--＞赋源码
    106
  • 2
    【数据结构】二叉树顺序实现（大堆）--＞赋源码
    77
  • 3
    【数据结构】栈和队列--＞理解和实现（赋源码)
    67
  • 4
    【数据结构】双向带头（哨兵位）循环链表 —详细讲解（赋源码）
    173
  • 5
    【数据结构】单链表--＞详细讲解，后赋源码
    52
  • 6
    深入探索堆：Go语言中的高效数据结构
    143
  • 7
    揭秘MongoDB：这个神奇的建模技巧将如何彻底改变你的数据结构？
    95
  • 8
    PHP 数据结构的巅峰对决：在机器学习的舞台上，谁将主宰沉浮？
    85
  • 9
    揭秘C#.Net编程秘宝：结构体类型Struct，让你的数据结构秒变高效战斗机，编程界的新星就是你！
    419
  • 10
    栈溢出处理
    391

    • 相关课程

    更多
  • Go语言核心编程 - 数据结构和算法

    • 相关电子书

    更多
  • 如何使用Tair增强数据结构构建丰富在线实时场景
  • Apache Flink 流式应用中状态的数据结构定义升级
  • 低代码开发师（初级）实战教程
    • 下一篇
    蛋白质语言模型 ProGen：在实验室合成由 AI 预测的蛋白质