包含min函数的栈-最小堆的插入、删除（调整）

时间限制：C/C++ 1秒，其他语言2秒 空间限制：C/C++ 32M，其他语言64M 热度指数：448024

本题知识点： 栈

 算法知识视频讲解

题目描述

定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O（1））。

注意：保证测试中不会当栈为空的时候，对栈调用pop()或者min()或者top()方法。

解答：

第一种方法是堆，第二种方法是双栈法。

class Solution {
private:
    int stop;
    int s[2000];
    vector<int>heap;
    vector<int>stack;
public:
    Solution(){
        stop=0;
        stack.push_back(-1);
        heap.push_back(INT_MAX);
        //#include<limits.h>
        //#define INT_MAX 2147483647
        //#define INT_MIN (-INT_MAX - 1)

    }
    void BuildMinHeap(int max){
        for(int i=max/2;i>=1;i--){
            AdjustUp(heap,i,max);
            //max是最大下标。
            //注意，i从1开始！
        }
    }//这是将普通二叉树调整为堆的过程，是调整，不是创建堆。
    void AdjustUp(vector<int>&s,int st,int maxi){
        s[0]=s[st];
        int i=0;
        for(i=2*st;i<=maxi;i=i*2){
            if(maxi>=i+1){
                if(s[i]>s[i+1]){
                    i++;
                }
            }
            if(s[i]<s[0]){
                s[i/2]=s[i];
            }else{
                break;
            }
        }
        s[i/2]=s[0];
    }//这是将普通二叉树调整为堆的过程，是调整，不是创建堆。
    
    void insert(int bottomi){
        int num=heap[bottomi];
        int k=bottomi/2;
        while(heap[k]>num&&k>0){
            heap[bottomi]=heap[k];
            bottomi=k;
            k=k/2;
        }
        heap[bottomi]=num;
    }//这是从零开始创建堆的过程。
    
    void deletenum(int value){
        int num=0;
        for(int i=heap.size()-1;i>=1;i--){
            if(heap[i]==value){
                num=i;
            }
        }
        int temp=0;
        for(int i=num;i<=heap.size()-2;i++){
            heap[i]=heap[i+1];
        }
        heap.pop_back();
        BuildMinHeap(heap.size()-1);
    }
    void push(int value) {
        stop++;
        stack.push_back(value);
        heap.push_back(value);
        insert(heap.size()-1);
        
    }
    void pop() {
        if(stack.empty())
            return;
        deletenum(stack.back());
        stack.pop_back();
    }
    int top() {
        if(stack.empty())
            return -1;
        return stack.back();
    }
    int min() {
        if(stack.empty())
            return -1;
        return heap[1];
    }
};

class Solution {
private:
    //struct minunit{
        //int val;
        //int times;
        //minunit(int value):times(0),val(value){}
    //};
    int stop;
    vector<int>gmin;
    vector<int>stack;
public:
    Solution(){
        stop=0;
        gmin.push_back(INT_MAX);
        stack.push_back(-1);
        //#include<limits.h>
        //#define INT_MAX 2147483647
        //#define INT_MIN (-INT_MAX - 1)

    }
    void push(int value) {
        stop++;
        stack.push_back(value);
        if(value<=gmin.back()){
            gmin.push_back(value);
        }
    }
    void pop() {
        if(stack.empty())
            return;
        if(stack.back()==gmin.back()){
            gmin.pop_back();
        }
        stack.pop_back();
    }
    int top() {
        if(stack.empty())
            return -1;
        return stack.back();
    }
    int min() {
        if(stack.empty())
            return -1;
        return gmin.back();
    }
};