第四章：——栈、队、堆

已于 2022-07-18 10:32:14 修改
阅读量317 收藏
点赞数 1
分类专栏： 算法 文章标签： c++ java 开发语言
于 2022-07-18 10:26:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44722108/article/details/125843013
版权
本文详细介绍了栈、队列和堆的基本概念，以及如何通过这些数据结构实现特殊功能，如用队列模拟栈、用栈实现队列、设计常数级复杂度的栈和最小值查找，以及解决数组中第K大数和中位数问题。涉及到了堆的应用，如最大堆和最小堆在Kth大数查找中的角色。
摘要由CSDN通过智能技术生成

第四章：——栈、队、堆

（1）预备知识：

栈：先进后出。

队列：先进先出。

栈：

S.top():取出栈顶（仅仅是获得栈顶的数值）

S.empty():判断栈是否为空

S.push(x):将x添加至栈

S.pop():弹出栈顶（把栈顶的数值弹出删除）

S.size():栈的存储元素个数

队列：

Q.empty():判断队列是否为空

Q.front():返回队列头部元素

Q.back():返回队列尾部元素

Q.pop():弹出队列头部元素

Q.push(x):将x添加至队列

Q.size():返回队列的存储元素的个数

栈如何声明：std::stack S;//栈的关键字是stack

队列如何声明：std::queue Q;//队列的关键字是queue

（2）例1：使用队列实现栈：

设计一个栈，支持基本的操作，这个栈的内部存储数据的结构为队列，队列的方法只能包括push、peek(front)、pop、size、empty等标准队列的方法：意思是用队列实现栈

方法论述：

push(x):将元素x压入栈中

pop()：弹出（移除）栈顶元素

top():返回栈顶元素

empty():判断栈是否是空

class MyStack
{
    public:
    MyStack()
    {}
    void push(int x)
    {}
    int pop()
    {}
    int top()
    {}
    bool empty
    {}
};

这边的重点思路就是通过利用：一个临时队列来实现顺序的调整：

#include<queue>
class MyStack
{
  public:
    MyStack(){}
    void push(int x)
    {
        std::queue<int>temp_queue;
        temp_queue.push(x);
        while(!_data.empty())
        {
            temp_queue.push(_data.front());
            _data.pop();
        }
        while(!temp_queue.empty())
        {
            _data.push(temp_queue.front());
            temp_queue.pop();
        }
    }
    int pop()
    {
        int x=_data.front();//取栈顶元素，即为队列头部元素
        _data.pop();
        return x;//返回取出的队列头部元素x，即为栈顶元素
    }
    int top()
    {
        return _data.front();//返回栈顶即直接返回队列头部元素
    }
    bool empty()
    {
        return _data.empty();
    }
    private:
    std::queue<int>_data;//_data数据队列存储元素的顺序就是栈存储元素的顺序
};

（3）例2：使用栈实现队列：设计一个队列，支持基本的队列操作，这个队列的内部存储数据的结构为栈，栈的方法只能包括push、top、pop、size、empty等标准的栈方法。

方法论述：

push(x):将元素x压入队列中

pop()：弹出（移除）队列头部元素

peek():返回队列头部元素

empty():判断队列是否是空

class MyQueue
{
    public:
    MyQueue()
    {}
    void push(int x)
    {}
    int pop()
    {}
    int top()
    {}
    bool empty
    {}
};

思路重点：添加一个临时栈：

#include <stack>
class MyQueue
{
  public:
    MyQueue(){}
    void push(int x)
    {
        std::stack<int>temp_stack;
        while(!_data.empty)
        {
            temp_stack.push(_data.top());
            _data.pop();
        }
        temp_stack.push(x);
        while(!temp_stack.empty())
        {
            _data.push(temp_stack.top());
            temp_stack.pop();
        }
    }
    int pop()
    {
        int x=_data.top;
        _data.pop();
        return x;
    }
    int peek()
    {
        return _data.top();
    }
    bool empty()
    {
        return _data.empty();
    }
    private:
    std::stack<int>_data;
};

(4)例3：设计一个栈，支持如下操作，这些操作的算法复杂度需要是常数级，O(1):

方法概述：

push(x):将元素x压入栈中

pop():弹出（移除）栈顶元素

top():返回栈顶元素

getMin():返回栈内最小元素

class MinStack
{
  public:
    MinStack(){}
    void push(int x)
    {}
    void pop(){}
    int top(){}
    int getMin(){}//返回栈内最小元素
};

思考关键：用另一个栈，存储各个状态的最小值：

#include <stdio.h>
#include <stack>

class MinStack
{
  public:
    void push(int x)
    {
        _data.push(x);
        if(_min.empty()) _min.push(x);
        else{
            if(x>_min.top())
                x=_min.top();
            _min.push(x);
        }
    }
    void pop()
    {
        _data.pop();
        _min.pop()//数据栈喝最小栈同时弹出
    }
    int top()
    {
        return _data.top();
    }
    int getMin()
    {
        return _min.top();
    }
    private:
    std::stack<int> -data;
    std::stack<int> _min;
};

（5）例4：合法的出栈序列：已知从1至n的数字序列，按顺序入栈，每个数字入栈后即可出栈，也可在栈中停留，等待后面的数字入栈出栈后，该数字再出栈，求该数字序列的出栈序列是否合法？

设置一个栈依按照题中给出的出栈顺序，依次进入，发现最后栈不能为空，则说明不合理，为空则说明合理

#include <stack>
#include <queue>

bool check_is_valid_order(std::queue<int>&order)
{
    std::stack<int>S;
    int n=order.size();
    for(int i=0;i<n;i++)
    {
        S.push(i);
        while(!S.empty()&&S.top()==order.front())
        {
            order.pop();
            S.pop();
        }
    }
    if(!S.empty())
        return fasle;
    else return true;
}

(6)例5：简单的计算器：设计一个计算器，输入一个字符串存储的数学表达式，可以计算包括“（”、“）”、“+”、“-”四种符号的1数学表达式，输入的数学表达式字符串保证是合法的。输入的数学表达式中可能存在空格字符。

//字符串转换数字
#include <stdio.h>
#include <string>

int main()
{
    int number=0;
    std::string s="12345";
    for(int i=0;i<s.length;i++)
        number=number*10+s[i]-'0';
    printf("number =%d\n",number);
    return 0;
}

//计算
void compute(std::stack<int>&number stack,std::stack<char>&operation stack)
{
    if(number_stack.size<2) return;
    int num1=number_stack.top();
    number_stack_pop();
    int num2=number_stack.top();
    number_stack_pop();
    if(operation_stack.top()=='+')
        number_stack.push(num1+num2);
    else if(operation_stack.top()=='-')
        number_stack.push(num1-num2);
    operation_stack.pop();
}

#include <string>
#include <stack>

class Solution
{
    public:
    int calculate(std::string s)
    {
        static const int STATE_BEGIN=0;
        static const int NUMBER_STATE=1;
        static const int OPERATION_STATE=2;
        std::stack<int>number_stack;
        std::stack<char>operation_stack;
        int number=0;
        int STATE=STATE_BEGIN;
        int compuate_flag=0;
        for(int i=0;i<s.length();i++)
        {
            if(s[i]==' ')
                continue;
            switch(STATE)
            {
                case STATE_BEGIN:
                    if(s[i]>='0'&&s[i]<='9')
                        STATE=NUMBER_STATE;
                    else
                        STATE=OPERATION_STATE;
                    i--;
                    break;
                case NUMBER_STATE:
                    if(s[i]>='0'&&s[i]<='9')
                        number=number*10+s[i]-'0';
                    else
                    {
                        number_stack.push(number);
                        if(compuate_flag==1)
                            compute(number_stack,opteration_stack);
                        number=0;
                        i--;
                       STATE=OPERATION_STATE;
                        break;
                    }
                 case OPERATION_STATE:
                        if(s[i]=='+'||s[i]=='-')
                        {
                            operation_stack.push(s[i]);
                            compuate_flag=1;
                        }
                        else if(s[i]=='(')
                        {
                            STATE=NUMBER_STATE;
                            compuate_flag=0;
                        }
                        else if(s[i]>='0'&&s[i]<='9')
                        {
                            STATE=NUMBER_STATE;
                            i--;
                        }
                        else if(s[i]==')')
                            compute(number_stack,opteration_stack);
                    if(number!=0)
                    {
                        number_stack.push(number);
                		compute(number_stack,opteration_stack);
                    }
                    if(number==0&&number_stack.empty())
                    {
                        return 0;
                    }
                    return number_stack.top();
            }
        }
    }
};

(7)堆的预备：

（8）例6：数组中第K大的数：已知一个未排序的数组，求这个数组中第K大的数字。

直接对数组排序是O(NlogN)的时间复杂度。
所以就可以考虑用最大堆和最小堆来解决问题。

#include<vector>
#include<queue>
class Solution:
{
    public:
    int findKthLargest(std::vector<int>&nums,int k)//最小堆
    {
        std::priority queue<int,std::vector<int>,std::greater<int>> Q;
        for(int i=0;i<nums.size();i++)
        {
            if(Q.size()<k)
                Q.push(nums[i]);
            else if(Q.top()<nums[i])
            {
                Q.pop();
                Q.push(nums[i]);
            }
        }
        return Q.top();
    }
}

（9）例9：寻找中位数：设计一个数据结构，该数据结构动态维护一组数据，且支持如下操作：

（1）添加元素：void addNum(int num)，将整型num添加至数据结构中。

（2）返回数组的中位数：double findMedian(),返回其维护的数据的中位数。

中位数的定义为：

（1）若数据个数为奇数，中位数是该数组排序后中间的数。[1,2,3]->2

（2）若数据个数为偶数，中位数是该组数排序后中间的两个数字的平均值。[1,2,3,4]->2.5

void addNum(int num)
{
    if(bid_queue.empty())
    {
        bid_queue.push(num);
        return ;
    }
    if(big_queue.size()==small_size())
    {
        if(num<big_queue.top())
            big_queue.push(num);
        else
            small_queue.push(num);
    }
    else if(big_queue.size()>small_queue.size())
    {
            if(num<big_queue.top())
            {
                small_queue.push(big_queue.top());
                big_queue.pop();
                big_queue.push(num);
            }
            else{
                small_queue.push(num);
            }
      }
      else if(big_queue.size()<small_queue.size())  
      {
          if(num>small_queue.top())
          {
              big_queue.push(small_queue.top());
              small_queue.pop();
              small_queue.push(num);
          }
          else{
              big_queue.push(num);
          }
      }
    }
}

double findMedian()
{
    if(big_queue.size()==small_queue.size())
    {
        return (big_queue.top()+small_queue.top())/2;
    }
    else if(big_queue.size()>small_queue.size())
    {
        return big_queue.top();
    }
    else if(big_queue.size()<small_queue.size())
    {
        return small_queue.top();
    }
}

          small_queue.pop();
          small_queue.push(num);
      }
      else{
          big_queue.push(num);
      }
  }
}

}


```c++
double findMedian()
{
    if(big_queue.size()==small_queue.size())
    {
        return (big_queue.top()+small_queue.top())/2;
    }
    else if(big_queue.size()>small_queue.size())
    {
        return big_queue.top();
    }
    else if(big_queue.size()<small_queue.size())
    {
        return small_queue.top();
    }
}
当个老六儿~
关注
专栏目录
《低功耗方法学》翻译——第一章：介绍
记录所学，分享知识，结识挚友
01-03 1749
第一章：介绍
Java核心技术第十四章——线程
RoadSon的博客
11-26 181
1. 使用线程给其他任务提供机会 可以将移动球的代码放置在一个独立的线程中， 运行这段代码可以提高弹跳球的响应能力。实际上，可以发起多个球， 每个球都在自己的线程中运行。 由于每个线程都有机会得以运行，所以在球弹跳期间， 当用户点击Close 按钮时， 事件调度线程将有机会关注到这个事件， 并处理“ 关闭” 这一动作。 Runnable runnable = () -> { ...
堆， 栈， 队区别
暮水的专栏
07-31 317
浅薄理解，深刻的等看完原理再说吧。 堆：程序运行时请求操作系统给自己分配的内存空间 栈：先进后出，从栈的末尾出，只有一个活口。 队：先进先出，从队头出，从队尾添加元素，两个活口。 ...
栈、队
weixin_34329187的博客
12-05 92
本文为个人学习笔记。 昨天学习了表，写了个简单的单链表。今天看了下栈和队。 　　说白了：栈就是一个只能在头部插入和删除的表，遵循后进先出的原则；而队与栈的区别就是先进先出，从头部插入，底部删除。 附代码 1 #include <iostream> 2 using namespace std; 3 4 typedef struct StackNode 5 ...
栈和队
难不难的博客
05-29 684
一、Stack（栈后进先出）的方法 1. public void push（int node）  把项 压入栈顶。其作用与 addElement (node) 相同。   不一定是int，可以是节点 stack.push(node); 2. public void pop () 移除栈顶对象，并作为函数的值 返回该对象。 stack.pop(); 3. publi
数据结构之栈和队
又是重名了
10-22 965
数据结构————栈 我们在这里对于栈进行一个整理，这里说的栈，是指的顺序栈，链表栈等我后期将链表整理好了在一起发上来。 栈 这里栈我只是简述一下关于栈的知识，具体的一些细的知识自己百度吧，我写这一篇文章的目的是为了能够手写栈。 首先，栈基本介绍，栈是什么呢？栈是一个数据结构，类似的话就是一个水瓶，你有ABC三个物品，装入栈里面，就是ABC，这是入栈的熟悉，入栈就是将元素放进栈中，而如果我们需要将元...
数据结构---栈和队
dejeya2381的博客
03-27 335
1.栈 1.1栈的定义 栈是只能在表的一端进行插入和删除操作的线性表，其中允许掺入与删除的一端称为栈顶（top），另一端则称为栈底（bottom）。对于栈（a1,a2,...an）,元素a1为栈底元素，an为栈顶元素。n=0时为空栈。进栈与出栈分别称为压入和弹出操作。栈的特点是先进后出。 1.2顺序栈 顺序栈可以使用向量作为栈的存储结构，用一维数组s[1:m]表示，用...
数据结构第4章：栈、队列与优先级队列详解
第4章 "栈和队列" 是数据结构课程中的核心章节，主要探讨了三种线性数据结构：栈、队列和优先级队列。这些结构具有顺序访问的特点，并且在存取上有限制，分别是栈的“后进先出”（LIFO）原则，队列的“先进先出”...
第八章：面向对象编程 —— 初级
weixin_55192559的博客
04-05 1293
本章主讲：类与对象的创建；属性的创建和使用；方法的创建和使用；构造器的创建和使用；this关键字。 需要掌握：匿名对象的使用、返回数据类型与return的使用、类作为参数和返回数据类型的应用、方法递归、方法的三大应用之二。 需要理解：JVM的内存机制、属性与变量的区别、属性与方法的机制、作用域、this的本质
第二章：线性表、栈和队列
WANGHAOXIN364的博客
02-13 2009
什么是线性表？ 线性表是由n个相同类型的数据元素组成的有限序列，它是最基本的一种线性结构。顾名思义，线性表就像是一条线，不会分叉。线性表有唯一的开始和结束，除了第一个元素外，每个元素都有唯一的直接前驱，除了最后一个元素外，每个元素都有唯一的直接后继。线性表有两种存储方式，分别是顺序存储和链式存储。采用顺序存储的线性表称为顺序表，采用链式存储的线性表称为链表。链表又分为单链表、双向链表和循环链表。 顺序表：顺序表采用顺序存储方式，元素存储是连续的，中间不允许有空，因此顺序表可以快速定位是第几个...
链表队栈堆
a716121的专栏
09-23 170
/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) { val = x; } * } */ class Solution { public ListNode reverseList(ListNode head) { if(head==null||head.next==n...
栈队列
wyy的博客
04-15 165
//栈 //public class Stack extends Vector 已经过时 Stack stack = new Stack(); //双端队列 可以作为栈来使用 push() 入栈 pop() 出栈 peek() 获取栈顶元素 Deque deque ; //ArrayDeque 底层是数组 LinkedList 底层是链表 //队列 Queue queue; //ArrayDeque 底层是数组 LinkedList 底层是链表 //表 List list ; //模拟摞盘子 De
heap和stack有什么区别
weixin_33738982的博客
07-21 311
1.heap是堆，stack是栈。2.stack的空间由操作系统自动分配和释放，heap的空间是手动申请和释放的，heap常用new关键字来分配。3.stack空间有限，heap的空间是很大的自由区。在Java中，若只是声明一个对象，则先在栈内存中为其分配地址空间，若再new一下，实例化它，则在堆内存中为其分配地址。4.举例：数据类型 变量名；这样定义的东西在栈区。如：Object a =null...
栈队数据结构全集
gexiaobaoHelloWorld的专栏
09-07 1182
1，栈 1.1，用数组实现栈 template class Stack{ private: int stk_top; int max_top; T* stk; public: Stack(int max = 100); ~Stack(){delete [] stk}; bool empty()const{return stk_top == -1;} boo
数据结构与算法之栈和队
最新发布
zjy521_的博客
06-10 104
数据结构与算法系列之栈与队
数据结构——栈、堆以及队列
lingwu_hb的博客
09-27 484
洛谷P1981 表达式求值 1）涉及栈的知识点不太多，主要是栈的进栈和出栈操作。注意在c++中，pop() 没有返回值，一般和 top() 结合起来使用！ 一些细节： c++ 的 cin 会根据输入的类型自动进行判断读取，不必像 c 语言那么僵硬的一直用字符类型进行处理。 c++ 里面的 cin/cout 效率不如 scanf()/printf() ，所以在数据很大的时候最好还是使用后者。 洛谷P5788单调栈 1）单调栈概念：栈中元素递增或者递减。 2）应用：单调栈内存储的元素一般都为下标，而不是真正
栈、堆、队列 深入理解
huangpb的博客
12-21 5528
栈、堆、队列都属于常见数据结构。 一、栈 1.1 简介 栈 是一种遵循 后进先出（LIFO） 原则的有序集合。新添加和待删除的数据都保存在栈的同一端栈顶，另一端就是栈底。新元素靠近栈顶，旧元素靠近栈底。 栈由编译器自动分配释放。栈使用一级缓存。调用时处于存储空间，调用完毕自动释放。 举个栗子：乒乓球盒子/搭建积木 1.2 基本数据结构的存储（存储栈） javaScript中，...
栈 队列 堆
Kingrrr的博客行程
03-07 237
简要介绍数据结构之栈队列堆
【数据结构】栈与队列
Dooo_yh的博客
01-10 1103
解决栈与队列90%的问题
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值