数据结构初阶(用C语言实现简单数据结构)--栈和队列

请添加图片描述

✨✨欢迎来到T_X_Parallel的博客!!
      ️博客主页:T_X_Parallel
      ️专栏 : 数据结构初阶
      ️欢迎关注:点赞收藏✍️留言

文章目录

  • 前言
  • 链表与栈和队列的关系
    • 1.栈
      • ✨栈的概念及结构
      • ✨栈的实现
    • 2.队列
      • ✨队列的概念及结构
      • ✨队列的实现
    • 3.相关oj题
      • 括号匹配问题
      • 设计循环队列
      • 用队列实现栈
      • 用栈实现队列
  • 总结


前言

这小猫真好看数据结构初阶(用C语言实现简单数据结构)--栈和队列_第1张图片
数据结构初阶(用C语言实现简单数据结构)--栈和队列_第2张图片

言归正传,通过上篇有关顺序表和链表的博客,可以了解到线性表的一些大致特征,这篇博客主要就是来了解线性表中的栈和队列。(如果没有看过本博主上篇有关链表的博客,可以先去看看上篇博客,对学习本篇博客会有一定的帮助)
<数据结构初阶(用C语言实现简单数据结构)-- 手搓顺序表、链表>

链表与栈和队列的关系

栈和队列是一种数据结构,而链表是一种存储数据的方式。栈和队列都可以用链表来实现。

栈使用后进先出(LIFO)的方式存储数据,即最后进入栈中的元素最先被取出。链表实现栈可以在链表头部插入元素和删除元素,这样最后进入的元素就位于链表头部,最先被取出。

队列使用先进先出(FIFO)的方式存储数据,即最先进入队列的元素最先被取出。链表实现队列可以在链表尾部插入元素,在链表头部删除元素,这样最先进入的元素就位于链表头部,最先被取出。

因此,链表可以用于实现堆栈和队列,使其具有相应的特性。

下面将对两种数据结构进行详细剖析


1.栈

✨栈的概念及结构

栈(Stack)是一种基本的数据结构,它是一种只能在一端进行插入和删除操作的线性表。栈的特点是LIFO(Last In First Out)即后进先出,也就是最后压入栈的元素最先弹出
栈有很多实际应用,包括函数调用、表达式求值、操作系统的进程调度、缓存等。

栈的两个基本操作是push(压栈)和pop(出栈)操作。
push操作将元素压入栈中,即向栈顶端插入元素;
pop操作将元素弹出栈外,即弹出栈顶端的元素。

数据结构初阶(用C语言实现简单数据结构)--栈和队列_第3张图片
下面的动图可以更直观的理解栈的出入栈
数据结构初阶(用C语言实现简单数据结构)--栈和队列_第4张图片
数据结构初阶(用C语言实现简单数据结构)--栈和队列_第5张图片

✨栈的实现

通常栈的实现有两种方式:数组和链表。数组实现栈需要指定栈的大小,当栈满了就不能再向栈中添加元素了。链表实现栈不需要事先指定栈的大小,可以动态地添加和移除节点。
数据结构初阶(用C语言实现简单数据结构)--栈和队列_第6张图片

在实现栈之前需要想想定义的结构体中需要哪些成员变量,再想想实现栈需要实现栈的哪些功能
首先是结构体的声明
数据结构初阶(用C语言实现简单数据结构)--栈和队列_第7张图片

从上面的声明来看,结构体中需要三个成员变量,其实和链表差不多。

接下来是栈的功能实现
栈的功能实现大致可以分为七个部分(初始化、入栈、出栈、判空、取栈顶元素、取有效元素个数、栈销毁)
数据结构初阶(用C语言实现简单数据结构)--栈和队列_第8张图片
上面是功能函数的声明,这样我们能在实现过程中清楚自己需要实现哪些功能函数

我相信只要C语言学的扎实(特别是结构体和指针部分)并且链表自己实现过,其实栈的实现都是小菜一碟,所以每个功能函数具体如何实现的我就不一一讲解,C语言学到这里我相信自己也有看懂代码的能力

下面是完整栈实现代码

//Stack.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 = (STDataType*)malloc(sizeof(STDataType) * 4);//动态开辟空间
    if (!tmp)//必要的检查
    {
        perror("malloc failed");
        return;
    }
    ps->a = tmp;
    ps->top = -1;
    ps->capacity = 4;
}

// 入栈 
void StackPush(Stack* ps, STDataType data)
{
    assert(ps);
    if (ps->top + 1 == ps->capacity)//如果空间不够需要扩容
    {
        ps->a = (STDataType*)realloc(ps->a, sizeof(STDataType) * (ps->capacity + 2));
        if (!ps->a)
        {
            perror("realloc failed");
            return;
        }
        ps->capacity += 2;
    }
    ps->top++;
    ps->a[ps->top] = data;
}

// 出栈 
void StackPop(Stack* ps)
{
    assert(ps);
    assert(!StackEmpty(ps));
    ps->top--;
}

// 获取栈顶元素 
STDataType StackTop(Stack* ps)
{
    assert(ps);
    assert(!STIsempty(ps));

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

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

// 检测栈是否为空,如果为空返回非零结果,如果不为空返回0 
int StackEmpty(Stack* ps)
{
    if (ps->top == -1)
        return 1;

    return 0;
}

// 销毁栈 
void StackDestroy(Stack* ps)
{
    assert(ps);
    free(ps->a);
    ps->a = NULL;
    ps->top = -1;
    ps->capacity = 0;
    ps = NULL;
}

注:上述代码没有引用必要头文件,如需使用请自行引用;上述代码采用声明与定义分离的方式实现的,且无main函数,如需使用请自行补充完整

接下来是一些关于实现中可能会遇到的问题

1️⃣在代码中,初始化时 top 变量的值可以被初始化为 0 或 -1,这两种方式都可以实现栈的初始化操作。但它们的细微差别仍然存在

✨当 top 被初始化为 0 时,栈中第一个元素实际上是存储在栈底下标为 0 的位置,此时栈的容量就是数组 stack 的长度。当一个元素被入栈时,top++ 表示栈顶指针向上移动一个位置,指向下一个可以存储元素的位置。当有元素被出栈时,top-- 表示栈顶指针向下移动一个位置,指向栈顶元素。

✨当 top 被初始化为 -1 时,栈中第一个元素实际上是存储在栈底下标为 0 的位置,且栈顶指针 top 的初始值为 -1。当一个元素被入栈时,由于 top++ 的作用,栈顶指针先向上移动一个位置变为 0,然后将元素存储在下标为 0 的位置上。当有元素被出栈时,首先将下标为 0 的元素弹出栈,然后将栈顶指针向下移动一个位置,变成 -1。

总的来说,这两种方式的主要区别在于栈底元素的位置不同,但它们的基本操作是一样的。

2️⃣在出栈操作中直接top–即可完成出栈操作

直接top–而不是先将top位置的元素置空再top–是因为要将top位置置空应该置为什么值(这是动态开辟的数组,不像链表,无法释放单个空间)

直接top–,是因为其他操作都是用top来访问元素,则top–就无法访问到原top位置的元素,间接的实现了出栈操作


2.队列

✨队列的概念及结构

队列是一种特殊的数据结构,它是一系列元素的有序集合,它的主要特点是新元素只能从一端(队尾)添加,已有元素只能从另一端(队头)删除。因此,队列是一种先进先出(FIFO)的数据结构。队列可以使用数组或链表实现。
队列可以用于多种场景,比如实现消息队列、任务队列、事件处理队列等。在计算机科学中,队列是非常重要的一种基础数据结构,它具有良好的性能和可扩展性,能够高效地处理大量数据。
数据结构初阶(用C语言实现简单数据结构)--栈和队列_第9张图片
数据结构初阶(用C语言实现简单数据结构)--栈和队列_第10张图片
从上面两张动图可直观地看出和了解队列的结构和先进先出的特点,为用C语言实现队列打下基础

✨队列的实现

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

队列常用的操作包括:
️ 入队:将新元素插入到队尾。
️ 出队:从队头删除一个元素。
️ 取队头:获取队头元素,但不删除。
️ 取队尾:获取队尾元素,但不删除。
️ 判空:判断队列是否为空。
️ 判满:判断队列是否已满。


数据结构初阶(用C语言实现简单数据结构)--栈和队列_第11张图片
上面是结构体和函数的声明,接下来是函数的定义

// 初始化队列 
void QueueInit(Queue* q)
{
    assert(q);
    q->head = q->tail = NULL;
    q->size = 0;
}

// 队尾入队列 
void QueuePush(Queue* q, QDataType data)
{
    assert(q);

    QNode* newnode = (QNode*)malloc(sizeof(QNode));
    if (!newnode)
    {
        perror("malloc failed");
        return;
    }
    newnode->next = NULL;
    newnode->val = data;
    if (q->head == NULL)
    {
        q->head = q->tail = newnode;
    }
    else
    {
        q->tail->next = newnode;
        q->tail = newnode;
    }
    q->size++;
}

// 队头出队列 
void QueuePop(Queue* q)
{
    assert(q);
    assert(!QueueEmpty(q));
    if (q->head->next == NULL)
    {
        free(q->head);
        q->head = q->tail = NULL;
    }
    else
    {
        QNode* next = q->head->next;
        free(q->head);
        q->head = next;
    }
    q->size--;
}

// 获取队列头部元素 
QDataType QueueFront(Queue* q)
{
    assert(q);
    assert(!QueueEmpty(q));

    return q->head->val;
}

// 获取队列队尾元素 
QDataType QueueBack(Queue* q)
{
    assert(q);
    assert(!QueueEmpty(q));

    return q->tail->val;
}

// 获取队列中有效元素个数 
int QueueSize(Queue* q)
{
    assert(q);
    return q->size;
}

// 检测队列是否为空,如果为空返回非零结果,如果非空返回0 
int QueueEmpty(Queue* q)
{
    assert(q);
    return QueueSize(q) == 0;
}

// 销毁队列 
void QueueDestroy(Queue* q)
{
    assert(q);
    QNode* cur = q->head;
    while (cur)
    {
        QNode* next = cur->next;
        free(cur);
        cur = next;
    }
    q->head = q->tail = NULL;
    q->size = 0;
}

回过头看,其实链表、栈和队列的实现差别不是很大,所以只要自己实现过链表,基本上栈和队列就都能实现出来

另外扩展了解一下,实际中我们有时还会使用一种队列叫循环队列。如操作系统课程讲解生产者消费者模型时可以就会使用循环队列。环形队列可以使用数组实现,也可以使用循环链表实现。下面会有循环队列实现的oj题


3.相关oj题

括号匹配问题


数据结构初阶(用C语言实现简单数据结构)--栈和队列_第12张图片

数据结构初阶(用C语言实现简单数据结构)--栈和队列_第13张图片
根据题目描述及上方动图解析可知:

有效括号字符串的长度,一定是偶数!
右括号前面,必须是相对应的左括号,才能抵消!
右括号前面,不是对应的左括号,那么该字符串,一定不是有效的括号!

具体答案可参考题解<题解>(做题一定要先自己想一想做一做再参考题解!!!

设计循环队列


数据结构初阶(用C语言实现简单数据结构)--栈和队列_第14张图片
实现循环队列有两种方法:数组和队列

方法一:数组
关于循环队列的概念可以参考:「循环队列」,我们可以通过一个数组进行模拟,通过操作数组的索引构建一个虚拟的首尾相连的环。在循环队列结构中,设置一个队尾rear与队首front,且大小固定,结构如下图所示:
数据结构初阶(用C语言实现简单数据结构)--栈和队列_第15张图片
数据结构初阶(用C语言实现简单数据结构)--栈和队列_第16张图片

时间复杂度:初始化和每项操作的时间复杂度均为 O(1)。
空间复杂度:O(k),其中 k 为给定的队列元素数目。

方法二:链表
我们同样可以用链表实现队列,用链表实现队列则较为简单,因为链表可以在 O(1) 时间复杂度完成插入与删除。入队列时,将新的元素插入到链表的尾部;出队列时,将链表的头节点返回,并将头节点指向下一个节点。

循环队列的属性如下:
head:链表的头节点,队列的头节点。
tail:链表的尾节点,队列的尾节点。
capacity:队列的容量,即队列可以存储的最大元素数量。
size:队列当前的元素的数量

时间复杂度:初始化和每项操作的时间复杂度均为 O(1)。
空间复杂度:O(k),其中 k 为给定的队列元素数目。

讲述了两种方法后,我们来看看两种方法的区别:

数据结构:循环队列用数组实现时,需要声明一个固定大小的数组来存储队列元素,而用链表实现时,则需要声明一个结构体来表示节点,并用指针来连接各个节点。

增删操作效率:在循环队列中,数组实现的增删操作效率较高,因为可以直接通过下标访问元素。而链表实现的增删操作效率较低,因为需要通过指针遍历整个链表来找到相应的节点。

具体答案可参考题解<题解>(做题一定要先自己想一想做一做再参考题解!!!

✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨

如果还没自己动手实现过栈和队列,那么可以自己写一下下面两道oj题,写完即可更深地理解栈和队列的结构及关系

用队列实现栈

用栈实现队列


总结

这差不多是本篇博客的尾声了,我浅浅地总结一下栈和队列

栈的优点:

  1. 栈具有后进先出(LIFO)的特性,可以方便地实现一些递归、回溯等算法。
  2. 栈具有一定的保护作用,可以避免某些数据被误操作或意外更改。
  3. 栈的实现简单,可以用数组或链表等数据结构实现。

栈的缺点:

  1. 栈只能在一端进行插入和删除操作,不适合于一些需要频繁的随机访问操作。

队列的优点:

  1. 队列具有先进先出(FIFO)的特性,在实现广度优先搜索等算法时非常方便。
  2. 队列的实现简单,也可以用数组或链表等数据结构实现。

队列的缺点:

  1. 队列在处理数据时必须按照顺序,无法跳过某些数据进行操作,不适合于一些需要频繁的随机访问操作。
  2. 在队列应用中,往往需要进行超时或阻塞操作,这增加了队列的实现难度。

栈与队列的区别:

  1. 存储方式:栈使用线性结构(数组或链表)存储数据,而队列使用线性结构(数组或链表)或链式结构存储数据。
  2. 操作方式:栈只能在一端进行插入和删除操作,而队列只能在两端进行插入和删除操作。
  3. 特性:栈具有后进先出(LIFO)的特性,而队列具有先进先出(FIFO)的特性。
  4. 应用场景:栈适用于递归、回溯等算法,以及在需要反转操作的情况下。队列适用于广度优先搜索、缓存队列等情况。

学完栈和队列基本上对线性表有了一定的认识和了解,接下来将要学的是堆(二叉树),小小剧透一下


最后再来一张美图,放松一下疲惫的眼睛
是心动的感觉

数据结构初阶(用C语言实现简单数据结构)--栈和队列_第17张图片
数据结构初阶(用C语言实现简单数据结构)--栈和队列_第18张图片


数据结构初阶(用C语言实现简单数据结构)--栈和队列_第19张图片

专栏:数据结构初阶
都看到这里了,留下你们的珍贵的点赞+⭐收藏+评论吧

你可能感兴趣的:(数据结构初阶,数据结构,c语言,leetcode)