栈 队列

最新推荐文章于 2023-05-24 11:32:42 发布
最新推荐文章于 2023-05-24 11:32:42 发布
阅读量467 收藏 2
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35452533/article/details/77514351
版权
栈
一种特殊的线性表，其只允许在在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一段称为栈顶，另一端称为栈底。不含任何元素的栈称为空栈，栈又称为后进先出的线性表。
顺序栈
顺序堆栈和顺序表数据成员相同，不同之处，顺序堆栈的入栈和出栈操作只允许对当前栈顶进行
特点：顺序栈的实现在于使用了数组这个基本数据结构，数组中的元素在内存中的存储位置是连续的，且编译器要求我们在编译期就要确定数组的大小，这样对内存的使用效率并不高，一来无法避免因数组空间用光而引起的溢出问题，二在系统将内存分配给数组后，则这些内存对于其他任务就不可用
共享栈
如果有两个同类型的栈，为他们各自开辟了数组空间，极有可能第一个栈已经满了，在进栈就溢出，而另一个栈还有很多存储空间空闲，对空间的利用率不是很高。
原理：既然是两个栈共享一段空间向中间靠拢。用数组的0号位置标记stack1的栈底，top1标记stack1的栈顶；用size-1标记stack2的栈顶，用top2标记栈stack2的栈顶，top1和top2向中间移动，只要top1和top2不见面则栈未满。
#include <iostream>
#include <assert.h>
using namespace std;

template<class T, int N>
class SharedStack
{
public:
    SharedStack()
        :_s1(0)
        ,_s2(N-1)
    {}

    void Push(const T& data, int which)
    {
        assert(which == 1 || which == 2);
        assert(_s1 <= _s2);

        if(which == 1)
            arr[_s1++] = data;
        else
            arr[_s2--] = data;
    }

    void Pop(int which)
    {
        assert((which == 1 || which == 2) && (_s1 != 0 || _s2 != N-1));
        if(which == 1)
            _s1--;
        else
            _s2++;
    }

    bool Empty()
    {
        return _s1 == 0 && _s2 == N-1;
    }

    size_t Size(int which)
    {
        if(which == 1)
            return _s1;
        return  N - _s2 - 1;
    }

    T& Top(int which)
    {
        assert((which == 1 || which == 2) && (_s1 != 0 || _s2 != N-1));
        if(which == 1)
            return arr[_s1-1];
        return arr[_s2+1];
    }
private:
    T arr[N];
    int _s1;
    int _s2;
};

int main()
{
    SharedStack<int, 5> ss;
    ss.Push(1, 1);
    ss.Push(2, 1);
    ss.Push(3, 1);
    cout<<ss.Top(1)<<endl;
    cout<<ss.Size(1)<<endl;

    cout<<ss.Empty()<<endl;

    ss.Push(1, 2);
    ss.Push(2, 2);
    cout<<ss.Top(2)<<endl;
    cout<<ss.Size(2)<<endl;

    ss.Pop(1);
    ss.Pop(1);
    ss.Pop(1);
    cout<<ss.Size(1)<<endl;
    ss.Pop(2);
    ss.Pop(2);
    cout<<ss.Size(2)<<endl;
    cout<<ss.Empty()<<endl;
    return 0;
}

这里写图片描述

链式栈
使用了链表来实现栈，链表中的元素存储在不连续的地址，由于是动态申请内存，所以我们可以以非常小的内存空间开始，另外当某个项不使用时也可将内存返还给系统。
#include <iostream>
#include <assert.h>
using namespace std;

template<class T>
struct Node
{
    Node(const T& data = T())
        :data(data)
        ,next(0)
    {}

    T data;
    Node* next;
};

template<class T>
class LinkStack
{
public:
    LinkStack()
        :_pNode(NULL)
    {}

    void Push(const T& data)
    {
        Node<T>* tmp = new Node<T>(data);
        tmp->data = data;
        if(_pNode != NULL)
            tmp->next = _pNode;
        _pNode = tmp;
    }

    void Pop()
    {
        assert(_pNode);
        Node<T>* tmp = _pNode;
        if(_pNode->next)
            _pNode = _pNode->next;
        else
            _pNode = NULL;
        free(tmp);
        tmp = NULL;
    }

    bool Empty()
    {
        return NULL == _pNode;
    }

    size_t Size()
    {
        size_t size = 0;
        Node<T>* tmp = _pNode;
        while(tmp)
        {
            size++;
            tmp = tmp->next;
        }
        return size;
    }

    T& Top()
    {
        assert(_pNode);
        return _pNode->data;
    }

    ~LinkStack()
    {
        while(_pNode)
        {
            Node<T>* tmp = _pNode;
            if(_pNode->next)
                _pNode = _pNode->next;
            free(tmp);
            tmp = NULL;
        }
    }
private:
    Node<T>* _pNode;
};

int main()
{
    LinkStack<int> ls;
    ls.Push(1);
    ls.Push(2);
    ls.Push(3);
    ls.Push(4);

    cout<<ls.Top()<<endl;
    cout<<ls.Size()<<endl;
    cout<<ls.Empty()<<endl;

    ls.Pop();
    cout<<ls.Top()<<endl;
    cout<<ls.Size()<<endl;

    ls.Pop();
    ls.Pop();
    ls.Pop();
    cout<<ls.Empty()<<endl;

    return 0;
}

运行结果：
这里写图片描述

队列
只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表。进行插入操作的一端称为队尾，通常称为入队列；进行删除操作的一端称为队头，通常称为出队列。队列具有先进先出的特性(FIFO)。
顺序队列
因多次入队列和出队列操作后出现的尚有存储空间但不能再进行入队列操作的溢出称作为假溢出。顺序队列最大存储空间已经存满而又要求进行入队列操作所引起的溢出称为真溢出。
循环队列
解决“假溢出”的办法就是后面满了，就从头再开始，也就是头尾相接的循环。 将头尾相接的顺序存储队列称为循环队列。
队列满和队列空判断
1.少用一个存储单元
如果少用一个存储空间，则队尾指针加1等于队头指针
此时判断队列空的条件为：rear == front
判断队列满的条件为：(rear+1)%MaxSize==front
#include <iostream>
#include <assert.h>
using namespace std;

template<class T, int N = 5>
class Queue
{
public:
    Queue()
        :_front(0)
        ,_rear(0)
    {}

    void Push(const T& data)
    {
        assert((_rear+1)%N != _front);
        arr[_rear] = data;
        _rear = (_rear+1)%N;
    }

    void Pop()
    {
        assert(_rear != _front);
        _front = (_front+1)%N;
    }

    bool Empty()const
    {
        return _rear == _front;
    }

    size_t Size()const
    {
        return (_rear - _front + N)%N;
    }

    T& Front()
    {
        assert(_rear != _front);
        return arr[_front];
    }

    const T& Front()const
    {
        assert(_rear != _front);
        return arr[_front];
    }

    T& Back()
    {
        assert(_rear != _front);
        return arr[(_rear-1+N)%N];
    }   

    const T& Back()const
    {
        assert(_rear != _front);
        return arr[(_rear-1+N)%N];
    }
private:
    T arr[N];
    int _front;
    int _rear;
};

int main()
{
    Queue<int, 5> q;
    q.Push(1);
    q.Push(2);
    q.Push(3);
    q.Push(4);

    cout<<q.Back()<<endl;
    cout<<q.Front()<<endl;
    cout<<q.Size()<<endl;

    q.Pop();
    q.Push(5);
    cout<<q.Back()<<endl;
    cout<<q.Front()<<endl;
    cout<<q.Size()<<endl;

    q.Pop();
    q.Pop();
    q.Pop();
    q.Pop();
    cout<<q.Empty()<<endl;
    return 0;
}

这里写图片描述

2. 设置一个标记为
设置标记为flag，初始时置flag = 0；每当入队列操作成功，就置flag=1；每当出队列成功就置flag=0.
此时判断队列空的条件为：rear == front && flag == 0
判断队列满的条件为：rear == front&& flag == 1
#include <iostream>
#include <assert.h>
using namespace std;

template<class T, int N = 5>
class Queue
{
public:
    Queue()
        :_front(0)
        ,_rear(0)
        ,_flag(0)
    {}

    void Push(const T& data)
    {
        assert(_flag != 1 || _rear != _front);
        arr[_rear] = data;
        _rear = (_rear+1)%N;
        _flag = 1;
    }

    void Pop()
    {
        assert(_flag != 0 || _rear != _front);
        _front = (_front+1)%N;
        _flag = 0;
    }

    bool Empty()const
    {
        return _flag == 0 && _rear == _front;
    }

    size_t Size()const
    {
        if(_rear == _front && _flag == 1)
            return N;
        else if(_rear == _front && _flag == 0)
            return 0;
        else
            return (_rear - _front + N)%N;
    }

    T& Front()
    {
        assert(_flag != 0 || _rear != _front);
        return arr[_front];
    }

    const T& Front()const
    {
        assert(_flag != 0 || _rear != _front);
        return arr[_front];
    }

    T& Back()
    {
        assert(_flag != 0 || _rear != _front);
        return arr[(_rear-1+N)%N];
    }   

    const T& Back()const
    {
        assert(_flag != 0 || _rear != _front);
        return arr[(_rear-1+N)%N];
    }
private:
    T arr[N];
    int _front;
    int _rear;
    int _flag;
};

int main()
{
    Queue<int, 5> q;
    q.Push(1);
    q.Push(2);
    q.Push(3);
    q.Push(4);
    q.Push(5);

    cout<<q.Back()<<endl;
    cout<<q.Front()<<endl;
    cout<<q.Size()<<endl;

    q.Pop();
    q.Push(6);
    cout<<q.Back()<<endl;
    cout<<q.Front()<<endl;
    cout<<q.Size()<<endl;

    q.Pop();
    q.Pop();
    q.Pop();
    q.Pop();
    q.Pop();
    cout<<q.Empty()<<endl;
    return 0;
}

这里写图片描述

3.设置一个计数器
设置计数器count，初始时置count=0，每当入队列操作成功，就是count加1，每当出队列成功，就使count减1。
此时队列空的判断条件为：count == 0
判断队列满的条件为：count>0 && rear ==front 或者count == MaxSize
#include <iostream>
#include <assert.h>
using namespace std;

template<class T, int N = 5>
class Queue
{
public:
    Queue()
        :_front(0)
        ,_rear(0)
        ,_count(0)
    {}

    void Push(const T& data)
    {
        assert(_count < N);
        arr[_rear] = data;
        _count++;
        _rear = (_rear+1)%N;
    }

    void Pop()
    {
        assert(_count);
        _count--;
        _front = (_front+1)%N;
    }

    bool Empty()const
    {
        return _count == 0;
    }

    size_t Size()const
    {
        return _count;
    }

    T& Front()
    {
        assert(_count);
        return arr[_front];
    }

    const T& Front()const
    {
        assert(_count);
        return arr[_front];
    }

    T& Back()
    {
        assert(_count);
        return arr[(_rear-1+N)%N];
    }   

    const T& Back()const
    {
        assert(_count);
        return arr[(_rear-1+N)%N];
    }
private:
    T arr[N];
    int _front;
    int _rear;
    int _count;
};

int main()
{
    Queue<int, 5> q;
    q.Push(1);
    q.Push(2);
    q.Push(3);
    q.Push(4);
    q.Push(5);

    cout<<q.Back()<<endl;
    cout<<q.Front()<<endl;
    cout<<q.Size()<<endl;

    q.Pop();
    q.Push(6);
    cout<<q.Back()<<endl;
    cout<<q.Front()<<endl;
    cout<<q.Size()<<endl;

    q.Pop();
    q.Pop();
    q.Pop();
    q.Pop();
    q.Pop();
    cout<<q.Empty()<<endl;
    return 0;
}

这里写图片描述

单是顺序存储，若不是循环队列，算法的时间性能不是很好，循环队列虽然能够解决问题，但循环队列又面临着数组可能会溢出的问题。
链式队列
队列的链式存储结构，其实就是线性表的单链表，只不过它只能尾进头出而异，将其称为链队列。
#include <iostream>
#include <assert.h>
using namespace std;

template<class T>
struct Node
{
    Node(const T& data = T())
        :data(data)
        ,next(0)
    {}

    T data;
    Node* next;
};

template<class T>
class LinkQueue
{
public:
    LinkQueue()
        :_pHead(NULL)
        ,_pTail(NULL)
    {}

    void Push(const T& data)
    {
        if(_pTail)
        {
            _pTail->next = new Node<T>(data);
            _pTail = _pTail->next;
        }
        else
        {
            _pHead = new Node<T>(data);
            _pTail = _pHead;
        }
    }

    void Pop()
    {
        assert(_pHead);
        Node<T>* tmp = _pHead;
        if(_pHead->next)
            _pHead = _pHead->next;
        else
        {
            _pHead = NULL;
            _pTail = NULL;
        }
        free(tmp);
        tmp = NULL;
    }

    bool Empty()
    {
        return NULL == _pHead;
    }

    size_t Size()
    {
        size_t size = 0;
        Node<T>* tmp = _pHead;
        while(tmp)
        {
            size++;
            tmp = tmp->next;
        }
        return size;
    }

    T& Front()
    {
        assert(_pHead);
        return _pHead->data;
    }

    T& Back()
    {
        assert(_pTail);
        return _pTail->data;
    }

    ~LinkQueue()
    {
        while(_pHead)
        {
            Node<T>* tmp = _pHead;
            if(_pHead->next)
                _pHead = _pHead->next;
            free(tmp);
            tmp = NULL;
            _pHead = NULL;
        }
    }
private:
    Node<T>* _pHead;
    Node<T>* _pTail;
};

int main()
{
    LinkQueue<int> lq;
    lq.Push(1);
    lq.Push(2);
    lq.Push(3);
    lq.Push(4);

    cout<<lq.Front()<<endl;
    cout<<lq.Back()<<endl;
    cout<<lq.Size()<<endl;
    cout<<lq.Empty()<<endl;

    lq.Pop();
    cout<<lq.Front()<<endl;
    cout<<lq.Back()<<endl;
    cout<<lq.Size()<<endl;

    lq.Pop();
    lq.Pop();
    lq.Pop();
    cout<<lq.Empty()<<endl;

    return 0;
}

运行结果：
这里写图片描述

░冷░月░
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
队列
love_jing_forever的博客
04-29 421
队列是一种动态集合，且在其上进行的DELETE操作所移除的元素是预先设定的。在队列中，被删去的总是在集合中存在时间最长的那个元素：队列实现的是一种先进先出策略。 队列也分为两种：顺序队列和循环队列。 一、顺序队列（c++实现）： //顺序队列; #include <iostream> using namespace std;template <typename T> class orderQueue
栈及栈溢出
风雨无阻
07-05 1533
1、内存空间分布 常规的内存布局，在UNIX环境高级编程中: 代码段: （code segment/text segment）通常是指用来存放程序执行代码的一块内存区域。这部分区域的代码属于只读。在代码段中，字符串常量也属于这部分。整个程序的代码，以及所有的常量。这部分内存是是固定大小的，只读的。 数据段：数据段（data segment）通常是指用来存放程序中已初始化的全局变量的一块内存区域。数据段属于静态内存分配。初始化为非零值的全局变量。 BSS段:（bss segment）通常是指用来存
C语言-实现栈的基本操作(顺序栈)
m0_63223213的博客
07-01 8614
下面用两种方式来构建顺序栈，分别是将top定义为指针类型和将top定义成指针下标两种形式，实现栈的基本操作。
栈讲解
wyzworld的博客
09-21 667
栈 栈 stack 限定仅在表尾进行插入删除操作的线性表，表尾称栈顶 top 表头称栈底 bottom 栈又称先进后出的线性表 LIFO 栈抽象数据类型定义 ADT Stack{ 数据对象 数据关系 基本操作 InitStack(&amp;S) //构造空栈 DestroyStack(&amp;S) //销毁栈 ClearStack(&amp;S) //清空栈 Stac...
《啊哈算法》第二章栈，队列，链表（解析+代码）
IT OR 考公？
01-13 1470
队列，栈，链表，模拟链表✊ 学如逆水行舟，不进则退✊
栈和队列知识点
weixin_52238184的博客
01-05 178
栈和队列
Queue_栈队列_pop_
09-30
任务描述栈和队列都提供 Push/Pop 两种操作，其中 Push：加入一个元素。Pop：弹出一个元素。给出一个线性结构的进出顺序，判定这个结构是栈还是队列。(40’) 输入描述第一行输入一个整数s，代表有s组测试数据。第一...
第一讲：线性表和栈队列.ppt
07-12
1、5个男生3个女生排成一排,3个女生要排在一起,有多少种不同的排法?
线性表栈队列的所有源文件
11-08
线性表、栈和队列是计算机科学中最基础的数据结构之一，它们在各种算法和程序设计中都有着广泛的应用。这个压缩包提供了这些数据结构的线性存储和链式存储结构的源文件，对于理解它们的工作原理和实际操作非常有帮助...
Python 实现数据结构中的的栈队列
09-19
栈和队列是两种基本且常用的数据结构，它们在Python中有着多种实现方式。本篇文章将详细探讨如何使用Python来实现这些数据结构。 首先，栈（Stack）是一种后进先出（LIFO, Last In First Out）的数据结构，它遵循...
C语言-数据结构-栈队列实现
03-10
本主题关注的是如何使用C语言来实现数据结构中的栈和队列，这是两种基础但非常重要的抽象数据类型（ADT）。 栈（Stack）是具有后进先出（LIFO）特性的数据结构。它类似于一个堆叠的盘子，最新的元素被放在顶部，...
栈(stack)和队列（queue）
weixin_45608986的博客
04-09 406
一、栈 1.概念 栈（Stack）是存放数据对象的一种特殊容器，是一种程线性排列的数据结构，在这种结构中我们只能访问最新添加的数据。栈就像一个又细又长的圆筒，圆筒一端封闭，一端开口，往圆筒里放入圆球，先放入的在圆筒底部，后放入的靠近圆筒出口。 ...
【Python数据结构系列】❤️《栈（顺序栈与链栈）》——❤️知识点讲解+代码实现
码农-Vax天道的时间宝藏
08-06 3913
灵魂拷问：为什么要学数据结构？ 数据结构，直白地理解，就是研究数据的存储方式。数据存储只有一个目的，即为了方便后期对数据的再利用。因此，数据在计算机存储空间的存放，决不是胡乱的，这就要求我们选择一种好的方式来存储数据，而这也是数据结构的核心内容。 可以说，数据结构是一切编程的基本。学习数据结构是学习一种思想：如何把现实问题转化为计算机语言的表示。 对于学计算机的朋友来说，学习数据结构是基本功。而对于非计算机专业，但是未来想往数据分析、大数据方向发展、或者在Python的使用上能有一个大的跨越的朋友来说，学.
栈与队列（详解）
c_study__c的博客
09-28 1707
栈与队列（详解）
栈与队列（超详细）
qq_45792749的博客
03-29 1万+
目录一、栈（Stack）什么是栈？栈的常见方法一级目录一级目录 一、栈（Stack） 什么是栈？ 栈其实就是一种数据结构 - 先进后出（先入栈的数据后出来，最先入栈的数据会被压入栈底） 什么是java虚拟机栈？ java虚拟机栈只是JVM当中的一块内存，该内存一般用来存放 例如：局部变量 当调用函数时，我们会为函数开辟一块内存，叫做 栈帧，在 java虚拟机栈中开辟，具体如下。 常见考点：不可能的出栈顺序 这道题该怎么分析呢？ 首先我们知道，出栈时拿到的第一个元素为4，那么4必须入栈，因为入栈的顺序是
栈和队列（详细版，一看就懂。包含栈和队列的定义、意义、区别，实现）
热门推荐
weixin_47252176的博客
03-10 2万+
栈和队列 一、栈和队列的定义、区别，存在的意义 1.栈的定义 （1）栈：栈实际上是一种线性表，它只允许在固定的一段进行插入或者删除元素，在进行数据插入或者删除的一段称之为栈顶，剩下的一端称之为栈顶。其遵循的原则是后进先出。 （2）栈的核心操作：三大核心操作，入栈，出栈，取栈顶元素 （3）对于栈的形象理解：子弹的弹夹我们一定见过，子弹在被压入的时候就相当于是一个个元素，而弹夹就相当于是栈。先被压入的子弹是最后被打出的，先压入的元素是最后出来的，也就是后进先出。 2.队列的定义 （1）队列：首先队列也是一种特殊
【详解栈Stack与队列Queue】
TheMyth142857的博客
05-24 2088
本章主要介绍了栈和队列这两种数据结构，它们属于特殊线性表，通常在学习栈的时候对比学习队列。本文如有不足之处，请广大读者提出宝贵意见！！！谢谢！！！
互联网生态峰会PPT模板
最新发布
07-13
【作品名称】：互联网生态峰会PPT模板 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
linux内核协议栈队列
05-20
Linux内核协议栈队列是指在Linux内核中，用于处理网络数据包的一组队列。这些队列按照不同的网络协议和处理阶段划分，分别用于存储和处理不同类型的网络数据包。 在Linux内核中，网络数据包在经过协议栈处理后，会被放入不同的队列中，这些队列包括： 1. 接收队列（Receive Queue）：用于存储从网络上接收到的数据包，在数据包经过网络接口驱动程序的处理后，会被放入接收队列中等待协议栈处理。 2. 传输队列（Transmission Queue）：用于存储将要发送到网络上的数据包，在协议栈处理完数据包后，会被放入传输队列中等待网络接口驱动程序发送。 3. 处理队列（Processing Queue）：用于存储协议栈中正在处理的数据包，在数据包经过协议栈某一层的处理后，会被放入处理队列中等待下一层继续处理。 4. 等待队列（Waiting Queue）：用于存储因为某种原因无法处理的数据包，在数据包无法被处理时，会被放入等待队列中等待下一次处理。 通过使用这些队列，Linux内核可以高效地处理网络数据包，并保证数据包在经过协议栈处理后能够正确地被发送或接收。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值