考研数据结构-栈和队列

最新推荐文章于 2023-10-19 01:03:32 发布
最新推荐文章于 2023-10-19 01:03:32 发布
阅读量370 收藏
点赞数
分类专栏： 数据结构 文章标签： 队列 链表 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sjxgghg/article/details/105608600
版权

文章目录

栈(stack)

定义：

栈是一种只能在一段进行插入或删除操作的线性表。

可以插入删除的一端叫栈顶，另一端叫栈底。

逻辑结构：

栈的逻辑结构属于线性表，只不过在操作上加了一些约束。先进后出。

存储结构：

顺序栈：

int stack[maxSize];
int top = -1;
//入栈
stack[++top] = 1;
//出栈
int x = stack[top--];
top == -1;//真，为栈空
top == maxSize - 1;//真，为栈满

链式栈：

带头结点写法


LNode *head = (LNode*)malloc(sizeof(LNode));
head->next = NULL;
LNode *top = NULL;
//入栈（就是单链表的头插法）
top = (LNode*)malloc(sizeof(LNode));
top->next = NULL;
top->data = 'A';
top->next = head->next;
head -> next = top;
//出栈
x = top -> data;
head -> next = top -> next;
free(top);
top = head -> next;

//判空
head->next == NULL;//真，则栈空
//只要有足够内存，栈就不会满。

应用：

【例】：不带头结点的单链表存储链栈，设计初始化栈、判断栈空、进栈和出栈等相应的算法。

分析：

不带头结点的单链表lst为空的条件是lst==NULL。

#include <iostream>
#define maxSize 100
using namespace std;
typedef struct LNode{
    int data;
    struct LNode *next;
}LNode;
void initStackl(LNode* &lst){
    lst = NULL;
}
int isEmptyl(LNode *lst){
    if(lst == NULL)
        return 1;
    else
        return 0;
}
//进栈
void pushl(LNode* &lst,int x){
    LNode *p;
    p = (LNode*)malloc(sizeof(LNode));
    p->data = x;
    p->next = lst;
    lst = p;
}
int popl(LNode* &lst,int &x){
   //别忘记栈空检查
    if(lst==NULL)
       return 0;
   x = lst->data;
   LNode *p = lst;
   lst = lst->next;
   free(p);
   return 1;
}
int main()
{
    LNode* lst;
    initStackl(lst);
    pushl(lst,1);
    pushl(lst,2);
    cout<<lst->data<<" "<<lst->next->data<<endl;
    int x;
    popl(lst,x);
    cout<<x<<" ";
    popl(lst,x);
    cout<<x<<endl;
    cout<<isEmptyl(lst);
    return 0;
}

队列（queue）：

队列是一种只能在一端插入元素（队尾），只能在另一端删除元素的线性表（队头）。

线性表：

队列的逻辑结构属于线性表，只不过在操作上加了一些约束。

队尾(Rear)进，队头(Front)出。先进先出，First in,First out.

存储结构

顺序队(也称循环队列)：

int queue[maxSize];
int front = 0,rear = 0;
//front不指向当前元素，它的下一个元素才是当前的元素。
//rear指向的是队尾
//让队列变成一个环
//入队
rear = (rear + 1) % maxSize;
queue[rear] = x;
//出队
front = (front + 1) % maxSize;
x = queue[front];
//判空
rear = front;
循环队列的要素：

  1. 队空状态：qu.rear == qu.front;

  2. 队满状态：(qu.rear + 1)%maxSize = qu.front;

  3. 进队：

    //判断队满之后
qu.rear = (qu.rear+1)%maxSize;
qu.data[qu.rear] = x;

  4. 出队：

    //判断队空之后
qu.front = (qu.front+1)%maxSize;
x = qu.data[qu.front];
链队：

特点：不存在队列满上溢的情况（只要内存够）。

链队的要素：

  1. 队空状态

    lqu->rear==NULL;
//或者
lqu->front==NULL;

  2. 队满状态

    无队满状态。

  3. 进队

    lqu->rear->next = p;
lqu->next = p;

  4. 出队

    p = lqu->front;//为了free(p)
lqu->front = p->next;
x = p->data;
free(p);

    如果空队列，入队一个元素：

    if(lqu->rear == NULL)
    lqu->front = lqu->rear = p;

    如果只剩下一个元素了，出队：

    if(lqu->rear == NULL)
    return 0;
if(lqu->rear == lqu->front)
    lqu->rear = lqu->front = NULL;

    共享栈和双端队列

    1. 共享栈

      为了增加内存空间的利用率和减少溢出的可能性，当两个栈共享一片连续的内存空间的时，应将两栈的栈底分别设在这片内存空间的两端，扎样当两个栈的栈顶在栈空间的某一位置相遇时，才产生上溢。

    2. 双端队列

      （太难了，稍后更新！）

    队列配置问题：

    前面介绍的是正常配置。

    非正常配置

    优点：front指向的就是当前元素。

    简述：

    ​ 队空是头在尾的前一个；

    ​ 有元素之后，rear++，rear就不可能在front的后面了。

    ​ 队满是front退两格。因为front退一格是队空，在队空再退一个就队满了，因为循环嘛。

    1. 队空(头在尾的前一个)

      front == (rear+1)%maxSize;//为真

    2. 队满

      front = (rear+2)%maxSize;//为真，关系式牢记

    3. 入队

      rear = (rear+1)%maxSize;
queue[rear] = x;

    4. 出队

      x = queue[front];
front = (front+1)%maxSize;

    【例】（真题）：

    循环队列存在数组A[]中，队列非空时，front和rear分别指向队头和队尾。初始化队列为空，要求第一个进入队列的元素在A[0]处，初始时front = 0,rear = n-1。

    真题仿造

    ​ （为了方便调试，给出的代码都包含main函数，考试只需要写主要函数就行了。）

1. 实现共享栈。顺序栈S0、S1共享一个存储区elem[maxSize];

  定义:

  ```cpp
  typedef struct{
      int elem[maxSize];
      int top[2];//top[0]为S0栈顶,top[1]为S1栈顶。
  }SqStack;
  //入栈
  int push(SqStack &st,int stNo,int x);//stNo
  //出栈操作
  int pop(SqStack &st,int stNo,int &x);
  ```

#include <iostream>
#define maxSize 100
using namespace std;
typedef struct{
    int elem[maxSize];
    int top[2];//top[0]为S0栈顶,top[1]为S1栈顶。
}SqStack;
void init_SqStack(SqStack &st){
    st.top[0] = -1;
    st.top[1] = maxSize;
}
//入栈
int push(SqStack &st,int stNo,int x) {//stNo
    //先判断栈满
    if(st.top[1] - st.top[0] == 1)
        return 0;
    if(stNo == 0){
        st.top[0]++;
        st.elem[st.top[0]] = x;
    }else if(stNo == 1){
        st.top[1]--;
        st.elem[st.top[1]] = x;
    }
    return 1;
}
//出栈操作
int pop(SqStack &st,int stNo,int &x){
    //记得判断栈空
    if(stNo == 0){
        if(st.top[0] == -1)
            return 0;
        x = st.elem[st.top[0]];
        st.top[0]--;
    } else if(stNo == 1){
        if(st.top[1] == maxSize)
            return 0;
        x = st.elem[st.top[1]];
        st.top[1]++;
    }
}
void print(SqStack st){
    cout<<"S0:\n";
    while(st.top[0]>=0){
        cout<<st.elem[st.top[0]]<<" ";
        st.top[0]--;
    }
    cout<<endl;
    cout<<"S2:\n";
    while(st.top[1]<maxSize){
        cout<<st.elem[st.top[1]]<<" ";
        st.top[1]++;
    }
    cout<<endl;
}
int main()
{
    SqStack st;
    init_SqStack(st);
    for(int i=0;i<4;i++){
        push(st,0,i);
        push(st,1,i+5);
    }
    print(st);
    int x;
    pop(st,0,x);
    cout<<"x:"<<x<<endl;
    pop(st,1,x);
    cout<<"x:"<<x<<endl;
    print(st);
    return 0;
}

2.请利用两个栈S1和S2来模拟一个队列，假设栈中元素为int型。

//3个运算的定义
push(ST,x);//元素x入ST栈
pop(ST,&x);//ST栈顶元素出栈，赋给变量x
isEmpty(ST);
/*
利用上述3个运算来实现该队列的3个运算：enQueue(元素入队列)、deQueue(元素出队列)、isQueueEmpty(判断队列是否为空，空返回1，不空返回0)。
*/

【分析】：S1作为输入元素存放的地方，S2作为输出元素存放地方；
S1要么全部倒进S2要么不倒，S2只要不空就不允许S1压栈。

S1的元素全部（必须全部）倒进S2的两个条件，任意满足一个S1即可倒入S2：

  1. S1栈满而且S2为空。
  2. 当出现pop命令而且S2为空。

S2不为空的时候，是因为已经有S1的元素倒入到S2了。

当S2的所有元素没有pop完，不允许S1倒元素到S2，如果S1栈满，那就拒绝push操作。

#include <iostream>
#define maxSize 5//设置小一点方便检查
using namespace std;
typedef struct{
    int data[maxSize];
    int top;
}SqStack;
void init_SqStack(SqStack &ST){
    ST.top = -1;
}
int push(SqStack &ST,int x) {//元素x入ST栈
    //检查栈满
    if(ST.top == maxSize - 1)
        return 0;
    ST.data[++ST.top] = x;
    return 1;
}
int pop(SqStack &ST,int &x) {//ST栈顶元素出栈，赋给变量x
    //检查栈空
    if(ST.top < 0)
        return 0;
    x = ST.data[ST.top];
    ST.top--;
}
int isEmpty(SqStack ST){
    if(ST.top == -1)
        return 1;
    else
        return 0;
}
int enQuenue(SqStack &s1,SqStack &s2,int x){
    //检查栈满
    //S1没有满，直接压
    if(s1.top != maxSize - 1){
        s1.data[++s1.top] = x;
    }else{
        //s1满了
        //s2非空就拒绝压栈
        if(s2.top != - 1)
            return 0;
        //s2是空栈，就把s1(记住是全部哦！)倒入到s2
        int y;
        while(s1.top != -1){
            pop(s1,y);
            push(s2,y);
        }
        //再把x压入空栈的s1
        push(s1,x);
        //
    }
}
int deQuenue(SqStack &s1, SqStack &s2, int &x){
    //s2有元素就直接弹出
    if(s2.top != -1)
        x = s2.data[s2.top--];
    else{
        //如果s1也没有元素，判定为空栈
        if(s1.top==-1)
            return 0;
        else {
            //把s1全部倒入s2，再在s2中出栈
            int y;
            while (s1.top != -1) {
                pop(s1,y);
                push(s2,y);
            }
            pop(s2,x);
        }
    }
}
int isQueueEmpty(SqStack s1,SqStack s2){
    if(s1.top==-1 && s2.top==-1)
        return 1;
    else
        return 0;
}
int main()
{
    SqStack s1;
    SqStack s2;
    init_SqStack(s1);
    init_SqStack(s2);
    int x;
    for(int i=0;i<8;i++){
        enQuenue(s1,s2,i);
        //当i==5时，出栈
        if(i==5) {
            deQuenue(s1,s2,x);
            cout << "pop value:" << x << endl;//出栈元素为：
        }
    }
    while(!isQueueEmpty(s1,s2)){
        deQuenue(s1,s2,x);
        cout<<x<<" ";
    }
    cout<<endl;
    return 0;
}
jieshenai
关注
专栏目录
数据结构-考研-栈和队列
qq_45044146的博客
09-06 203
栈的基本操作 栈常考的题型： 2.栈的特点：先进后出 按照存储方式分为顺序栈和链栈 顺序栈的定义： 初始条件不同，判断栈空和栈满的条件也不同，注意一下 队列 线性表，栈，队列之间关系。 栈和队列都是一种特殊的线性表 判断队列已满/已空 对于队头队尾指针 栈的应用（后进先出） 1.用栈实现括号匹配 2.栈在递归中应用 栈在递归中的调用 数组 ...
数据结构---栈和队列
qq_37617419的博客
08-30 207
栈和队列 周五了，不想学习，想出去玩滑板，但是今天的任务还没有完成啊！！！好气人！！ 感觉越到后边我的导图越来越不细致了。赶进度（此刻微信捂脸的表情） 好了，正题！！！！ （超级喜欢这种淡淡的绿色，哈哈哈哈哈哈） 一.栈 1.顺序栈的实现 #define MaxSize 50 typedef struct{ Elemtype data[MaxSize];//存放栈中元素 int top;/...
Python 多线程编程-10 Queue 模块之 queue 类
一分耕耘一分收获
02-24 4607
ueue/queue 模块中的 queue 类是该模块最经典的类，它实现的是 FIFO队列，先入先出队列，其添加的第一个任务是第一个检索的任务，这也是日常生活中最经典的场景之一。
循环队列
qq_74106438的博客
10-19 477
同样，在实现循环队列之前，我们需要了解它的定义：循环队列就是将队列存储空间的最后一个位置绕到第一个位置，形成逻辑上的环状空间，供队列循环使用。​这样的结构可以充分利用向量空间，克服”假溢出“现象。在循环队列中，如果队列元素数与数组内能容纳的最大元素数量MaxSize相等，当队列为空或满时，则都有front = rear。为了区分这两种情况，我们规定循环队列中最多只有MaxSize-1个元素，当front = rear时，循环队列为空，当front =（rear+1)%MaxSize时，循环队列为满
python queue模块
xxiaozr的博客
06-19 1067
import queuequeue.Queue(maxsize=0) 定义一个先进先出的队列，maxsize是队列的长度，如果其小于或者等于零，队列的长度就是无穷大 queue.LifoQueue(maxsize=0) 定义一个后进先出的队列 queue.deque() 双线队列 Queue.qsize() 返回队列的大小，真实存在的元素 Queue.maxsize() 返回队列最大支持
18版考研数据结构天勤课后习题全部代码-栈和队列.cpp
09-08
18版考研数据结构天勤课后习题全部代码-栈和队列，用于考研复习
数据结构考研习题-第三章栈和队列.rar
03-08
在本压缩包“数据结构考研习题-第三章栈和队列.rar”中，我们聚焦于两个基本且重要的数据结构：栈和队列。这两个概念在编程和算法设计中起着至关重要的作用。 栈（Stack）被称为“后进先出”（Last In, First Out, ...
考研数据结构-学习笔记
最新发布
05-17
综上所述，线性结构是数据结构的基础，通过对线性表、栈、队列等的理解，可以为后续更复杂的非线性结构的学习打下坚实的基础。在实际应用中，根据问题的具体需求选择合适的存储方式和操作方法至关重要。
3. 线性表-栈和队列1
08-03
总之，栈和队列是两种基本的线性数据结构，它们在实际编程中有着广泛的应用。栈的LIFO特性使得它在回溯、撤销、函数调用等场景中表现出色，而队列的FIFO（先进先出）特性则适用于任务调度、打印队列等场合。了解并...
考研数据结构-图的相关应用算法
11-14
【考研数据结构-图的相关应用算法】是针对考研备考者，特别是准备考暨南大学848或830科目的学生，所涵盖的内容主要涉及图的存储结构、图的遍历方法，以及一些关键算法，如最小代价生成树、最短路径等。这些知识点在...
Python队列Queue详解，超详细
热门推荐
小鱼干儿的博客
07-08 5万+
python队列实现与用法，queue块是Python内置的标准模块，模块实现了三种类型的队列，它们的区别仅仅是条目取回的顺序，分别由3个类进行表示，Queue，LifoQueue，PriorityQueue先进先出队列
Python3 queue队列模块详解
Alex
05-09 4834
queue介绍 queue是python中的标准库，俗称队列。 在python中，多个线程之间的数据是共享的，多个线程进行数据交换的时候，不能够保证数据的安全性和一致性，所以当多个线程需要进行数据交换的时候，队列就出现了，队列可以完美解决线程间的数据交换，保证线程间数据的安全性和一致性。 注意： 在python2.x中，模块名为Queue queue模块有三种队列及构造函数 Python queue模块的FIFO队列先进先出。 queue.Queue(maxsize) LIFO类似于堆，即先进后出。 que
Python自带队列模块Queue的使用(1)
qq_38949193的博客
07-26 7440
Python自带的队列模块有4种队列： FIFO：first in first out  先进先出 LIFO：last in first out   后进先出，类似于栈的数据结构 proiority：优先队列 deque：   双端队列 这一部分，先介绍FIFO模式的队列，后三种队列会在后续的文章种介绍 设置队列长度、进队列与出队列 from queue import Queue ...
Python多线程3：queue
宁静致远
06-25 6291
queue模块实现了多生产者，多消费者队列。在多线程环境下，该队列能实现多个线程间安全的信息交换。 queue模块介绍 模块实现了3种类型的队列，区别在于队列中条目检索的顺序不同。在FIFO队列中，按照先进先出的顺序检索条目。在LIFO队列中，最后添加的条目最先检索到（操作类似一个栈）。在优先级队列中，条目被保存为有序的（使用heapq模块）并且最小值的条目被最先检索。 queue模块定
python Queue模块
Yatere的天平秤
08-08 3万+
创建一个“队列”对象 import Queue myqueue = Queue.Queue(maxsize = 10) Queue.Queue类即是一个队列的同步实现。队列长度可为无限或者有限。可通过Queue的构造函数的可选参数maxsize来设定队列长度
python中Queue模块
Meringue's Blog
02-24 1874
创建队列 python中Queue模块提供了3中队列： 1. Queue.Queue(maxsize)：先进先出队列（最常用） 2. Queue.Lifoqueue(maxsize)：先进后出队列 3. Queue.Priorityqueue(maxsize)：优先级队列（优先级越低越先出） 这里只介绍最常用的现进先出队列 import Queue q = Queue.Queue(...
queue模块基本使用
永远相信美好的事情即将发生
12-15 709
主要作用 解耦，使程序实现松耦合（一个模块修改不会影响其他模块） 提高效率 队列与列表的关系 队列中数据只有一份，取出就没有了，区别于列表，列表数据取出只是复制了一份 分类 FIFO (先入先出) queue.Queue(maxsize=0) 示例： import queue q = queue.Queue() q.put(1) q.put(2) q.put(3) print(q.get()) print(q.get()) print(q.get()) 输出结果： 1 2 3 LIFO (后入先出
python队列溢出_python – 多处理队列maxsize限制是32767
weixin_39878716的博客
12-11 802
我正在尝试使用多处理编写Python 2.6(OSX)程序,并且我想填充一个超过默认值32767项的Queue.from multiprocessing import QueueQueue(2**15) # raises OSError队列(32767)工作正常,但任何更高的数字(例如队列(32768))失败并出现OSError：[Errno 22]参数无效这个问题有解决方法吗？解决方法:一种方法...
【数据结构】共享栈
ahang880的博客
10-28 818
设有两个栈s1、s2都采用顺序栈方式，并且共享一个存储区[0,…,maxsize-1]，为了尽量利用空间，减少溢出的可能，可采用栈顶相向，迎面增长的存储方式。试设计s1、s2有关入栈和出栈的操作算法。 #include <cstdio> #include <iostream> #define maxsize 100 using namespace std; typedef struct { int stack[maxsize]; int top[2]; }stk; stk s;
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

jieshenai

为了遇见更好的文章

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值