初学数据结构——从零开始的数据结构学习总结篇（栈和队列）

于 2023-05-05 02:07:42 发布
阅读量1.3k 收藏 11
点赞数 18
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lazy_chessplayer/article/details/130470402
版权
本文介绍了栈和队列这两种基础数据结构，包括它们的概念、逻辑结构、存储结构、运算规则以及在括号匹配和舞伴问题中的实际应用。栈遵循后进先出（LIFO）原则，常用于括号匹配等问题；队列遵循先进先出（FIFO）原则，适合解决顺序服务的问题，如舞伴配对。文章还详细讲解了栈和队列的顺序存储和链式存储的实现方式，并提供了相应的代码实现。
摘要由CSDN通过智能技术生成

前言

之前鸽了真的抱歉，肝了一段时间把栈和队列全部更完。

简介：

你有没有想过，为什么我们吃饭的时候，总是先吃掉最后放进嘴里的那一口？为什么我们排队的时候，总是先让最先来的人先走？这些生活中的现象，其实都和栈和队列的数据结构有关。

栈和队列是两种常见的数据结构，它们分别对应了后进先出（LIFO）和先进先出（FIFO）的原则。

栈就像是一叠盘子，你只能从最上面拿走或放上一个盘子，这个盘子就是栈顶。

队列就像是一条长龙，你只能从尾巴加入或从头部离开，这两个位置就是队尾和队首。

本文将向你大致介绍栈和队列的概念、特征和应用场景。

注：

本博客为本人在学习数据结构路途上的知识整理，如觉得对有你有所帮助，还希望不要吝啬你的赞，整理知识点是真的很累|*´Å`)ﾉ 。由于博主只是一名大一新生，在文章难免会出现错误，还希望指正。如果想要转载，附上链接就行。

本文中的颜色标记

  • 红色部分为重点内容
  • 蓝色部分为注释

目录

前言

简介：

注：

本文中的颜色标记

一、栈和队列的概念

栈

定义：

相关概念：

逻辑结构

存储结构

运算规则

实现方式

栈与一般线性表的区别

队列

定义：

相关概念

逻辑结构

存储结构

运算规则

实现方式

栈和队列的实际运用

栈的实际运用

队列的实际运用

 二、栈的表示和实现 

栈的抽象数据类型定义

栈的基本操作

注意事项

栈的顺序实现

使用数组作为顺序栈存储方式的特点：

存储方式：

栈的状态表示

顺序栈的代码实现

栈的链式存储实现

使用链表作为顺序栈存储方式的特点：

存储方式：

链栈的代码实现

三、队列的实现和操作

队列的抽象数据类型定义

基本操作：

 队列的顺序存储方式实现

存储方式：

状态：

顺序队的代码实现

循环队列

队列的链式存储方式 

存储方式

代码实现

 

总结

一、栈和队列的概念

栈

定义：

  • 栈（stack）是一个特殊的线性表，是限定仅在一端（通常是表尾）
    进行插入和删除操作的线性表。
  • 又称为后进先出(Last In First Out) 的线性表,简称LIFO结构

相关概念：

  • 表尾（即an端）称为栈顶Top
  • 表头（即a1端）称为栈底Base

例如：栈S=(a1,a2,a3...,an1,an)a1称为栈底元素,an称为栈顶元素

  • 插入元素到栈顶（即表尾）的操作，称为入栈(PUSH)
  • 从栈顶(即表尾)删除最后一个元素的操作，称为出栈(POP) 

栈只能在栈顶进行插入和删除的操作，只能在an-1尾部进行插入，插入an之后，只能先删除an然后再删除an-1 

逻辑结构

 与同线性表相同，仍为一对一关系。

存储结构

用顺序栈或链栈存储均可，但以顺序栈更常见

运算规则

只能在栈顶运算，且访问结点时依照后进先出（LIFO）的原则。

实现方式

关键是编写入栈和出栈函数，具体实现依顺序栈或链栈的不同而不同

栈与一般线性表的区别

  • 仅在于运算规则不同

队列

定义：

  • 队列（queue）是一种在表一端插入（表尾），在另一端（表头）删除的线性表。
  • 又称为先进先出（FristInFristOut）的线性表，简称FIFO结构。

相关概念

  • 表尾（即an端）称为队尾
  • 表头（即a1端）称为队首
  • 插入元素到队尾（即表尾）的操作，称为入队(PUSH)
  • 从队首(即表头)删除第一个元素的操作，称为出队(POP) 

逻辑结构

与同线性表相同，仍为一对一关系。

存储结构

顺序队或链队，以循环顺序队列更常见。

运算规则

只能在队首和队尾运算，直访问结点时依照先进先出（FIFO）的原则

实现方式

关键是掌握入队和出队操作，具体实现依顺序队或链队的不同而不同

栈和队列的实际运用

栈的实际运用

给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。

有效字符串需满足：

  1. 左括号必须用相同类型的右括号闭合。
  2. 左括号必须以正确的顺序闭合。
  3. 每个右括号都有一个对应的相同类型的左括号。

示例 1：

输入：s = "()"
输出：true

示例 2：

输入：s = "()[]{}"
输出：true

示例 3：

输入：s = "(]"
输出：false

解题步骤：

①将s依次栈入栈

②将s栈入的时候进行判段，为左括号直接栈入

③如果为右括号，判断是否与栈顶匹配，匹配则将栈顶栈出

④如果右括号与栈顶不匹配，则为非有效的括号，直接结束函数。

​

队列的实际运用

舞伴问题

假设在舞会上，男士和女士各自排成一队。舞会开始依次从男队和女队的队头各出一人配成舞伴。如果两队初始人数不相同，则较长的那一队中未配对者等待下一轮舞曲。现要求写一算法模拟上述舞伴配对问题。

显然，先入队的男士或女士先出队配成舞伴。因此该问题具有典型的先进先出特性，可以用队列作为算法的数据结构。

①首先构造两个队列

②依次将队头元素出队配成舞伴

③某队为空，则另外一队等待着则是下一舞曲第一个
可获得舞伴的人。

​

 二、栈的表示和实现 

栈的抽象数据类型定义

ADT Stack {

数据对象：

D= (ai /ai EElemSet, i=1,2..,n, n≥0)

数据关系：

R1={ <ai-1,ai> | ai-1,ai ∈D,i=2...,n}

约定an端为栈顶，a1端为栈底。

基本操作：初始化、进栈、出栈、取栈顶元素等

} ADT Stack

栈的基本操作

InitStack(&S)
初始化操作
操作结果：构造一个空栈S

DestroyStack(&S)
销毁栈操作
初始条件：栈S已存在。
操作结果：栈S被销毁。

StackEmpty(S)判定S是否为空栈
初始条件：栈S已存在。
操作结果：若栈S为空栈，则返回TRUE，否则返回FALSE

StackLength(S)
求栈的长度
初始条件：栈S


初始条件：栈S已存在且非空
操作结果：用e返回S的栈顶元素。

ClearStack(&S)
栈置空操作
初始条件：栈S已存在
操作结果：将S清为空栈

Push(&S,e)
入栈操作
初始条件：栈S已存在
操作结果：插入元素e为新的栈顶元素。

Pop(&S &e)
出栈操作
初始条件：栈S已存在且非空。
操作结果：删除S的栈顶元素an，并用e返回其值。

注意事项

  • 这里传参e来获取返回值只是伪代码方便，后面使用C语言写也使用e来得到返回值只是为了和伪代码相符，可以直接将结果return。

栈的顺序实现

由于栈本身就是线性表，于是栈也有顺序存储和链式存储两种实现方式。

  • 栈的顺序存储-顺序栈

  • 栈的链式存储-链栈

使用数组作为顺序栈存储方式的特点：

  • 简单方便、但易产生溢出（数组大小固定）

  • 上溢(stack overflow)：栈已经满，又要压入元素

  • 下溢(stack underflow)：栈已经空，还要弹出元素 注：上溢是一种错误，使问题的处理无法进行；而下溢一般认为是一种结束条件，即问题处理结束。

存储方式：

同一般线性表的顺序存储结构完全相同利用一组地址连续的存储单元依次存放自栈底到栈顶的数据元素。栈底一般在低地址端

  • 图示

    设top指针，指示栈顶元素在顺序栈中的位置

  • 设base指针，指示栈底元素在顺序栈中的位置

  • 为了方便操作，通常top指示真正的栈顶元素之上的下标地址

  • 用stacksize表示栈可使用的最大容量

栈的状态表示

  • 栈空：base==top
  • 栈满：top-base==stacksize

顺序栈的代码实现

  • 创建链栈
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

typedef int ElemType;      // 定义栈元素的数据类型

typedef struct
{
    ElemType data;         // 数据域
    LinkStack next;
}StackNode, *LinkStack;    // 定义链栈栈的类型
  • 初始化操作 InitStack(&S)
void InitStack(SqStack* S)
{
    S->base = (ElemType*)malloc(MAXSIZE * sizeof(ElemType));  // 分配存储空间
    if (!S->base)  // 分配失败
    {
        exit(1);
    }
    S->top = S->base;   // 栈顶和栈底指针初始指向同一位置
    S->stacksize = MAXSIZE;   // 栈的最大容量
}
  • 销毁栈操作 DestroyStack(&S)
void DestroyStack(SqStack* S)
{
    free(S->base);   // 释放存储空间
    S->base = S->top = NULL;   // 将栈底和栈顶指针置为NULL
    S->stacksize = 0;   // 当前栈的容量为0
}
  • 判定S是否为空栈 StackEmpty(S)
bool StackEmpty(SqStack S)
{
    if (S.top == S.base)  // 栈顶和栈底指针相同时，即栈为空
        return true;   // 返回TRUE
    else
        return false;   // 返回FALSE
}
  • 求栈的长度 StackLength(S)
int StackLength(SqStack S)
{
    return (S.top - S.base);  // 栈顶指针减去栈底指针就是栈的长度
}
  • 栈置空操作 ClearStack(&S)
oid ClearStack(SqStack* S)
{
    S->top = S->base;   // 将栈顶和栈底指针指向同一位置
}
  • 取栈顶元素操作 GetTop(&S,&e)
bool GetTop(SqStack S, ElemType* e)
{
    if (S.top == S.base) // 栈为空时，返回FALSE
        return false;
    *e = *(S.top - 1);   // 栈顶元素的值赋给e
    return true;
}
  • 入栈操作 Push(&S,e)
void Push(SqStack* S, ElemType e)
{
    if (S->top - S->base == S->stacksize) // 栈满时，扩充存储空间
    {
        S->base = (ElemType*)realloc(S->base, (S->stacksize + MAXSIZE) * sizeof(ElemType));
        if (!S->base)
        {
            exit(1);
        }
        S->top = S->base + S->stacksize; // 栈底指针不变，栈顶指针指向新的位置
        S->stacksize += MAXSIZE;         // 栈的最大容量增加 MAXSIZE
    }
    *(S->top++) = e;  // 元素 e 入栈，栈顶指针加1
}
  • 出栈操作 Pop(&S)
bool Pop(SqStack* S)
{
    if (S->top == S->base) // 栈为空时，返回FALSE
    {
        return false;
    }
    S--;
    return true;
}

栈的链式存储实现

  • 链栈是运算受限的单链表，只能在链表头部进行操作

使用链表作为顺序栈存储方式的特点：

  • 链表的头指针就是栈顶
  • 不需要头结点
  • 基本不存在栈满的情况
  • 空栈相当于头指针指向空
  • 插入和删除仅在栈顶处执行

存储方式：

  • 利用尾插法在单链表中存储
  • 头指针指向链表尾部（栈顶）

 

链栈的代码实现

  •  创建顺序栈
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

typedef int ElemType;   // 定义栈元素的数据类型

typedef struct StackNode
{
    ElemType data;         // 数据域
    struct StackNode* next;   // 指向下一个结点的指针
} StackNode, * LinkStack;     // 定义链栈栈的类型
  • 初始化操作 InitStack(&S)
void InitStack(LinkStack* S)
{
    *S = NULL;   // 初始化栈顶指针为空
}
  • 销毁栈操作 DestroyStack(&S)
void ClearStack(LinkStack* S)
{
    StackNode* p;
    while (*S != NULL)
    {
        p = *S;     // 指向栈顶结点
        *S = (*S)->next;   // 栈顶指针指向下一个结点
        free(p);    // 释放当前结点的内存空间
    }
}
  • 判定S是否为空栈 StackEmpty(S)
bool StackEmpty(LinkStack S)
{
    if (S == NULL)   // 栈顶指针为空时，即栈为空
        return true;
    else
        return false;
}
  • 求栈的长度 StackLength(S)
int StackLength(LinkStack S)
{
    int len = 0;      // 栈的长度
    while (S != NULL)
    {
        S = S->next;  // 栈顶指针向下移动
        len++;       // 栈的长度加1
    }
    return len;
}
  • 取栈顶元素操作 GetTop(&S,&e)
bool GetTop(LinkStack S, ElemType* e)
{
    if (S == NULL) // 栈为空时，返回FALSE
        return false;
    *e = S->data;   // 栈顶元素的值赋给e
    return true;
}
  • 入栈操作 Push(&S,e)
void Push(LinkStack* S, ElemType e)
{
    StackNode* p;
    p = (StackNode*)malloc(sizeof(StackNode));  // 创建新结点
    if (!p)   // 分配内存失败
    {
        exit(1);
    }
    p->data = e;     // 将元素e赋值给新结点的数据域
    p->next = *S;    // 新结点的next指针指向原栈顶指针指向的结点
    *S = p;          // 修改栈顶指针指向新的结点
}
  • 出栈操作 Pop(&S &e)
bool Pop(LinkStack* S)
{
    StackNode* p;
    if (*S == NULL) // 栈为空时，返回FALSE
        return false;
    p = *S;         // p指向栈顶结点
    *S = p->next;   // 栈顶指针指向下一个结点
    free(p);        // 释放当前结点的内存空间
    return true;
}

三、队列的实现和操作

队列的抽象数据类型定义

ADT Queuel {
数据对象：D={ai | ai∈ElemSet,=1,2,...,n≥0}
数据关系：R={<ai-1,ai> | ai-1,aI∈D,=2..,n) 约定a1端为队列头，an端为队列尾。
基本操作：初始化、入队、出队、将队列置空、遍历队列等操作...
} ADT Queue

基本操作：

InitQueue(&Q)
操作结果：构造空队列Q

DestroyQueue(&Q)
条件：队列Q已存在
操作结果：队列Q被销毁

ClearQueue(&Q)
条件：队列Q已存在
操作结果：将Q清空

QueueLength(Q）
条件：队列Q已存在
操作结果：返回Q的元素个数，即队长

GetHead(Q,&e)
条件：Q为非空队列
操作结果：用e返回Q的队头元素

EnQueue(&Q,e)
条件：队列Q已存在
操作结果：插入元素e为Q的队尾元素

DeQueue(&Q,&e)
条件：Q为非空队列
操作结果：删除Q的队头元素，用e返回值

 队列的顺序存储方式实现

存储方式：

同一般线性表的顺序存储结构完全相同利用一组地址连续的存储单元依次存放自队列头到队尾的数据元素。队尾一般在低地址端

图示

  • 设front指针，指示队头元素在顺序栈中的位置

  • 设rear指针，指示队尾元素在顺序栈中的位置

状态：

  • front==rear表示队空
  • rear=QLength（队列长度）表示队满

顺序队的代码实现

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

#define MAX_SIZE 100 // 队列的最大长度

typedef int ElemType; // 定义队列元素的数据类型

typedef struct
{
    ElemType* data; // 存储队列元素的数组
    int front; // 队头指针，指向队头元素
    int rear; // 队尾指针，指向队尾元素的下一个位置
} SqQueue;

// 构造空队列Q
void InitQueue(SqQueue* Q)
{
    Q->data = (ElemType*)malloc(MAX_SIZE * sizeof(ElemType)); // 动态分配数组空间
    Q->front = Q->rear = 0; // 初始化队头和队尾指针
}

// 队列Q销毁
void DestroyQueue(SqQueue* Q)
{
    free(Q->data); // 释放队列的数组空间
    Q->data = NULL; //将指针置空
    Q->front = Q->rear = 0; // 初始化队头和队尾指针
}

// 将队列Q清空
void ClearQueue(SqQueue* Q)
{
    Q->front = Q->rear = 0; // 将队头和队尾指针置为0，表示队列为空
}

// 返回队列Q的元素个数，即队列的长度
int QueueLength(SqQueue Q)
{
    return Q.rear - Q.front;
}

// 用e返回队列Q的队头元素
bool GetHead(SqQueue Q, ElemType* e)
{
    if (Q.front == Q.rear) // 队列为空，无法取出队头元素
    {
        return false;
    }
    *e = Q.data[Q.front]; // 将队头元素赋值给e
    return true;
}

// 插入元素e为队列Q的队尾元素
bool EnQueue(SqQueue* Q, ElemType e)
{
    if ((Q->rear + 1) % MAX_SIZE == Q->front) // 队列已满，插入失败
    {
        return false;
    }
    Q->data[Q->rear] = e; // 将元素e插入队尾
    Q->rear++; // 更新队尾指针
    return true;
}

// 删除队列Q的队头元素，并用e返回值
bool DeQueue(SqQueue* Q, ElemType* e)
{
    if (Q->front == Q->rear) // 队列为空，删除失败
    {
        return false;
    }
    *e = Q->data[Q->front]; // 将队头元素赋值给e
    Q->front++; // 更新队头指针
    return true;
}

循环队列

如果仔细观察上面的代码，不难发一个问题：

当我门进行出队操作时，front+1后之前的空间便无法利用，如果此时队满了，出现上溢情况，但实际数组中却还有空间无法被我们使用，我们把这种情况称为假上溢。

假上溢会极大地浪费我们的内存空间，我们该如何解决这个问题呢？

解决假上溢的方法

  1. 将队中元素依次向队头方向移动。缺点：浪费时间每移动一次，队中元素都要移动
  2. 将队空间设想成一个循环的表，即分配给队列的n个存储单元可以循环使用，当rear为maxqsize时，若数组的开始端空着，从头开始使用空着的空间。

  • base[0]接在base[MAXQSiZE-1]之后，若rear+1==M，则令rear=0

实现方法：利用模（%）运算。

  • 插入元素：
    Q.base[Q.rear]=x;
    Q.rear=(Q.rear+1)% MAXQSIZE;
  • 删除元素：
    X=Q.base[s.front];
    Q.front=(Q.front+1)%MAXQSIZE;

不难发现，循环队列中队空为：rear==front，队满也为rear==front，该如判断队空队满？

  1. 另外设一个标志以区别队空、队满
  2. 另设一个变量，记录元素个数
  3. 少用一个先素空间 

  • 队空：rear==front
  • 队满：(rear+1)%MAXQSIXZE==front

代码实现：

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

#define MAX_SIZE 100 // 循环队列的最大长度

typedef int ElemType; // 定义队列元素的数据类型

typedef struct
{
    ElemType* data; // 存储队列元素的数组
    int front; // 队头指针，指向队头元素
    int rear; // 队尾指针，指向队尾元素的下一个位置
    int size; // 队列元素个数
} SqQueue;

// 构造空队列Q
void InitQueue(SqQueue* Q)
{
    Q->data = (ElemType*)malloc(MAX_SIZE * sizeof(ElemType)); // 动态分配数组空间
    Q->front = Q->rear = 0; // 初始化队头和队尾指针
    Q->size = 0; // 初始化队列元素个数
}

// 队列Q销毁
void DestroyQueue(SqQueue* Q)
{
    free(Q->data); // 释放队列的数组空间
    Q->data = NULL; //将指针置空
    Q->front = Q->rear = 0; // 初始化队头和队尾指针
    Q->size = 0; // 将队列元素个数置为0，表示队列为空
}

// 将队列Q清空
void ClearQueue(SqQueue* Q)
{
    Q->front = Q->rear = 0; // 将队头和队尾指针置为0，表示队列为空
    Q->size = 0; // 将队列元素个数置为0，表示队列为空
}

// 返回队列Q的元素个数，即队列的长度
int QueueLength(SqQueue Q)
{
    return Q.size;
}

// 用e返回队列Q的队头元素
bool GetHead(SqQueue Q, ElemType* e)
{
    if (Q.front == Q.rear) // 队列为空，无法取出队头元素
        return false;
    *e = Q.data[Q.front]; // 将队头元素赋值给e
    return true;
}

// 插入元素e为队列Q的队尾元素
bool EnQueue(SqQueue* Q, ElemType e)
{
    if ((Q->rear + 1) % MAX_SIZE == Q->front) // 队列已满，插入失败
        return false;
    Q->data[Q->rear] = e; // 将元素e插入队尾
    Q->rear = (Q->rear + 1) % MAX_SIZE; // 更新队尾指针
    Q->size++; // 队列元素个数加1
    return true;
}

// 入队，插入元素e为队列Q的队尾元素
bool EnQueue(SqQueue* Q, ElemType e)
{
    if ((Q->rear + 1) % MAX_SIZE == Q->front) // 队列已满，插入失败
        return false;
    Q->data[Q->rear] = e; // 将元素e插入队尾
    Q->rear = (Q->rear + 1) % MAX_SIZE; // 更新队尾指针
    Q->size++; // 队列元素个数加1
    return true;
}

// 出队，删除队列Q的队头元素，并用e返回值
bool DeQueue(SqQueue* Q, ElemType* e)
{
    if (Q->front == Q->rear) // 队列为空，删除失败
        return false;
    *e = Q->data[Q->front]; // 将队头元素赋值给e
    Q->front = (Q->front + 1) % MAX_SIZE; // 更新队头指针
    Q->size--; // 队列元素个数减1
    return true;
}

队列的链式存储方式 

  • 当我们无法估计队列长度时，一般采用链式队列

存储方式

  • 链栈是运算受限的单链表，在链表头部和尾部进行操作

代码实现

 

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

typedef int ElemType; // 定义队列元素的数据类型

// 队列结点类型
typedef struct QNode
{
    ElemType data; // 结点的数据域
    struct QNode* next; // 结点的指针域
}QNode, * QuenePtr;

// 链式队列类型
typedef struct
{
    QuenePtr front; // 队头指针，指向队头结点
    QuenePtr rear; // 队尾指针，指向队尾结点
}LinkQuene;

// 初始化队列Q
void InitQuene(LinkQuene* Q)
{
    Q->front = Q->rear = (QuenePtr)malloc(sizeof(QNode)); // 创建头结点
    if (!Q->front) // 内存分配失败
        exit(1);
    Q->front->next = NULL; // 头结点的指针域置空
}

// 销毁队列Q
void DestroyQuene(LinkQuene* Q)
{
    QuenePtr p = Q->front;
    while (p) // 逐个释放结点内存
    {
        Q->front = p->next;
        free(p);
        p = Q->front;
    }
    Q->front = Q->rear = NULL; // 将队列指针置空
}


// 返回队列Q的元素个数，即队列的长度
int QueneLength(LinkQuene Q)
{
    int count = 0;
    QuenePtr p = Q.front->next;
    while (p) // 遍历队列计数
    {
        count++;
        p = p->next;
    }
    return count;
}

// 用e返回队列Q的队头元素
bool GetHead(LinkQuene Q, ElemType* e)
{
    if (Q.front == Q.rear) // 队列为空，无法取出队头元素
        return false;
    *e = Q.front->next->data; // 将队头元素赋值给e
    return true;
}

// 入队操作
bool EnQuene(LinkQuene* Q, ElemType e)
{
    QuenePtr p = (QuenePtr)malloc(sizeof(QNode)); // 创建新结点
    if (!p) // 内存分配失败
        return false;
    p->data = e; // 将元素e存储到新结点中
    p->next = NULL; // 将新结点的next指针置为NULL

    Q->rear->next = p; // 将新结点链接到队尾结点的后面
    Q->rear = p; // 将队尾指针指向新结点

    return true;
}

// 出队操作
bool DeQuene(LinkQuene* Q, ElemType* e)
{
    if (Q->front == Q->rear) // 队列为空，无法出队
        return false;
    QuenePtr p = Q->front->next; // 指向队头结点
    *e = p->data; // 将队头元素赋值给e
    Q->front->next = p->next; // 将队头结点删除
    if (Q->rear == p) // 如果队列只有一个元素，出队后队列为空，需要将队尾指针指向头结点
        Q->rear = Q->front;
    free(p); // 释放出队的结点的空间
    return true;
}

总结

栈和队列是两种常用的数据结构，都是操作方式受限的线性表，都支持快速插入和删除元素，但它们的特点和应用场景略有不同。

栈（Stack）是一种后进先出（Last In First Out, LIFO）的数据结构，通常用数组或链表实现。栈有两个基本操作：入栈（push）和出栈（pop）。在栈中，只能访问最后一个入栈的元素，不能访问其他元素。栈的典型应用包括：表达式求值、函数调用、括号匹配等。

队列（Queue）是一种先进先出（First In First Out, FIFO）的数据结构，通常用数组或链表实现。队列有两个基本操作：入队（enQueue）和出队（deQueue）。在队列中，只能访问最先入队的元素，不能访问其他元素。队列的典型应用包括：进程调度、广度优先搜索、缓存等。

在实际应用中，栈和队列的应用十分广泛。例如，在计算机底层，操作系统利用栈来保存程序调用信息和临时变量；在图形学中，使用栈来实现画图的撤销和重做操作；在网络通信中，使用队列来实现数据包的存储和转发。掌握栈和队列的基本操作及其应用，是编程中必不可少的基本功。

伊斯星
关注
  • 18
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 11
    评论
数据结构与算法——从零开始学习（一）基础概念篇
csdn_aiyang的博客
12-06 25万+
前言 数据结构：是指相互之间存在一种或多种特定关系的数据元素的集合用计算机存储、组织数据的方式。数据结构分别为逻辑结构、（存储）物理结构和数据的运算三个部分。 为什么要学数据结构？ 首先，因为数据结构作为计算机专业的专业基础课程，是计算机考研的必考科目之一，如果打算报考计算机专业的研究生，你必须学好它；其次，数据结构是计算机软考、计算机等级考试等相关考试的必考内容之一，想要顺利通过这些考...
数据结构自学笔记二、栈
kyc19的博客
09-08 314
数据结构自学笔记二、栈栈的定义栈的作用 栈的定义 刚刚我们学了线性表，其实栈在也可以算作是线性表，甚至在进行某些操作的时候要比之前讲的一般的线性表更为简单。 栈是只能在一端进行操作的线性表。 小学的时候很喜欢玩《穿越火线》，当时玩终结者模式，一堆人钻在一条狭窄的胡同里，因为幽灵只能从一端进攻，所以只要火力充足，基本都能苟到最后。 但有一个问题，就是胡同太窄了，大家只能排成一列，所以如果前面的人不出去，后面的人也出不去。栈就是像这样的一种数据结构，它是一种线性表，但是只能从线性表的一段进行操作，如添加元素（压
数据结构之栈与队列学习总结
小帅的专栏
01-23 4356
栈与队列更多的作为程序员的工具来使用，构思算法的辅助工具，而数组、链表等是作为数据存储工具，适用于数据库应用中做数据记录，但栈与队列不是完全的数据存储工具，他们的生命周期比较短，在程序操作执行期间他们才被创建，在完成任务后就被销毁。栈与队列的访问是受限制的，即在特定时刻只有一个数据项可以被读取或被删除。他们可以用数组或链表来实现，比数组、链表更加抽象。Stack在解析算数表达式方面
数据结构（队列）学习心得
欢迎来到我的空间
08-04 6654
数据结构（队列）学习心得 1、队列的定义： 队列（queue）是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。 队列是一种先进先出（First In First Out）的线性表，简称FIFO. 允许插入的一端称为队尾，允许删除的一端称为队头。假设队列是 q = (a1, a2, ….., an),如下图所示：2、循环队列： front 指针指向队头元素 rear 指针指向队尾
【无标题】
kobe5152的博客
02-22 156
用队列实现栈和用栈实现队列 用队列实现栈 typedef int QDataType; typedef struct QListNode { struct QListNode* next; QDataType data; }QNode; // 队列的结构 typedef struct Queue { QNode* front; QNode* rear; }Queue; void QueueInit(Queue* q) { assert(q); q->front = NULL; q-&
栈与队列的学习总结
奔跑的蜗牛
05-07 5729
栈与队列1、栈1.1栈的定义1.2栈的存储结构及实现1.2.1栈的顺序存储1.2.2栈的链式存储1.3两栈共享存储空间1.4 栈的应用（四则运算表达式求值）2、队列2.1 队列的定义2.2循环队列2.3队列的链式存储结构及实现3、栈与队列的比较 1、栈 1.1栈的定义 栈是限定仅在表尾进行插入和删除操作的线性表 1.2栈的存储结构及实现 1.2.1栈的顺序存储 1.2.2栈的链式存储 1.3两栈共...
数据结构--栈和队列学习小结
qq_44392254的博客
11-23 572
学习内容 栈 (Stack) 栈（stack）又名堆栈，它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。 稍微介绍一下关键名词： 运算受限：也就是这个表你...
《数据结构与算法》知识点（二）
程序员随笔
01-05 1036
第三章 栈和队列 栈和队列的定义和特点 1、栈的定义和特点 栈(Stack)是限制在表的一端进行插入和删除运算的线性表，通常称插入、删除的这一端为栈顶(Top)，另一端为栈底(Bottom)。先进后出。top= -1时为空栈，top=0只能说明栈中只有一个元素，并且元素进栈时top应该自增 顺序存储栈：顺序存储结构 链栈：链式存储结构。插入和删除操作仅限制在链头位置上进行。栈顶指针就...
c++数据结构之入门ppt
01-02
本套“C++数据结构之入门PPT”是专为初学者设计的一份详细教程，旨在帮助读者从零开始理解并掌握数据结构的基本概念、原理和应用。通过这套PPT，学习者可以逐步建立起对数据结构的系统认识，并为后续的C++编程学习...
栈实验报告
03-31
1.了解栈和队列的特性。 2. 掌握栈的顺序表示和实现。 3. 掌握栈的链式表示和实现。 4. 掌握队列的顺序表示和实现。 5. 掌握队列的链式表示和实现。 6. 掌握栈和队列在实际问题中的应用。
数据结构-栈与队列学习小结-转载自（公众号：代码随想录）
Tiehao7的博客
02-02 237
1.栈实现队列 使用两个栈 使用第一个栈作为队列 第二个作为辅助 push的时候 先把第一个栈中的POP到辅助栈中 再把需要进入队列的push进第二个栈 将第二个栈的数据pop到第一个栈 即为队列 其他操作照旧 2.队列实现栈 使用两个队列 使用第一个队列作为栈 第二个作为辅助 offer的时候 先把数offer到第二个队列中 再把第一个队列出列到第二个队列中 再交换一二队列即可 3.括号匹配问题 首先判断是奇数直接false 使用hashMap把括号放进去 右括号匹配 Map<Cha
数据结构学习总结（四）队列和栈
csdnligao的博客
07-18 1939
3.队列 队列其实可以看作是一种特别的线性表，一种对存储有特定要求的线性表。队列的特性就是FIFO——先进先出，就像平常的排队一样，先排队的先处理，队列中的进、出一般用PUSH、POP表示。队列是一种使用频率非常高的数据结构，在很多算法中（如图的广度优先遍历等）队列是实现的关键。 由于队列是一种特殊的线性表，因而队列的实现是基于线性表的实现的，只不过在对线性表的操作上，要特殊化，使其符合队列的
算法——剑指 Offer 09. 用两个栈实现队列
知北行的博客
09-25 243
剑指 Offer 09. 用两个栈实现队列 原题链接 题目： 用两个栈实现一个队列。队列的声明如下，请实现它的两个函数 appendTail 和 deleteHead ，分别完成在队列尾部插入整数和在队列头部删除整数的功能。(若队列中没有元素，deleteHead 操作返回 -1 )   示例 1： 输入： ["CQueue","appendTail","deleteHead","deleteHead"] [[],[3],[],[]] 输出：[null,null,3,-1] 示例 2：
数据结构学习之路————栈和队列
zhenghao_zh45的博客
07-26 848
       栈和队列是两种重要的线性结构。从数据结构的角度看，栈和队列也是线性表，其特殊性在于栈和队列的基本操作是线性表基本操作的子集。，它们是操作受限的线性表，因此可称为限定性的数据结构。 1.栈        栈是限定仅在表尾进行插入或删除操作的线性表。因此对栈来说，表尾端有其特殊含义，称为栈顶，表头端称为栈底。不含元素的空表称为空栈。栈顶实现元素的进出，栈的修改遵循后进先出的原则。因此...
《数据结构》第3章-栈与队列的学习总结
weixin_30252155的博客
03-31 258
　　我之前有接触过栈和队列，当时就觉得很好奇，那是以怎样的存储结构存储数据的呢？拨开重重迷雾，终于学到基础知识了。 　　学习《栈和队列》有两个星期了，有了前面两个章节的思维基础，我觉得栈和队列学习起来还是很好理解的，通过一些实际应用例子，让我有了更进一步的理解。现在我梳理一下知识，下面总结这一章我所学习到的东西。 一、栈（后进先出：LIFO） 　1、顺序栈 这是顺序栈的存储结构： t...
数据结构——队列总结
qq_43627106的博客
10-28 495
用顺序和链式实现了线性表，这次要用顺序和链式实现队列了。 队列：只允许在一端进行插入操作，而另一端进行删除操作的线性表。 允许插入（入队、进队）的一端称为队尾，允许删除（出队）的一端称为队头。 队列的操作特性：先进先出 队列的顺序存储结构及实现 顺序队列——队列的顺序存储结构 假溢出：当元素被插入到数组中下标最大的位置上之后，队列的空间就用尽了，尽管此时数组的低端还有空闲空间。 解决：循环队列：将...
数据结构总结（栈与队列）
weixin_43266513的博客
10-21 220
学习完链表马上就进入链表的应用。这一章我想主要还是利用顺序存储与链式存储来实现栈与队列。具体还有很多细节。 1，先讲栈的操作，特性，再讲如何存储栈的元素，代码如何实现。提及双端栈，注意寻找条件何时栈空，栈满。 const int MAX_SIZE=100; template <class T> class seqStack { public: ...
数据结构学习笔记（栈、队列）整理与总结
weixin_44814867的博客
08-21 550
数据结构学习笔记（栈、队列）整理与总结栈栈结构之顺序栈的基本介绍顺序栈的常用操作栈结构之链栈的基本介绍链栈的常用操作队列顺序队列链队列三级目录 栈 栈的概念： 栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。 压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。 出栈：栈的删除操作叫做出栈。出数据也在栈顶。 结构： 栈结构之顺序栈的基本介绍 概念： 栈是限
评论 11
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值