数据结构第三章 栈与队列

最新推荐文章于 2023-07-13 10:39:53 发布
最新推荐文章于 2023-07-13 10:39:53 发布
阅读量379 收藏 6
点赞数 2
分类专栏： 数据结构与算法 文章标签： 数据结构 栈 队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/YJY131248/article/details/117448059
版权

文章目录

前言：
栈与队列是限定性线性表，与常规线性表的区别在于限制了插入和删除等操作的位置。
在栈中，只能在指定的一段进行插入和删除，俗称 “后进先出”。
在队列中，只能在一段插入，另一端删除，俗称 “先进先出”。

1 栈

1.1 栈的定义

插入和删除运算限制为仅在表的一端进行的线性表。

通常将表中允许进行插入、删除操作的一端称为栈顶，另一端称为栈底。栈底不能进行任何操作。当栈中没有元素时称为空栈。栈的插入操作被称为入栈，删除操作称为出栈。

栈的特点是：“后进先出”（后进栈的先出栈）
栈的描述

1.2 栈的表示和实现

1.2.1 顺序栈

顺序存储结构的栈。利用一组连续的存储单元依次存放自栈底到栈顶的数据元素。
栈顶指针top指示栈顶元素位置，top=-1表示为空栈

1.2.1.1 顺序栈的存储结构
#define StackSize 255
typedef struct{
	StackElemType elem[StackSize]; //存放数据元素
	int top; //存放栈顶元素下标
}SeqStack;
1.2.1.2 顺序栈的初始化
void InitStack(SeqStack *S){
	S->top = -1;
}
1.2.1.3 顺序栈的进栈
int Push(SeqStack * S,StackElementType x){
	if(S->top == StackSize-1)  //栈满
		return false;
	S->top++;
	S->elem[S->top] = x;
	return true;
}
1.2.1.4 顺序栈的出栈
int GetTop(SeqStack * S, StackElementType *x){
    if(S->top == -1)  //空栈
        return false;
    else
    {
        *x = S->elem[S->top];
        S->top--;
        return true;
    }
}

1.2.2 链栈

链栈是采用链表作为存储结构实现的栈。采用带头结点的单链表实现栈。表头指针就作为栈顶指针。

1.2.2.1 链栈的存储结构
typedef struct node
{
    StackElementType data;
    struct node * next;
}LinkStackNode,*LinkStack;
1.2.2.2 链栈的入栈
int Push(LinkStack top, StackElementType x)
{
    LinkStackNode *temp;
    temp = (LinkStackNode * )malloc(sizeof(LinkStackNode));
    if(temp==NULL) //没有存储空间
    	return false;
    temp->data = x;
    temp->next = top->next;
    top->next = temp;
    return true;
}
1.2.2.3 链栈的出栈
int Pop(LinkStack top,StackElementTyoe *x)
{
    LinkStackNode *temp;
    temp = top->next;
    if(temp==NULL) //空栈
        return false;
    top->next = temp->next;
    *x = temp->data;
    free(temp);
    return true;
}

1.3 栈与递归的实现

递归算法的特点：

  1. 分而治之
  2. 效率低下

1.3.1 递归算法的前提

  • 原问题可以层层分解为类似的子问题，且子问题规模更小
  • 规模最小的子问题具有直接解（递归出口）

1.3.2 递归工作栈

递归函数运行期间的数据存储区。每一层递归所需的信息构成一个“工作记录”，其中包括所有实参、局部变量以及上一层返回地址

递归工作栈的特点：

  • 调用即入栈
  • 退出则出栈
  • 当前执行层的工作记录必须是递归工作栈栈顶的工作记录，栈顶指针为当前环境指针

2 队列

2.1 队列的定义

只允许在表的一端插入元素，在另一端删除元素的线性表。“先进先出”

2.2 队列的表示和实现

2.2.1 顺序队列

利用一个一维数组来存储，并设立两个指针rear（指向队尾）和 front（指向队首）。
非空顺序队列队头指针（front）指向队头元素，队尾指针（rear）指向最后一个元素的下一位。

2.2.1.1 顺序队列的存储结构
#define MaxQueueSize 255

typedef struct
{ 
    DataType queue[MaxQueueSize];
    int rear;
    int front;
}SeqCQueue;
2.2.1.2 顺序队列的假溢出

顺序队列的假溢出是指顺序队列因多次入队出队导致有存储空间但无法插入元素的现象。

解决办法：

  • 尽可能设置最大元素个数
  • 修改出队算法，使每次出队后都把队列中剩余元素向对头方向移动一个位置
  • 修改入队算法，增加判断条件，当出现“假溢出”现象，把元素向队头移动
  • 采用循环队列

2.2.2 循环队列

把顺序队列所使用的存储空间构造成逻辑上首尾相连的循环队列。当rear和front到达MaxQueueSize-1，再前进一个位置就自动到0。当rear+1 = MaxQueueSize时，rear = 0

在这里插入图片描述

2.2.2.1 循环队列的存储结构
#define MaxQueueSize 255 //定义队列最大长度

type struct
{
    DataType queue[MaxQueueSize];
    int rear;
    int front;
    int count;
}SeqQueue;
2.2.2.2 循环队列的初始化
//初始化操作
void InitQueue(SeqQueue *Q)
{
    Q->front = Q->rear = 0;
}
2.2.2.3 循环队列的入队
int EnterQueue(SeqQueue *Q,QueueElementType x)
{
    /* 将元素x入队 */
    if((Q->rear+1)%MaxQueueSize==Q->front) //尾指针+1指向了头指针，说明队列已满
        return false;
    Q->element[Q->rear] = x;
    Q->rear = (Q->rear+1)%MaxQueueSize;
    return true;
}
2.2.2.3 循环队列的出队
int DeleteQueue(SeqQueue *Q, QueueElementType * x)
{
    //删除队列的对头元素，用x返回其值
    if(Q->front==Q->rear)  //队列为空
        return false;
    *x = Q->element[Q->front];
    Q->front = (Q->front+1)%MaxQueueSize;
    return true;
}
2.2.2.3 循环队列的队空队满判断
  1. 计数器方法
    1. 队满：count>0 && rear==front
    2. 对空：count = 0
  2. 标志位Tag
    1. 队满：tag == 1 && rear==front
    2. 对空：tag == 0 && rear==front
  3. 牺牲一个空间
    1. 队满：（rear+1）% Max == front
    2. 对空： rear == front

2.2.3 链队列

链式队列的队头指针指在队列的当前队头结点位置，队尾指针指在队列的当前队尾结点位置。

2.2.2.1 链队列的存储结构
typedef struct Node
{
	QueueElementType data;
	struct Node * next;
}LinkQueueNode;

typedef struct
{
	LinkQueueNode *front;
	LinkQueueNode *rear;
}LinkQueue;

3 实验题

3.1 顺序队列的逆置

借助顺序栈完成顺序队列的逆置

代码：

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

//顺序队列、顺序栈的逆置

//顺序队列结构化描述：
typedef struct Node {
    int data;
    struct Node *next;
}QueueNode;
typedef struct {
    int sum;
    QueueNode *front;
    QueueNode *rear;
}Queue;

//顺序栈结构化描述
typedef struct SeqStack
{
    int elem[20]; //用来存放栈中元素的一维数组
    int top; //用于存放栈顶元素下标
}SeqStack;

//顺序队列的初始化
void InitQueue(Queue *Q){
    Q->front = (QueueNode *)malloc(sizeof(QueueNode));
    Q->rear = Q->front;
    Q->front->next = NULL;
    Q->sum = 0;
    return;
}
//顺序栈初始化
void InitSeqStack(SeqStack *S){
    S->top = -1;
    return;
}

//顺序队列入队
void EnterQueue(Queue *Q, int x){
    QueueNode *e;
    e = (QueueNode *)malloc(sizeof(QueueNode));
    e->data = x;
    e->next = NULL;
    Q->rear->next = e;
    Q->rear = e;
    Q->sum++;
    return;
}
//顺序队列出队
int PopQueue(Queue *Q) {
    QueueNode *x; //记录出队元素的值
    if(Q->rear == Q->front){
        return -1; //空队列返回-1
    }
    x = Q->front->next;
    Q->front->next = x->next;
    //若x为队列中唯一的元素，则尾指针应指向头指针
    if(Q->rear == x){
        Q->rear = Q->front;
    }
    Q->sum--;
    return x->data;
}
//顺序栈入栈:将队列中元素依次入栈
void EnterSeqStack(SeqStack *S, Queue *Q){
    int x;
    int num = Q->sum;
    for(int i = 0;i<num;i++){
        x = PopQueue(Q);
        S->top++;
        S->elem[S->top] = x;
    }
    S->top++;
    return;
}

//打印顺序队列
void PrintQueue(Queue *Q){
    QueueNode *t;
    t = Q->front->next; //t指向Q第一个元素
    while(t!=NULL){
        printf("%d ",t->data);
        t = t->next;
    }
    return;
}
//打印顺序栈
void PrintSeqStack(SeqStack *S){
    for(int i = S->top-1;i>=0;i--){
        printf("%d ",S->elem[i]);
    }
    return;
}

int main(){
    Queue Q;
    SeqStack S;
    InitQueue(&Q);
    InitSeqStack(&S);
    printf("请依次输入队列的各元素（输入0表示结束）:");
    while(1){
        int x;
        scanf("%d", &x);
        if(x == 0)
            break;
        EnterQueue(&Q, x);
    }
    printf("--------------------------------------------------\n");
    printf("输出逆置前为:");
    PrintQueue(&Q);
    printf("\n");
    EnterSeqStack(&S,&Q);
    printf("输出逆置后为:");
    PrintSeqStack(&S);
    return 0;
}

结果如下：
在这里插入图片描述

3.2 划分子集

问题描述：
在这里插入图片描述
代码：

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

//划分子集
//R:2,8 9,4 2,9 2,1 2,5 6,2 5,9 5,6 5,4 7,5 7,6 3,7 6,3 (0,0)

//设置全局变量
int n = 0; //记录集合A元素个数
int m = 0; //记录集合B元素个数

//矩阵结构化描述
typedef struct {
    int row; //行值
    int col; //列值
}Triple;
Triple t[100];

//顺序队列结构化描述
typedef struct Node {
    int data;
    struct Node *next;
}QueueNode;
typedef struct {
    int sum;
    QueueNode *front;
    QueueNode *rear;
}Queue;

//顺序队列初始化
void InitQueue(Queue *Q){
    Q->front = (QueueNode *)malloc(sizeof(QueueNode));
    Q->rear = Q->front;
    Q->front->next = NULL;
    Q->sum = 0;
    return;
}
//入队
void EnterQueue(Queue *Q, int x){
    QueueNode *e;
    e = (QueueNode *)malloc(sizeof(QueueNode));
    e->data = x;
    e->next = NULL;
    Q->rear->next = e;
    Q->rear = e;
    Q->sum++;
    return;
}
//出队
int PopQueue(Queue *Q) {
    QueueNode *x;
    if(Q->rear == Q->front){
        return -1; //空队返回-1
    }
    x = Q->front->next;
    Q->front->next = x->next;
    //若x为顺序队列的唯一元素，尾指针指向到头指针
    if(Q->rear == x){
        Q->rear = Q->front;
    }
    Q->sum--;
    return x->data;
}
//打印队列
void PrintQueue(Queue *Q){
    QueueNode *t;
    t = Q->front->next;
    while(t!=NULL){
        printf("%d ",t->data);
        t = t->next;
    }
    return;
}
//判断元素x与队列Result的元素是否冲突
int Conflict(Queue *Result, int x){
    QueueNode *temp;
    temp = Result->front->next;
    while(temp!=NULL){
        for(int i=0;i<m;i++){
            if((x == t[i].row && temp->data==t[i].col)||(x==t[i].col && temp->data==t[i].row)){
                return 1;
            }
        }
        temp = temp->next;
    }
    return 0;
}
//划分子集
void CollectionDivide(Queue *Result,Queue *Q){
    int num = Q->sum;
    for(int i=0;i<num;i++){
        //遍历Q中每个元素，判断该元素与Result中元素是否冲突
        //将Q中首元素取出并将其在队列中删除
        int q_data = PopQueue(Q);
        if(Conflict(Result,q_data)){
            EnterQueue(Q, q_data);
        }
        else
        {
            EnterQueue(Result, q_data);
        }
    }
    return;
}
int main(){
    Queue Q;
    InitQueue(&Q);
    int i = 0; //记录矩阵下标值
    //集合A、R的初始化
    printf("请依次输入集合A中各元素的值（输入0视为结束）:");
    while(1){
        int x;
        scanf("%d", &x);
        if(x == 0)
            break;
        EnterQueue(&Q, x);
        n++;
    }
    printf("------------------------------------------------------------------\n");
    printf("请依次输入集合R中各元素的值（输入0,0视为结束）:");
    while(1){
        scanf("%d,%d", &t[i].row,&t[i].col);
        if(t[i].row == 0 && t[i].col == 0)
            break;
        i++;
        m++;
    }
    printf("------------------------------------------------------------------\n");
    Queue result[100];
    int re = 0; //记录result数组下标
    while(Q.sum>0){
        InitQueue(&result[re]);
        EnterQueue(&result[re],PopQueue(&Q));
        if(Q.sum>0){
            CollectionDivide(&result[re],&Q);
        }
        re++;
    }
    for(int i = 0;i<re;i++) {
        printf("第%d个子集:",i+1);
        PrintQueue(&result[i]);
        printf("\n");
    }
    return 0;
}

结果如下：
在这里插入图片描述

看风结种子
关注
专栏目录
数据结构与算法之队列
m0_62143653的博客
02-25 402
Java
list、queue、stack：在matlab中实现list、queue、stack数据结构-matlab开发
05-30
这些文件在 matlab 中实现了列表、队列、堆栈数据结构，队列和堆栈比 java 的替代方案要快一点。 CStack 定义一个栈数据结构 它喜欢 java.util.Stack，但是，它可以使用 CStack.content() 来返回堆栈的所有数据（在单元格中），并且速度更快比java的堆栈。 s = CStack(c); c 是一个单元格，可以省略s.size() 返回元素的数量s.empty() 返回栈是否为空s.push(el) 将 el 推到栈顶s.pop() 弹出栈顶，返回元素s.top() 返回栈顶元素s.remove() 移除栈中的所有元素s.content() 返回栈的所有数据（以a的形式） 大小为[s.size（），1]的像元 CQueue 定义一个队列数据结构 它喜欢 java.util.Queue，然而，它可以使用 CQueue.content() 来返回队
栈和队列
Hush
07-06 443
一、栈的表示和操作的实现 定义：栈（stack）是限定只在表尾进行插入或删除操作的线性表；表头为栈底（bottom），表尾为栈顶（top）；不含元素叫空栈；具有后进先出（LIFO）的特点。 顺序栈的表示和实现 //-----顺序栈的存储结构----- #define MAXSIZE 100 //顺序栈存储最大容量 typedef struct { SElemType *base;...
Matlab实现支持代码生成的栈和队列数据结构
anbuqi的博客
07-13 1047
matlab没有内置的队列和栈数据结构，本文介绍一种使用Matlba函数和coder.varsize实现存储结构体的队列和栈方法，支持代码生成转成C语言或mex。%CREATEVT 预创建结构体，方便代码生成% 此处显示详细说明vt=struct;vt.x=0;vt.y=0;vt.z=0;end。
matlab动态数组、队列、堆栈、容器
tyl532667325的博客
08-04 1万+
一直以为matlab中没有动态数组，或者类似C++的vector容器的数据结构。其实不然，matlab的数组就是一个动态数组，它可以当作vector，或者队列等数据结构使用。 array = 1:10; array = 1 2 3 4 5 6 7 8 9 10 array(1) = []; array = ...
数据结构第三章栈和队列3.1-3.2
11-23
在本章中，我们将深入探讨两种重要的数据结构：栈和队列。这些数据结构在算法设计、编程语言解析、操作系统等多个领域有着广泛的应用。 首先，我们来看栈（Stack）。栈是一种后进先出（LIFO, Last In First Out）的...
数据结构第三章栈和队列3.3-3.4
最新发布
11-23
在本章中，我们将深入探讨两种基本的数据结构：栈和队列，它们在3.3至3.4部分扮演着关键角色。 首先，栈是一种后进先出（LIFO，Last In First Out）的数据结构，就像现实生活中的堆叠物品一样，最后放进去的物品...
数据结构第三章栈和队列.pdf
11-12
"数据结构第三章栈和队列" 本章节主要介绍了栈和队列这两种基本数据结构的概念、实现和应用。 一、栈的基本概念 栈是一种后进先出（Last In First Out，LIFO）的数据结构，仅允许在栈顶插入或删除元素。栈的基本...
数据结构 第3章 栈和队列.ppt
06-17
数据结构-栈和队列 栈是一种特殊的线性表，它限定仅在表尾进行插入和删除操作。栈的顶端称为栈顶，栈的底端称为栈底。栈的特点是后进先出（LIFO）或先进后出（FILO）。 栈的抽象数据类型定义（ADT）： ADT Stack...
数据结构作业：第三章-栈和队列题目.docx
12-17
本文档旨在提供一个详细的知识点总结，涵盖数据结构第三章中的栈和队列概念。通过对题目的逐一分析，我们将对栈和队列的基本概念、特点、操作和应用进行总结。 栈的基本概念 栈是一种后进先出（LIFO）的数据结构，...
队列和栈类：双向链表、栈和队列的实现-matlab开发
06-01
这是使用双向链表的队列和堆栈的实现。 双向链表类可以单独使用。
顺序队列出现假溢出现象的解决办法
热门推荐
ganggang112800的专栏
11-27 2万+
这个问题是从队列的基本形式上进行修改的： 我们知道顺序队列中，删除一个元素，first指针要向后移动一个，并且插入一个的时候last指 针也会向后移动一个。这样的话，我们申请好的空间利用情况都得向后移动，前面的空间不能再 用了。首先解释一下假溢出的现象：当队尾指针last=MaxSize - 1时，队列的前端可能还有许多 由于此前进行了删除操作而产生的空的位置。这样的情况，我们称为假溢出现
matlab 堆栈实现,检验“MATLAB 实现队列(FIFO)”所编写的程序的正确性
weixin_39636540的博客
04-09 914
检验“MATLAB 实现队列(FIFO)”所编写的程序的正确性；演示所设计的新类是如何被运作的。(1)创建一个队列对象，并显示。qe='Hello! 你好 ！ '; % 字符串Q=queue(qe) % 生成队列对象 Q ，并显示Q=qe: Hello! 你好 ！(2)类别检查和是否对象判断class(Q) % 类别检查isobject(Q) % 是否对象判断isa(Q,'queue') % 是否...
数据结构之队列（C语言）基础
x_trusher的博客
12-19 432
队列（Queue）: 是一种先进先出的线性表（FIFO）,也分为两种，链队列和循环队列（好像还有其他的类型，忘了。。） 这里就介绍这两种的一些简单函数。 1、链队列 毋庸置疑，就是链式存储队列，有两个指针front和rear，其中front负责进队，rear负责出队 代码如下 /* 数据结构之链队列 实现函数： 初始化；入队；出队；判断是否队空，销毁；输出 *...
栈顶指针和队尾指针指向当前位置和指向下一个位置的区别？——轻松搞懂栈和队列指针的指向问题
weixin_44003177的博客
11-07 4603
我们先看一下队列的队尾指针指向队尾元素的当前位置的入队操作: 可以看到，当队尾指针指向的是队尾元素时，我想加入一个新的元素，这时直接放在队尾指向的位置是不可以的，因为这个位置已经有元素了，所以先要对队尾指针进行移动，移动到一个空位置，然后再进行插入操作。 再看一下队尾指针指向队尾元素的下一个位置： 可以看到，让队尾指向的是下一个位置，那队尾指向的位置是空的，当我想插入元素时，是不是直接可以放到这个空位置上，然后再移动队尾...
队列的链表存储实现
weixin_33910137的博客
01-18 150
struct Node{ ElementType Data; struct Node *Next; }; struct QNode{//链队列结构 struct Node *rear; //指向队尾结点 struct Node *front;//指向队头结点 }; typedef struct QNode *Queue; Queue PtrQ; ...
【数据结构与算法】链队和环形队列的基本算本，以及为什么使用环形队列
weixin_53161762的博客
03-28 2206
一、什么是队列 队列 (Queue) 是限定只能在表的一端进行插入，在表的另一端进行删除的线性表。 **队列的特点：**先进先出(FIFO) 把进行插入的一端称做队尾（rear）。 进行删除的一端称做队首或队头（front）。 向队列中插入新元素称为进队或入队，新元素进队后就成为新的队尾元素。 从队列中删除元素称为出队或离队，元素出队后，其后继元素就成为队首元素。 队列的应用： 根据队列的“先进先出”的特征，可以使用队列解决如下问题： 记录访问或操作的顺序。 对“独占资源”的调度安排。如打印机，同一时间
c语言双循环链表,循环链表之双循环链表（C语言版）
weixin_35822833的博客
05-19 584
依然沿袭过去的风格，进入双循环链表之前，先提另一种结构，双向链表，先有了双向链表再有了双循环链表。这两种结构和单链表一样都有带头结点和不带头结点之分。我们先来看一下这几种结构的结构图:双链表双循环链表既然单向链表有普通的链表也就是不循环的链表、那么双向链表也一样，也有普通的双向链表和双向循环链表；也有带头结点，不带头结点的结构，这里依然是两种结构都给出算法，但是普通的循环链表不写，这里只写循环双链...
数据结构与算法实战：链表
qq_37410388的博客
10-09 369
目录链表的基本理论链表的基本操作链表的初始化链表结点的创建求链表的长度查找链表的第K个元素链表的插入链表的删除链表的输出效果测试 链表的基本理论 链表属于线性表的元一种，与顺序表不同的是，虽然链表在逻辑上具有连续性，但其的物理存储却是不一定连续的，链表的每一个元素又称之为一个结点，每一个结点都是我们随机在内存中开辟的空间，正是由于这一特点，所以链表的长度是不固定的，为了构成链式的逻辑结构，即一个结点链接一个的结点的的逻辑结构，我们每个结点除了要储存元素的信息外，还要储存下一个结点的地址(指针)，以便我们可以
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值