模拟实现堆+堆的应用

最新推荐文章于 2024-02-05 23:58:17 发布
最新推荐文章于 2024-02-05 23:58:17 发布
阅读量393 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 结构 树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhuohaiyy/article/details/78254440
版权

堆数据结构是一种数组对象，它可以被看作一颗完全二叉树的结构（数组是完全二叉树），堆是一种静态结构。
堆分为最大堆和最小堆。
最大堆：每个父结点都大于孩子结点。
最小堆：每个父结点都小于孩子结点。

堆的优势：效率高，可以找最大数最小数，增删的时间复杂度为lgN，快
怎么找最后一个叶子结点？
找到最后一个叶子结点（左孩子为空就是叶子结点），由于堆是静态结构，所以我们要通过计算下标的方法找，计算它的孩子是否超出了数组范围。

下图就是一个堆（以下举例都会用这个堆）
单发

堆的基本实现

我们先建立一个最大堆

首先，堆的成员应该是一个数组，但是这个数组不能是固定的大小，因为我们要实现堆的插入删除，所以我们可以用库中的vector来创建数组。
即vector<T> _a;

构造函数
首先我们要写一个无参的构造函数，因为系统不会自动生成无参的构造函数，无参的构造函数刚开始堆是空的，不需要做任何事。

Heap()
{}

我们还需要写一个带参数的构造函数
给一个一定大小的数组。
我开空间，我们开空间用reserve()，因为size是一定的，如果用resize也可以但是我们就多初始化了一次。
然后逐一的用循环插入元素，
建堆，建堆的思想是：先找到最后一个非叶子结点，然后向下调整，在找到倒数第二个非叶子结点，向下调整，直到找到根节点。

Heap(T* a, size_t n)
    {
        _a.reserve(n);//开空间
        for (size_t i = 0; i < n; ++i)
        {
            _a.push_back(a[i]);

        }
        //建堆,找最后一个非叶子节点
        for (int i = (_a.size() - 2) / 2; i >= 0; --i)
        //不用size_t，因为i在这可能等于0
        {
            AdjustDown(i);
        }
    }

向下调整AdjustDown()

//向下调整
    void AdjustDown(int root)
    {
        int parent = root;
        int child = parent * 2 + 1;//默认为左孩子
        while (child < _a.size())
        {
            //选出大孩子
            if (child+1 < _a.size() && _a[child + 1] > _a[child])
            {
                ++child;
            }
            //如果孩子大于父亲则交换，否则跳出循环
            if (_a[child] > _a[parent])
            {
                swap(_a[child], _a[parent]);//值交换
                parent = child;
                child = parent * 2 + 1;
            }
            else
            {
                break;
            }
        }
    }

向上调整AdjustUp()
向上调整的思想和向下调整的思想是相同的
但在这里我们需要注意的是循环的结束条件：

while(child>0)
//while(parent>=0)
这两个我们只能使用第一个，因为父亲的计算方法为(child-1)/2，所以父亲不会为负数，从而导致程序死循环。

//向上调整
    void AdjustUp(int child)
    {
        int parent = (child - 1) / 2;
        while (child > 0)
        {
            if (_a[child] > _a[parent])
            {
                swap(_a[parent], _a[child]);
                child = parent;
                parent = (child - 1) / 2;
            }
            else
            {
                break;
            }
        }

    }

插入元素Push
堆的插入元素就在最后插入，所以我们在最后插入元素之后，向上调整即可

    void Push(const T&x)
    {
        _a.push_back(x);
        AdjustUp(_a.size() - 1);
    }

删除元素Pop
最大堆的删除元素，是删除最大的元素。
如图
的
我们不能直接删除19
原因：
1，vector不提供pop_front
2，如果直接删除19，那我们整个堆就会乱掉，重新构造这个堆的话，代价太大。

所以我们可以先将第一个结点和最后一个结点进行交换，然后删除最后一个结点，然后再进行向下调整。
代码实现如下：

//删除最大数
    void Pop()
    {
        assert(!_a.empty());
        swap(_a[0], _a[_a.size() - 1]);
        _a.pop_back();
        AdjustDown(0);

    }

取第一个元素Top()
堆的Top()实现相对简单一些，返回_a[0]。

//取顶元素
    T& Top()
    {
        assert(!_a.empty());
        return _a[0];
    }

判断它是否为最大堆
判断这个堆是否为最大堆，我们有两种方法可以解决
1，递归。
2，非递归。
我们先来看一下递归：

    bool IsHeap()
    {
        return _IsHeap(_root);//递归
    }
    bool _IsHeap(int root)
    {
        if (root >= _a.size())//不存在,是大堆
            return true;
        int left = root * 2 + 1;
        int right = root * 2 + 2;
        if (left < _a.size())
        {
            if (_a[left] > _a[root])
            {
                return false;
            }
            if (right < _a.size())
            {
                if (_a[right] > _a[root])
                {
                    return false;
                }
            }
        }
        return _IsHeap(left) && _IsHeap(right);

    }

非递归：

bool IsHeap()
    {
        //非递归
        for (size_t i = 0; i <= (_a.size() - 2) / 2; i++)
        {
            int left = i * 2 + 1;
            int right = i * 2 + 2;
            //最后一个非叶子结点左孩子一定存在，但是右孩子不一定存在
            if (_a[i] < _a[left] || (right < _a.size() && _a[i] < _a[right]))
            {
                return false;
            }
            return true;
        }

    }

堆的应用

1，优先级队列
（谁的优先级高（看具体场景）谁先出）
用堆实现

template<class T, class Compare = Greater<int>>
class PriorityQueue
{
    void Push(const T& x) // O(lgN)
    {
        _hp.Push(x);
    }

    void Pop() // O(lgN)
    {
        _hp.Pop();
    }

    T& Top()
    {
        return _hp.Top();
    }

protected:
    Heap<T, Compare> _hp;
};

2，堆排序（升序）
升序：建最大堆，然后最大的和最后一个结点进行交换，然后size–，然后在用次大的和size-1进行交换，直到只剩下最后一个数，停止交换。
如图：
东方舵手
代码如下：

//堆排序（升序）
void adjustDown(int* a,size_t n,int root)
{
    int parent = root;
    int child = parent * 2 + 1;
    while (child<n)
    {
        if (child + 1 < n&&a[child + 1] > a[child])
        {
            ++child;
        }
        if (a[child] > a[parent])
        {
            swap(a[child], a[parent]);
            parent = child;
            child = parent * 2 + 1;
        }
        else
        {
            break;
        }

    }
}

void HeapSort(int*a, size_t n)
{
    //建堆(升序建大堆)
    for (int i = (n - 2) / 2; i >= 0; --i)
    {
        adjustDown(a, n, i);
    }
    int end = n - 1;
    while (end >= 0)
    {
        swap(a[0], a[end]);
        adjustDown(a, end, 0);
        --end;
    }
}

3，在N个数中找出最大的前K个数
N个数找出最大的前K个
思想：如果我们N非常大的时候， 内存是放不下的
建立一个K大小的堆，如果建立最大堆，那么只能找到最大的一个，所以我们要建立小堆
方法：遍历N个数，先用前K个数建立一个小堆，下一个数如果比堆顶数据大的话，那么替代堆顶数据（因为堆顶数据是最小的），并且向下调整，最后堆里面的就是最大的前K个数，最大的前K个一定会进堆。
时间复杂度为N*lgK(严格来说为K*lgK+(N-K)*lgK，但是N一般远大于K，所以时间复杂度为N*lgK)。建立K个数的堆为的时间复杂度为N*lgN
代码实现如下

//向下调整（小堆）
void AdjustDown(int* a, size_t n, int root)
{
    assert(a);
    int parent = root;
    int child = parent * 2 + 1;
    while (child<n)
    {
        if (child + 1 < n&&a[child + 1] < a[child])
        {
            ++child;
        }
        if (a[child] < a[parent])
        {
            swap(a[child], a[parent]);
            parent = child;
            child = parent * 2 + 1;
        }
        else
        {
            break;
        }

    }


}
//N个数里面找最大的前K个
const size_t N = 10000;
const size_t K = 10;
void TopK()
{
    int a[N] = { 0 };
    for (size_t i = 0; i < N; ++i)
    {
        a[i] = rand() % N;//给随机数
    }
    //为了验证
    a[0] = N + 100;
    a[100] = N + 101;
    a[2] = N + 102;
    a[50] = N + 105;
    a[1000] = N + 100;
    a[1005] = N + 1550;
    a[888] = N + 130;
    a[9998] = N + 100;
    a[9999] = N + 100;
    a[9444] = N + 100;


    //堆就是一个数组
    int heap[K] = { 0 };
    //将前K个数放入堆中
    for (size_t i = 0; i < K; ++i)
    {
        heap[i] = a[i];
    }

    // 建堆
    for (int i = (K - 2) / 2; i >= 0; --i)
    {
        AdjustDown(heap, K, i);
    }

    for (size_t i = K; i < N; ++i)
    {
        if (a[i] > heap[0])
        {
            heap[0] = a[i];
            AdjustDown(heap, K, 0);
        }
    }

    for (size_t i = 0; i < K; ++i)
    {
        cout << heap[i] << " ";
    }

}

其中堆的应用最后两个（堆排序，找N个数中最大的前K个数）
我们可以通过调整AdjustDown（）函数可以实现堆排序的降序以及，找N个数中最小的前K个数，这里就不给大家举例子了。

最小堆和最大堆在代码上的区别主要是在向上调整和向下调整的区别上（只是三个符号上的区别，但是写两个函数代价大），我们要增强代码的复用性，我们可以用仿函数，以下的完整代码我们用仿函数来实现出来

模拟实现堆完整代码

#pragma once
#include<iostream>
#include<assert.h>
#include<vector>
using namespace std;

template<class T>
struct Less
{
    bool operator()(const T& left, const T& right) const
    {
        return left < right;
    }
};

template<class T>
struct Greater
{
    bool operator()(const T& left, const T& right) const
    {
        return left > right;
    }
};


template<class T,class Compare=Greater<T>>
class Heap
{
public:
    Heap()//无参的构造函数（系统不会给无参构造函数），开始堆是空的不需要做什么事
    {}
    Heap(T* a, size_t n)
    {
        _a.reserve(n);//开空间
        for (size_t i = 0; i < n; ++i)
        {
            _a.push_back(a[i]);

        }
        //建堆,找最后一个非叶子节点
        for (int i = (_a.size() - 2) / 2; i >= 0; --i)//不用size_t，因为i在这可能等于0，用size_t会死循环
        {
            AdjustDown(i);
        }
    }
    //向下调整
    void AdjustDown(int root)
    {
        Compare com;
        int parent = root;
        int child = parent * 2 + 1;//默认为左孩子
        while (child < _a.size())
        {
            //选出大孩子
            //if (child+1 < _a.size() && _a[child + 1] > _a[child])
            if (child+1 < _a.size() && com(_a[child + 1] , _a[child]))
            {
                ++child;
            }
            //如果孩子大于父亲则交换，否则跳出循环
            //if (_a[child] > _a[parent])
            if (com(_a[child],_a[parent]))
            {
                swap(_a[child], _a[parent]);//交换值
                parent = child;
                child = parent * 2 + 1;
            }
            else
            {
                break;
            }
        }
    }
    //向上调整
    void AdjustUp(int child)
    {
        Compare com;
        int parent = (child - 1) / 2;
        while (child > 0)
        {
            //if (_a[child] > _a[parent])
            if (com(_a[child] , _a[parent]))
            {
                swap(_a[parent], _a[child]);
                child = parent;
                parent = (child - 1) / 2;
            }
            else
            {
                break;
            }
        }

    }
    //最后插入
    void Push(const T&x)
    {
        _a.push_back(x);
        AdjustUp(_a.size() - 1);
    }
    //删除最大数
    void Pop()
    {
        assert(!_a.empty());
        swap(_a[0], _a[_a.size() - 1]);
        _a.pop_back();
        AdjustDown(0);

    }
    //取顶元素
    T& Top()
    {
        assert(!_a.empty());
        return _a[0];
    }
    size_t Size()
    {
        return _a.size();
    }

    bool Empty()
    {
        return _a.empty();
    }

    bool IsHeap()
    {
        //return _IsHeap(_root);//递归
        //非递归
        for (size_t i = 0; i <= (_a.size() - 2) / 2; i++)
        {
            int left = i * 2 + 1;
            int right = i * 2 + 2;
            //最后一个非叶子结点左孩子一定存在，但是右孩子不一定存在
            if (_a[i] < _a[left] || (right < _a.size() && _a[i] < _a[right]))
            {
                return false;
            }
            return true;
        }

    }
    bool _IsHeap(int root)
    {
        if (root >= _a.size())//不存在,是大堆
            return true;
        int left = root * 2 + 1;
        int right = root * 2 + 2;
        if (left < _a.size())
        {
            if (_a[left] > _a[root])
            {
                return false;
            }
            if (right < _a.size())
            {
                if (_a[right] > _a[root])
                {
                    return false;
                }
            }
        }
        return _IsHeap(left) && _IsHeap(right);

    }
private:
    vector<T> _a;

};

void Test() 
{ 
    int a[] = { 10, 11, 13, 12, 16, 18, 15, 17, 14, 19 };
    Heap<int> hp1(a, sizeof(a) / sizeof(a[0]));
    cout << "hp1" << hp1.IsHeap() << endl;
} 

向下调整（大堆）
void AdjustDownBig(int* a, size_t n, int root)
{
    assert(a);
    int parent = root;
    int child = parent * 2 + 1;
    while (child<n)
    {
        if (child + 1 < n&&a[child + 1] > a[child])
        {
            ++child;
        }
        if (a[child] > a[parent])
        {
            swap(a[child], a[parent]);
            parent = child;
            child = parent * 2 + 1;
        }
        else
        {
            break;
        }

    }


}
//堆排序
void HeapSort(int*a, size_t n)
{
    //建堆(升序建大堆 O(N*lgN))
    for (int i = (n - 2) / 2; i >= 0; --i)
    {
        AdjustDownBig(a, n, i);
    }
    // 选择
    int end = n - 1;
    while (end >= 0)
    {
        swap(a[0], a[end]);
        AdjustDownBig(a, end, 0);
        --end;
    }
}
//向下调整（小堆）
void AdjustDownSmall(int* a, size_t n, int root)
{
    assert(a);
    int parent = root;
    int child = parent * 2 + 1;
    while (child<n)
    {
        if (child + 1 < n&&a[child + 1] < a[child])
        {
            ++child;
        }
        if (a[child] < a[parent])
        {
            swap(a[child], a[parent]);
            parent = child;
            child = parent * 2 + 1;
        }
        else
        {
            break;
        }

    }


}
//N个数里面找最大的前K个
const size_t N = 10000;
const size_t K = 10;
void TopK()
{
    int a[N] = { 0 };
    for (size_t i = 0; i < N; ++i)
    {
        a[i] = rand() % N;//给随机数
    }
    //验证
    a[0] = N + 100;
    a[100] = N + 101;
    a[2] = N + 102;
    a[50] = N + 105;
    a[1000] = N + 100;
    a[1005] = N + 1550;
    a[888] = N + 130;
    a[9998] = N + 100;
    a[9999] = N + 100;
    a[9444] = N + 100;


    //堆就是一个数组
    int heap[K] = { 0 };
    //将前K个数放入堆中
    for (size_t i = 0; i < K; ++i)
    {
        heap[i] = a[i];
    }

    // 建堆
    for (int i = (K - 2) / 2; i >= 0; --i)
    {
        AdjustDownSmall(heap, K, i);
    }

    for (size_t i = K; i < N; ++i)
    {
        if (a[i] > heap[0])
        {
            heap[0] = a[i];
            AdjustDownSmall(heap, K, 0);
        }
    }

    for (size_t i = 0; i < K; ++i)
    {
        cout << heap[i] << " ";
    }

}
void TestHeapSort()
{
    int a[] = { 10, 11, 13, 12, 16, 18, 15, 17, 14, 19 };
    HeapSort(a, sizeof(a) / sizeof(a[0]));
    for (size_t i = 0; i < sizeof(a) / sizeof(a[0]); ++i)
    {
        cout << a[i] << " ";
    }
    cout << endl;
}
zhuohaiyy
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
小根堆java_小根堆的Java实现
weixin_34515820的博客
02-26 950
1. 堆堆是完全二叉树的数组形式，由于堆没有指针指向，所以可以利用下标来模拟指向，假设 i 为父节点，那么 2i+1 为左孩子，2i+2 为右孩子。假设 i 为当前节点，那么 (i - 1) / 2 为父节点根据大小排序可分为小根堆和大根堆，小根堆即元素越小越在上方，大根堆则相反。这里注意：元素大小并不是按数组下标来排序的，下图的数字对应数组的坐标堆的应用：堆排序优先级队列快速找最值2. 小根堆实...
数组模拟堆
最新发布
cookies_s_的博客
04-01 1168
堆是一种特殊的树形数据结构，常用于实现优先队列。堆分为最大堆和最小堆两种类型，最大堆要求父节点的值大于等于子节点的值，最小堆要求父节点的值小于等于子节点的值。在堆中，通常使用数组来实现，具体实现时需要满足以下性质：1. 父节点 i 的左子节点在位置2* parent+1，右子节点在位置2* parent+2；子节点 child 的父节点parent位置 parent = (child - 1) / 2（下标从0开始）
C/C++实现大根堆（数组实现）
Lhw_666的博客
01-24 3996
思想 利用一个一维数组通过下标来实现一个大根堆，大根堆其实就是一棵完全二叉树 对于任意一个位置 i 上的节点，他的父节点下标为 （i-1）/2 他的左孩子下标为 2i+1 ， 他的右孩子下标为 2i+2 对于0位置上的节点，（0-1）/2就是0，因此0位置上的节点的根节点就是他自己 大根堆就是要保证每一棵子树的根节点是这棵树上最大的 建立大根堆 时间复杂度O(N) void swap(int arr[], int i, int j){ int temp = arr[i]; arr[i] =
排序算法：堆排序
Yikefore的博客
05-28 2691
关于排序算法中的堆排序的详细介绍，以及实现过程和时间复杂度的计算，附带图解。
驱动开发：通过应用堆实现多次通信
CSDN
05-19 9634
的方式灵活的实现了内核态多次输出结构体的效果，但是此种方法并不推荐大家使用原因很简单首先内核空间比较宝贵，其次内核里面不能分配太大且每次传出的结构体最大不能超过。与MDL映射相反，MDL多数处理流程在内核代码中，而应用层开堆复杂代码则在应用层，但内核层中同样还是需要使用指针，只是这里的指针仅仅只是保留基本要素即可，通过。个，而最终这些内存由于无法得到更好的释放从而导致坏堆的产生，这样的程序显然是无法在生产环境中使用的，如下。回传给应用层，至此内核中仅仅回传了一个长度，其他的都写入到了应用层中。
C语言 二叉树的性质及堆的实现 + 堆排序
凡事都是靠练习
04-02 1458
堆结构声明，基本堆接口的实现，实现接口的一些细节点以及堆排序
深入浅出：用C++实现二叉堆的艺术
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
02-05 1398
在探索数据结构的宏伟宇宙中，二叉堆占据了其独特的一席之地。作为优先队列的基石，它在算法设计和数据处理中扮演着至关重要的角色。本篇博客旨在深入浅出地介绍如何在C++中实现二叉堆，无论你是数据结构的新手还是寻求更深层次理解的开发者，都能从中获得宝贵的知识和技能。
＜ 数据结构 ＞ 堆的应用 --- 堆排序和Topk问题
bit_zyx的博客
04-18 1214
目录 1、堆排序 法一：自己写堆进行排序 时间复杂度分析 法二：直接对数组建堆 ①、向上调整建堆 ②、向下调整建堆 向上建堆和向下建堆熟优？ 升序能否建小堆？ 排序（建大堆） 2、TopK问题 何为Topk？ 实现过程 1、堆排序 假如我们有一串乱序数组，如...
数据结构：堆 的详解
潜心钻研技术
09-05 6533
堆 文章目录堆堆的概念及结构堆的性质堆的实现向下调整算法（小根堆）代码向上排序算法代码堆的创建堆的增加元素堆减少元素堆的应用堆排序TopK问题 堆的概念及结构 如果有一个关键码的集合k={k0,k1,k2…,kn-1}，把他们的所有元素按完全二叉树的顺序存储方式存储在一个一维数组中，并满足：Ki<K(2i+1) 且 Ki<=K(2i+2) (或Ki>=K(2i+1) 且Ki>=K (2i+2) ) i=1,2,…，则称为小堆（大堆）。将根节点最大的堆叫做对大堆或大根堆，根节点最小
模拟JAVA堆内存溢出和栈内存溢出
jeffersonchern的博客
08-01 1521
模拟JAVA堆内存溢出和栈内存溢出，代码可以直接复制粘贴使用。
堆排序 java实现
04-12
在这个实例中，我们关注的是如何用Java来实现堆排序算法，并通过随机生成的数字进行验证。 首先，了解堆的基本概念。堆分为最大堆和最小堆，最大堆是每个父节点的值都大于或等于其子节点的值，而最小堆则相反。在堆...
c语言实现 小根堆heap
12-07
8. 应用场景：小根堆常被用在优先队列、事件驱动的模拟系统、最短路径算法（Dijkstra's algorithm）等场合，因为它能快速找到并处理最小元素。 以上就是关于C语言实现小根堆heap的主要知识点。在minheap这个压缩包...
模拟计算反应堆冷却剂温度分布_热管_冷却_模拟计算反应堆冷却剂温度分布_
10-03
"模拟计算反应堆冷却剂温度分布"这一主题涉及到多个关键知识点，包括热管技术的应用、冷却系统的工作原理以及数值模拟方法。以下将对这些核心概念进行详细阐述。 首先，热管是一种高效传热元件，它通过内部工作液体...
基于最小堆的银行模拟系统
04-09
在这个项目中，最小堆这一数据结构被巧妙地应用到了银行服务系统的模拟中，以高效地处理客户服务请求。下面将详细介绍这个系统的核心知识点。 一、最小堆及其特性 最小堆是一种特殊的完全二叉树，每个节点的值都...
华大额温枪方案 模拟传感器 原理图+PCB+程序+调试说明.rar
04-02
【华大额温枪方案】是一款基于模拟热电堆传感器的体温测量设备设计，它集成了原理图设计、PCB布局、程序代码以及调试指南，为开发者或制造商提供了完整的生产流程和技术支持。以下是对该方案的详细解析： 一、模拟...
STL中map和set底层的红黑树实现
zhuohaiyy的博客
11-10 3718
我们都知道map和set的实现是依赖红黑树的 怎样写红黑树可以让map和set都可以使用呢？ 在这里我们定义了一个模版参数，如果它是key那么它就是set，如果它是map，那么它就是map；我们分析一下，红黑树迭代器的前置++ 到当前结点，就说明了它的左子树和自己都已经访问过了 1，当前位置，若右树不为空，则访问右树的最左结点 2，当前位置，若右树为空，则找祖先中孩子不是他的右 若右访问
面试题（两个栈实现一个队列和两个队列实现一个栈）
zhuohaiyy的博客
09-26 2712
面试题（判断元素出栈入栈顺序的合法性。） 面试题（实现一个栈，要求实现Push（出栈）、Pop（入栈）、Min（返回最小值的操作）的时间复杂度为O(1)）1，两个栈实现一个队列我们知道栈是后进先出的，而队列是先进先出的 我们创建两个栈input（输入栈），output（输出栈） 我们用input（输入栈）来负责入队，而output（输出栈）来负责出队（反向） 出队是，如果output不为空，
面试题（实现一个栈，要求实现Push、Pop、Min的时间复杂度为O(1)）
zhuohaiyy的博客
09-26 1339
面试题（判断元素出栈入栈顺序的合法性。） 面试题（两个栈实现一个队列和两个队列实现一个栈） 实现一个栈，要求实现Push（出栈）、Pop（入栈）、Min（返回最小值的操作）的时间复杂度为O(1) 解题思路： 我们定义两个栈分别为s1,s2。我们用s2保存最小值，s1保存原来的值 Push()：我们添加元素到s1中，如果s2为空或者x #include #include using n
面试题（判断元素出栈入栈顺序的合法性。）
zhuohaiyy的博客
09-26 1175
面试题（实现一个栈，要求实现Push（出栈）、Pop（入栈）、Min（返回最小值的操作）的时间复杂度为O(1)） 面试题（两个栈实现一个队列和两个队列实现一个栈） 判断元素出栈，入栈顺序的合法性 如：入栈的序列（1,2,3,4,5），出栈序列为（4,5,3,2,1）是合法序列 入栈的序列（1,2,3,4,5），出栈序列为（1,5,3,2,4）是不合法序列 解题思路：我们声明两个栈，分别为i
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值