栈和队列

1.可查询最值的栈

定义栈的数据结构，请在该类型中实现一个能够得到栈最小元素的min函数。

方法一.

class Solution {
public:
    stack <int> stackdata;
    stack <int> stackmin;
    void push(int value) {
        stackdata.push(value);
        if(stackmin.empty()||value<stackmin.top())
            stackmin.push(value);
        else
            stackmin.push(stackmin.top());
    }
    void pop() {
        if(!stackdata.empty())
        {
            stackdata.pop();
            stackmin.pop();
        }
    }
    int top() {
        return stackdata.top(); 
    }
    int min() {
        return stackmin.top();
        
    }
};

使用一个额外栈来保存栈当前的最小值，例如1 2 1 5 4 3，两个栈里面的内容回是这样:

1    1

2    1

1    1

5    3

4    3

3    3

方法二.

class Solution {
public:
    stack <int> stackdata;
    stack <int> stackmin;
    void push(int value) {
        stackdata.push(value);
        if(stackmin.empty()||value<=stackmin.top()) {
            stackmin.push(value);
        }
    }
    void pop() {
        if(!stackdata.empty() && !stackmin.empty()) {
            if (stackdata.top() == stackmin.top()) {
                stackmin.pop();
            }
            stackdata.pop();
        }
    }
    int top() {
        return stackdata.top();
    }
    int min() {
        return stackmin.top();
    }
};

使用一个额外栈来保存栈当前的最小值，例如1 2 1 5 4 3，两个栈里面的内容回是这样:

1    

2    

1    

5    1

4    1

3    3

2.双栈队列

利用两个栈实现一个队列的操作，需要注意两点:

(1)另外一个栈不为空时，不能倒入。

(2)如果要倒入的话，需要全部倒入。

class TwoStack {
public:
    vector<int> twoStack(vector<int> ope, int n) {
        stack<int> in;
        stack<int> out;
        vector<int> result;
        for(int i=0;i<n;++i)
        {
            if(ope[i]!=0)
            {
                in.push(ope[i]);
            }
            else
            {
                if(!out.empty())
                {
                    int temp=out.top();
                    out.pop();
                    result.push_back(temp);
                }
                else
                {
                    while(!in.empty())
                    {
                        int temp=in.top();
                        in.pop();
                        out.push(temp);
                    }
                    int temp=out.top();
                    out.pop();
                    result.push_back(temp);
                }
            }
        }
        return result;
    }
};

3.栈的反转练习

把vector当作一个栈来使用

class StackReverse {
public:
    vector<int> reverseStack(vector<int> A, int n) {
        reverse(A);
        return A;
    }
    void reverse(vector<int> &A)
    {
        if(A.empty())
            return;
        else
        {
            int last=get(A);
            reverse(A);
            A.push_back(last);
        }
        
    }
    int get(vector<int> &A)
    {
        int res=A.back();
        A.pop_back();
        if(A.empty())
            return res;
        else{
            int last=get(A);
            A.push_back(res);
            return last;
        }
    }
};

4.双栈排序

返回递增顺序的numbers数组。

class TwoStacks {
public:
    vector<int> twoStacksSort(vector<int> numbers);
};
vector<int> TwoStacks::twoStacksSort(vector<int > numbers)
{
    vector<int> ivc;
    int data;
    while(!numbers.empty())
    {
        data=numbers.back();
        numbers.pop_back();
        while(!ivc.empty()&&data>ivc.back())
        {
            numbers.push_back(ivc.back());
            ivc.pop_back();
        }
        ivc.push_back(data);
    }
    return ivc;

}

5.滑动窗口

方法一:

不适用辅助数据结构，暴力法，求解每个窗口内的最大值。

class SlideWindow {
public:
    int get_win_max(vector<int>&arr, int l, int r) {
        int max = 0;
        for (int i = l; i <= r; ++i) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        return max;
    }
    vector<int> slide(vector<int> arr, int n, int w) {
        
        if(arr.empty()||w>n)
            return arr;
        //vector<int> res;
        vector<int> res(n-w+1);
        for (int i = 0; i <= n - w; ++i) {
            //res.push_back(get_win_max(arr, i, i+w-1));
            res[i] = get_win_max(arr, i, i+w-1);
        }
        
        return res;
    }
};

方法二:

利用双端队列，保持队列里面的对手元素值最大。

class SlideWindow {
public:
    vector<int> slide(vector<int> arr, int n, int w) {
        
        if(arr.empty()||w>n)
            return arr;
        vector<int> res(n-w+1);
        int index=0;
        deque<int> qmax;//存的是数组的下标
        for(int i=0;i<n;++i)
        {
            while(!qmax.empty()&&arr[qmax.back()]<=arr[i])//给貌似少的操作和明晰的条件，加条件判断
            {
                qmax.pop_back();
            }
            qmax.push_back(i);//尽量给正常的操作，减少判断条件，或者没有条件
            if(qmax.front()<i-w+1)//if(qmax.front()<i-w+1)都是可以的
                qmax.pop_front();
            if(i>=w-1)
            {

                //res.push_back(arr[qmax.front()]);不能push_back，虽然后面的数字正常，但是会导致前面输出000..
                res[index++]=(arr[qmax.front()]);
            }
        }
        return res;
    }
};

6.数组变树

根节点是最大的节点，对于子树也同样如此。

class MaxTree {
public:
    vector<int> buildMaxTree(vector<int> A, int n) {
    
        vector<int> leftMax(n);
        vector<int> rightMax(n);
        vector<int> res;
        stack<int>left,right;
          
        for(int i = 0;i<n;++i){
            while(!left.empty()&&A[left.top()]<A[i])
                left.pop();
            if(left.empty())
                leftMax[i] = -1;
            else
            leftMax[i] = left.top();
            left.push(i);
        }
        for(int i = n-1;i>=0;--i){
            while(!right.empty()&&A[right.top()]<A[i])
                right.pop();
            if(right.empty())
                rightMax[i] = -1;
            else
            rightMax[i] = right.top();
            right.push(i);
        }
          
        for(int i = 0;i<n;++i){
            if(leftMax[i] == -1&&rightMax[i] == -1)
                res.push_back(-1);
            else if(leftMax[i] == -1)
                res.push_back(rightMax[i]);
            else if(rightMax[i] == -1)
                res.push_back(leftMax[i]);
            else if(A[leftMax[i]]<A[rightMax[i]])
                res.push_back(leftMax[i]);
            else
                res.push_back(rightMax[i]);
        }
        return res;
    }
};