剑指offer：栈和队列

JZ9 用两个栈实现队列
简单 通过率：41.16% 时间限制：1秒 空间限制：64M
知识点栈
描述
用两个栈来实现一个队列，使用n个元素来完成 n 次在队列尾部插入整数(push)和n次在队列头部删除整数(pop)的功能。
队列中的元素为int类型。保证操作合法，即保证pop操作时队列内已有元素。

数据范围： n≤1000
要求：存储n个元素的空间复杂度为 O(n) ，插入与删除的时间复杂度都是 O(1)
示例1
输入：
[“PSH1”,“PSH2”,“POP”,“POP”]
返回值：
1,2
说明：
“PSH1”:代表将1插入队列尾部
“PSH2”:代表将2插入队列尾部
"POP“:代表删除一个元素，先进先出=>返回1
"POP“:代表删除一个元素，先进先出=>返回2
示例2
输入：
[“PSH2”,“POP”,“PSH1”,“POP”]

返回值：
2,1

class Solution
{
public:
    void push(int node) {
        stack_in.push(node);
    }
    int pop() {
        if (stack_out.empty()){
            while (!stack_in.empty()){
                stack_out.push(stack_in.top());
                stack_in.pop();
            }
        }
        int res = stack_out.top();
        stack_out.pop();
        return res;
    }
private:
    stack<int> stack_in;
    stack<int> stack_out;
};

JZ30 包含min函数的栈
简单 通过率：34.99% 时间限制：1秒 空间限制：64M
知识点栈
描述
定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的 min 函数，输入操作时保证 pop、top 和 min 函数操作时，栈中一定有元素。

此栈包含的方法有：
push(value):将value压入栈中
pop():弹出栈顶元素
top():获取栈顶元素
min():获取栈中最小元素

数据范围：操作数量满足 0≤n≤300 ，输入的元素满足 ∣val∣≤10000
进阶：栈的各个操作的时间复杂度是 O(1) ，空间复杂度是 O(n)

示例:
输入: [“PSH-1”,“PSH2”,“MIN”,“TOP”,“POP”,“PSH1”,“TOP”,“MIN”]
输出: -1,2,1,-1
解析:
"PSH-1"表示将-1压入栈中，栈中元素为-1
"PSH2"表示将2压入栈中，栈中元素为2，-1
“MIN”表示获取此时栈中最小元素==>返回-1
"TOP"表示获取栈顶元素==>返回2
"POP"表示弹出栈顶元素，弹出2，栈中元素为-1
"PSH1"表示将1压入栈中，栈中元素为1，-1
"TOP"表示获取栈顶元素==>返回1
“MIN”表示获取此时栈中最小元素==>返回-1

示例1
输入：
[“PSH-1”,“PSH2”,“MIN”,“TOP”,“POP”,“PSH1”,“TOP”,“MIN”]
返回值：
-1,2,1,-1

class Solution
{
public:
    void push(int value) {
        if (min_sta.empty() || value < min_sta.top()) {
            min_sta.push(value);
        } else {
            min_sta.push(min_sta.top());
        }
        sta.push(value);
        //     sta:5 7 4 8 3 6 2 9 1
        // min_sta:5 5 4 4 3 3 2 2 1
    }
    void pop(){
        min_sta.pop();
        sta.pop();
    }
    int top(){
        return sta.top();
    }
    int min() {
        return min_sta.top();
    }
    stack<int> sta;
    stack<int> min_sta;
};

JZ31 栈的压入、弹出序列
中等 通过率：31.62% 时间限制：1秒 空间限制：64M
知识点栈
描述
输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否可能为该栈的弹出顺序。假设压入栈的所有数字均不相等。
例如序列1,2,3,4,5是某栈的压入顺序，序列4,5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。

1. 0<=pushV.length == popV.length <=1000
2. -1000<=pushV[i]<=1000
3. pushV 的所有数字均不相同
   示例1
   输入：
   [1,2,3,4,5],[4,5,3,2,1]
   返回值：
   true
   说明：
   可以通过push(1)=>push(2)=>push(3)=>push(4)=>pop()=>push(5)=>pop()=>pop()=>pop()=>pop()
   这样的顺序得到[4,5,3,2,1]这个序列，返回true
   示例2
   输入：
   [1,2,3,4,5],[4,3,5,1,2]
   返回值：
   false

说明：
由于是[1,2,3,4,5]的压入顺序，[4,3,5,1,2]的弹出顺序，要求4，3，5必须在1，2前压入，且1，2不能弹出，但是这样压入的顺序，1又不能在2之前弹出，所以无法形成的，返回false

class Solution
{
public:
    bool IsPopOrder(vector<int> pushV,vector<int> popV) {
        if ( pushV.empty() ) {
            return false;
        }
        stack<int> sta;
        for (int i = 0, j = 0; i < pushV.size(); i++){
            sta.push(pushV[i]);
            while ( !sta.empty() && sta.top() == popV[j] ){
                sta.pop();
                j++;
            }
        }
        return sta.empty();
    }
};

JZ73 翻转单词序列

这道题目没有使用栈，而是使用两轮翻转。

简单 通过率：21.65% 时间限制：1秒 空间限制：64M
知识点字符串双指针
描述
牛客最近来了一个新员工Fish，每天早晨总是会拿着一本英文杂志，写些句子在本子上。同事Cat对Fish写的内容颇感兴趣，有一天他向Fish借来翻看，但却读不懂它的意思。例如，“nowcoder. a am I”。后来才意识到，这家伙原来把句子单词的顺序翻转了，正确的句子应该是“I am a nowcoder.”。Cat对一一的翻转这些单词顺序可不在行，你能帮助他么？

数据范围：1≤n≤100
进阶：空间复杂度 O(n) ，时间复杂度 O(n) ，保证没有只包含空格的字符串
示例1
输入：
“nowcoder. a am I”
返回值：
“I am a nowcoder.”
示例2
输入：
“”
返回值：
“”

C++ reverse函数的用法
reverse函数功能是逆序（或反转），多用于字符串、数组、容器。
头文件是#include
reverse函数用于反转在[first,last)范围内的顺序
包括first指向的元素，不包括last指向的元素，
reverse函数无返回值

string str=“hello world , hi”;
reverse(str.begin(),str.end());//str结果为 ih , dlrow olleh

vector v = {5,4,3,2,1};
reverse(v.begin(),v.end());//容器v的值变为1,2,3,4,5

class Solution
{
public:
    string ReverseSentence(string str) {
        //第一步：整体翻转
        reverse(str.begin(), str.end());

        // begin()      begin()+1      begin()+2
        //   0              1              2   
        //第二步：局部翻转
        int offset = 0;
        for (int i = 0; i < str.size(); i++) {
            if (str[i] == ' ') {
                reverse(str.begin() + offset, str.begin() + i);
                // 下一个单词的迭代器：begin()+i+1
                offset = i + 1;
            } else if (i == str.size() - 1) {
                //到达字符串末尾，最后一个单词使用end()
                reverse(str.begin() + offset, str.end());
            }
        }
        return str;
    }
};

JZ59 滑动窗口的最大值
较难 通过率：27.60% 时间限制：1秒 空间限制：256M
知识点堆双指针队列
描述
给定一个长度为 n 的数组 nums 和滑动窗口的大小 size ，找出所有滑动窗口里数值的最大值。

例如，如果输入数组{2,3,4,2,6,2,5,1}及滑动窗口的大小3，那么一共存在6个滑动窗口，他们的最大值分别为{4,4,6,6,6,5}； 针对数组{2,3,4,2,6,2,5,1}的滑动窗口有以下6个： {[2,3,4],2,6,2,5,1}， {2,[3,4,2],6,2,5,1}， {2,3,[4,2,6],2,5,1}， {2,3,4,[2,6,2],5,1}， {2,3,4,2,[6,2,5],1}， {2,3,4,2,6,[2,5,1]}。

数据范围： 1≤size≤n≤10000，数组中每个元素的值满足 ∣val∣≤10000
要求：空间复杂度 O(n)，时间复杂度 O(n)

示例1
输入：
[2,3,4,2,6,2,5,1],3
返回值：
[4,4,6,6,6,5]
示例2
输入：
[9,10,9,-7,-3,8,2,-6],5
返回值：
[10,10,9,8]
示例3
输入：
[1,2,3,4],3
返回值：
[3,4]

第一种方法：两层循环

class Solution {
public:
    vector<int> maxInWindows(const vector<int>& num, int size) {
        vector<int> res;
        if (num.size() == 0 || num.size() < size || size < 1) {
            return res;
        }
        for (int i = 0; i <= num.size() - size; i++) {
            int max = 0;
            for (int j = i; j <= i + size - 1; j++) {
                if (max < num[j]) {
                    max = num[j];
                }
            }
            res.push_back(max);
        }
        return res;
    }
};

第二种方法：队列deque

class Solution {
public:
    vector<int> maxInWindows(const vector<int>& num, int size) {
        vector<int> ret;
        if (num.size() == 0 || size < 1 || num.size() < size) {
            return ret;
        }
        deque<int> deq;
        for (int i = 0; i < num.size(); ++i) {
            while (!deq.empty() && num[deq.back()] < num[i]) {
                //后面的大数把前面的小数吃掉
                deq.pop_back();
            }
            deq.push_back(i);

            // 判断队列的头部的下标是否过期
            // 窗口的起始下标 i - size + 1
            // 窗口的结束下标 i
            if (deq.front() < i - size + 1) {
                deq.pop_front();
            }


            // 判断是否形成了窗口
            // 第一个窗口的起始下标：0
            // 第一个窗口的结束下标：size - 1
            if (i >= size - 1) {
                ret.push_back(num[deq.front()]);
            }
        }
        return ret;
    }
};

BM44 有效括号序列
题目
题解(283)
讨论(379)
排行
面经new
简单 通过率：33.39% 时间限制：1秒 空间限制：256M
知识点
栈
字符串
描述
给出一个仅包含字符’(‘,’)‘,’{‘,’}‘,’[‘和’]',的字符串，判断给出的字符串是否是合法的括号序列
括号必须以正确的顺序关闭，"()“和”()[]{}“都是合法的括号序列，但”(]“和”([)]"不合法。

数据范围：字符串长度 0\le n \le 100000≤n≤10000
要求：空间复杂度 O(n)O(n)，时间复杂度 O(n)O(n)
示例1
输入：
“[”
复制
返回值：
false
复制
示例2
输入：
“[]”
复制
返回值：
true
复制

class Solution {
public:
    /**
     * 
     * @param s string字符串 
     * @return bool布尔型
     */
    bool isValid(string s) {
        stack<char> sta;
        for (int i = 0; i < s.length(); ++i) {
            if (s[i] == '(') {
                sta.push(')');
            } else if (s[i] == '[') {
                sta.push(']');
            } else if (s[i] == '{') {
                sta.push('}');
            } else if (sta.empty()) {
                return false;
            } else if (s[i] == sta.top()) {
                sta.pop();
            }
        }
        return sta.empty();
    }
};