《数据结构与算法》栈和队列

原创 已于 2024-11-21 22:50:45 修改
· 717 阅读 · 25 ·
版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构

于 2024-10-09 16:32:04 首次发布

1 栈

1.1 栈的概念及结构

栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作，进行数据的插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的元素遵守后进先出LIFO（Last In First Out）的原则（类似于烤串，最后串上的肉最先吃到嘴里）。

压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。

出栈：栈的删除操作叫做出栈，出数据也在栈顶。

1.2 栈的实现 

栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些，因为数组在尾上插入数据的代价比较小。

1.2.1 栈的分类 

定长的静态栈

静态栈的结构一般不用，所以我们主要实现下面的支持动态增长的栈

typedef int STDataType;
#define N 10
typedef struct Stack
{
  STDataType_a[N];
  int _top; //栈顶
}ST;
支持动态增长的栈
typedef int STDataType;
typedef struct Stack
{
  STDataType* a;
  int top;
  int capacity;
}ST;

1.2.2 初始化栈

top指向的栈顶元素的下一个的初始化方式（下面功能实现使用此初始化方式）

void STInit(ST* ps)
{
  assert(ps);

  ps->a = NULL;
  ps->top = 0;    //top指向栈顶元素的下一个
  ps->capacity = 0;
}

 

top指向栈顶元素的初始化方式

void STInit(ST* ps)
{
  assert(ps);

  ps->a = NULL;
  ps->top = -1;    //top指向栈顶元素
  ps->capacity = 0;
}

1.2.3 销毁栈

void STDestroy(ST* ps)
{
  assert(ps);

  free(ps->a);
  ps->a = NULL;
  ps->top = ps->capacity = 0;
}

1.2.4 入栈 

void STPush(ST* ps, STAdataType x)
{
  assert(os);

  //满了，扩容
  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] = x;
  ps->top++;
}

1.2.5 检测栈是否为空

bool STEmpty(ST* ps)
{
  assert(ps);

  return ps->top == 0;
}

1.2.6 出栈

void STPop(ST* ps)
{
  assert(ps);
  assert(!STEmpty(ps));

 ps->top--;
}

1.2.7 获取栈顶元素

STDataType STTop(ST* ps)
{
  assert(ps);
  assert(!STEmpty(ps));

  return ps->a[ps->top-1];
}

1.2.8  获取栈中有效元素个数

int STSize(ST* ps)
{
  assert(ps);
  
  return ps->top;
}

1.3 整理栈代码

Stack.h

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

typedef int STDataType;
typedef struct Stack
{
  STDataType* a;
  int top;
  int capacity;
}ST;

//初始化栈
void STInit(ST* ps);
//销毁栈
void STDestroy(ST* ps);
//入栈
void STPush(ST* ps, STDataType x);
//检测栈是否为空
bool STEmpty(ST* ps);
//出栈
void STPop(ST* ps);
//获取栈顶元素
STDataType STTop(ST* ps);
//获取栈中有效元素个数
int STSize(ST* ps);

Stack.c

#include"Stack.h"

//初始化栈
void STInit(ST* ps)
{
  assert(ps);

  ps->a = NULL;
  ps->top = 0;    //top指向栈顶元素的下一个
  ps->capacity = 0;
}

//销毁栈
void STDestroy(ST* ps)
{
  assert(ps);

  free(ps->a);
  ps->a = NULL;
  ps->top = ps->capacity = 0;
}

//入栈
void STPush(ST* ps, STDataType x)
{
  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] = x;
  ps->top++;
}

//检测栈是否为空
bool STEmpty(ST* ps)
{
  assert(ps);

  return ps->top == 0;
}

//出栈
void STPop(ST* ps)
{
  assert(ps);
  assert(!STEmpty(ps));

 ps->top--;
} 

//获取栈顶元素
STDataType STTop(ST* ps)
{
  assert(ps);
  assert(!STEmpty(ps));

  return ps->a[ps->top-1];
}

//获取栈中有效元素个数
int STSize(ST* ps)
{
  assert(ps);
  
  return ps->top;
}

2 队列 

2.1 队列的概念及结构

队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO（First In First Out）的原则。

入队列：进行插入操作的一端称为队尾

出队列：进行删除操作的一端称为队头

2.2 队列的实现 

队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率会比较低。

2.2.1 链式结构表示队列 以及队列的结构

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


typedef struct Queue
{
  QNode* phead;
  QNode* ptail;
  int size;
}Queue;

这里定义了两个结构体，第二个结构体是根据我们的使用需求来进行定义的，这个结构体包含了指向链表头（队头）的指针和指向链表尾（队尾）的 指针，我们先前学习链表的时候不定义这个结构体，是因为在单链表实现功能的时候，多加一个指针也不能同时解决头插、头删、尾插、尾删等问题，干脆就简单一点。而在队列里，我们只需要解决尾插和头删，放成结构体我们就能同时解决这连个问题，还能让我们能在实现功能时不需要定义二级指针。这里的size可以记录我们队列的大小，在获取队列大小的时候直接返回size值即可，达到了用空间（很少）换取时间的效果。

2.2.2 初始化队列

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

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

2.2.3 销毁队列

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

  QNode* cur = pq->phead;
  while(cur)  //这里不能写成cur != ptail,这样会ptail指向的这个节点无法删除
  {
    QNode* next = cur->next;
    free(cur);
    cur = next;
  }

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

2.2.4 入队列

void QueuePush(Queue* pq, QDataType x)
{
  assert(pq);

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

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

  pq->size++;
}

2.2.5 出队列

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

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

思考：上面这段代码有什么问题吗？

●问题一：这里的没有考虑到队列中节点个数的问题，如果队列为空我们找phead的下一个节点就会崩溃；如果队列只有一个节点就会导致ptail变成空指针。在这里我们要分多种情况来讨论。

●问题二：没有对size进行size--，导致队列个数在出队列时出现错误。

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

  //0个节点
  assert(pq->phead != NULL);
  //1个节点
  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--;
}

2.2.6 获取队列头部元素

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

  return pq->phead->val;
}

2.2.7 获取队列尾部元素

QDataType QueueBack(Queue* pq)
{
  assert(pq);
  assert(pq->ptail != NULL);
  
  return pq->ptail->val;
}

2.2.8 检测队列是否为空

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

  return pq->phead == NULL;
}

2.2.9 获取队列中有效元素个数

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

  return pq->size;
}

2.3 整理队列代码

Queue.h

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

typedef int QDataType;
typedef struct QueueNode
{
  int val;
  struct QueueNode* next;
}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);

//检测队列是否为空
bool QueueEmpty(Queue* pq);

//获取队列中有效元素个数
int QueueSize(Queue* pq);

Queue.c

#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)  //这里不能写成cur != ptail,这样会ptail指向的这个节点无法删除
  {
    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->val = x;
  newnode->next = NULL;
 
  if(pq->ptail)
  {
    pq->ptail->next = newnode;
    pq->ptail = newnode;
  }
  else
  {
    pq->phead = pq->ptail = newnode;
  }

  pq->size++;
}

//出队列
void QueuePop(Queue* pq)
{
  assert(pq);

  //0个节点
  assert(pq->phead != NULL);
  //1个节点
  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 != NULL);

  return pq->phead->val;
}

//获取队列尾部元素
QDataType QueueBack(Queue* pq)
{
  assert(pq);
  assert(pq->ptail != NULL);
  
  return pq->ptail->val;
}

//检测队列是否为空
bool QueueEmpty(Queue* pq)
{
  assert(pq);

  return pq->phead == NULL;
}

//获取队列中有效元素个数
int QueueSize(Queue* pq)
{
  assert(pq);

  return pq->size;
}

2.4 环形队列

实际中我们有时还会使用一种队列叫循环队列。如操作系统课程讲解生产者消费者模型时就会使用到循环队列。环形队列可以使用数组实现，也可以使用循环链表实现。

为了能使用rear = front来区别时队空还是队满，我们常常认为出现右图时的情况即为队满的情况，此时：rear + 1 = front 

3 栈和队列相关问题

3.1 括号匹配问题

对于这道题我们需要解决两个问题：数量匹配问题和顺序匹配问题。

对此我们可以用栈来解决这个问题，即左括号入栈匹配，右括号出栈匹配。

 

以上代码虽然通过了，但是是否存在什么问题呢？

没错，内存泄漏了，因为只在代码的结尾对栈进行销毁，在右括号比左括号多和符号不匹配的两种情况是直接返回了，没有销毁栈。

正确代码如下

3.2 用队列实现栈

队列是先进先出，栈是后进先出

思路：保持一个队列存数据，一个队列为空

入数据：入到不为空的队列 

出数据：借助空队列倒数据即可

        

对于myStackCreate这个创建队列的函数

左图这样写是不对的，这里的st是函数内的变量，生命周期就只在这个函数中，出函数就释放掉了。我们应该如右图用malloc来创建。

 对于myStackFree这个销毁的函数

左图这样写是不对的，这里释放了obj，但是q1和q2中的链表队列并没有释放掉。我们应该如右图的方式来释放。

正确代码如下

3.3 用栈实现队列 

栈是后进先出, 队列是先进先出

思路：一个栈专门用来入数据，一个栈专门用来出数据，两个栈的性质是固定的

 

我们在入数据的时候不用把popst中的数据倒回到pushst中，这样在peek取队头元素的时候

效率会高很多，就不需要在pushst和popst之间来回倒数据了

代码如下

3.4 设计循环队列

这道题不推荐用链表去解决，我们使用链表的话有一下两种方式实现：

一  rear指向尾的下一个

这一种方式，我们不能够采用front == rear去对队列判空，需要借助size和k比较进行判断；在去取rear即取队尾元素的时候我们不好取，需要用到双向链表，这在实现过程中会比较繁琐。

二  rear指向的是尾

这一种方式，我们在队满的时候连续pop四次的话，最后一次pop就需要特殊处理rear才行；还有我们无法区分是零个数据还是只有一个数据，增加了实现的难度。

所以我们采用数组的方式去解决这道题

我们需要解决假溢出（无法区分一个是空是满）的问题，我们有两种解决方案：第一种就是多开一个空间，第二种就是用size。我们选择第一种实现

我们选择数组的方式实现就很容易实现链表比较难实现的rear取队尾元素的功能

代码如下

4 概念选择题 

第一题

一个栈的初始状态为空。现将元素1、2、3、4、5、A、B、C、D、E依次入栈，然后再依次出栈，则元素出栈的顺序是（ ）。
A 12345ABCDE    B EDCBA54321    C ABCDE12345    D 54321EDCBA

第二题

若进栈序列为 1,2,3,4 ，进栈过程中可以出栈，则下列不可能的一个出栈序列是（）
A 1,4,3,2    B 2,3,4,1    C 3,1,4,2    D 3,4,2,1

第三题 

循环队列的存储空间为 Q(1:100) ，初始状态为 front=rear=100 。经过一系列正常的入队与退队操作后， front=rear=99 ，则循环队列中的元素个数为（ ）
A 1    B 2    C 99    D 0或者100

第四题

4.以下( )不是队列的基本运算？
A 从队尾插入一个新元素    B 从队列中删除第i个元素
C 判断一个队列是否为空    D 读取队头元素的值

第五题

5.现有一循环队列，其队头指针为front，队尾指针为rear；循环队列长度为N。其队内有效长度为？(假设队头不存放数据)
A (rear - front + N) % N + 1
B (rear - front + N) % N
C ear - front) % (N + 1)
D (rear - front + N) % (N - 1)

答案

  1. B
  2. C
  3. D
  4. B
  5. B
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值