算法总结

一 基础知识

1.

均为线性表，可以由数组或链表实现 

栈：先进后出，操作均在栈顶进行

队列：先进先出，队尾进，队首出

 

2.  STL stack & queue

stack 常见操作：

s.push(x)：入栈 （void类型）

s.pop()： 出栈 （void类型，只删除，不返回元素）

s.top()： 返回栈顶元素

s.size()：返回栈元素个数

s.empty() ：判断栈是否为空

 

queue 常见操作：

q.push(x): 入队

q.pop(): 出队 （void类型，只删除，不返回队首元素）

q.front(): 访问返回对首元素

q.back(): 访问返回队尾元素

q.size():返回队列元素个数

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

 

3.概念理解相关题型

3.1 Implement Stack using Queues （leetcode 225 https://leetcode.com/problems/implement-stack-using-queues/）

思路：使用两个队列实现，其中一个队列为空，用来进行颠倒顺序和输出队尾元素。

入栈操作： 向非空队列内入队即可

出栈操作：将非空队列除队尾元素外的所有元素导入另一个空队列，剩余队尾元素即为待应该待出栈元素

top()操作： 同出栈，注意只需访问返回，不需要让其出队，即仍需将其导入另一队列

注意：两队列地位平等，均可能用作储存和转移工作

class Stack {
private:
    queue<int> q1,q2;
public:
    // Push element x onto stack.
    void push(int x) {
        if(!q1.empty()){
            q1.push(x);
        }
        else{
            q2.push(x);
        }
    }

    // Removes the element on top of the stack.
    void pop() {
        if(!q1.empty()){
            while(q1.size() > 1){
                q2.push(q1.front());
                q1.pop();
            }
            q1.pop();
        }else{
            while(q2.size() > 1){
                q1.push(q2.front());
                q2.pop();
            }
            q2.pop();
        }
    }

    // Get the top element.
    int top() {
        if(!q1.empty()){
            while(q1.size() > 1){
                q2.push(q1.front());
                q1.pop();
            }
            int ans = q1.front();
            q2.push(q1.front());
            q1.pop();
            return ans;
        }else{
            while(q2.size() > 1){
                q1.push(q2.front());
                q2.pop();
            }
            int ans = q2.front();
            q1.push(q2.front());
            q2.pop();
            return ans;
        }
    }

    // Return whether the stack is empty.
    bool empty() {
        if(q1.empty() && q2.empty()){
            return true;
        }
        return false;
    }
};

 

3.2 Implement Queue using Stacks （leetcode 232 https://leetcode.com/problems/implement-queue-using-stacks/）

思路：

两个堆栈，s1负责入队，s2负责反向并出队

每次入队直接进入s1，出队操作先将s1所有元素压入s2，则栈顶元素即为待出队元素，出队后压回s1，恢复原状。

class Queue {
private:
    stack<int> s1,s2;
public:
    // Push element x to the back of queue.
    void push(int x) {
        s1.push(x);
    }

    // Removes the element from in front of queue.
    void pop(void) {
        while(!s1.empty()){
            s2.push(s1.top());  // 注意STL栈中，top只返回不出栈，pop只出栈不返回
            s1.pop();
        }
        s2.pop();
        while(!s2.empty()){
            s1.push(s2.top());
            s2.pop();
        }
    }

    // Get the front element.
    int peek(void) {
        while(!s1.empty()){
            s2.push(s1.top()); 
            s1.pop();
        }
        int ans = s2.top();
        while(!s2.empty()){
            s1.push(s2.top());
            s2.pop();
        }
        return ans;
    }

    // Return whether the queue is empty.
    bool empty(void) {
        if(s1.empty() && s2.empty()){
            return true;
        }
        return false;
    }
};

 

3.3 Min Stack (leetcode 155 https://leetcode.com/problems/min-stack/)

要求：实现可以返回最小元素的栈

思路：使用两个栈，一个栈s1正常出入，另一个储s2存最小值信息，当当前元素比s2栈顶元素小，入当前元素，否则再入一份栈顶元素

注意：由于s1,s2元素一样多，出栈时也应一起出栈。

class MinStack {
private:
    stack<int> s1,s2;
public:
    void push(int x) {
        s1.push(x);
        if(!s2.empty() && x > s2.top()){
            s2.push(s2.top());
        }else{
            s2.push(x);
        }
    }

    void pop() {
        s1.pop();
        s2.pop();
    }

    int top() {
        return s1.top();
    }

    int getMin() {
        return s2.top();
    }
};

 

 二. 栈与队列应用 （结合数据结构教材中的应用）

1. 典型应用场合

典型应用栈的场合有： 逆序输出 （进制转换），递归嵌套（栈混洗，括号匹配），延迟缓冲（表达式计算），栈式计算（逆波兰表达式）

举例如下：

1.1 十进制数向n进制转换的栈实现

思路：除以n取余数，以此存放在栈中，输出时由栈的特点反向输出得解

void convert(stack <char>& S, int n,int base) {
    static char digit[] = 
    {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
    while(n > 0){
        int remainder = (int)(n % base);
        S.push(digit[remainder]);
        n /= base;
    }
}

 

1.2 栈混洗（元素出入栈合法顺序判断）

思路：使用栈模拟，对于s，如果当前要出栈元素正好在栈顶，则必须出栈;否则入栈，出现矛盾则说明不合法

bool isPossible(vector<int>& in, vector<int>& out){
    stack<int> s;
    for(int i = 0,j = 0;j<out.size();j++){
        while(s.empty() || s.top!= out[j]){
            if(i > in.size()){
                return false;
            }
            s.push(in[++]);
        }  
        s.pop();
    }
    return true;
}

补充： n个元素的合法出入栈个数为卡特兰数  （2n!）/ n! /(n+1)!

 

1.3 括号匹配 （leetcode 20 https://leetcode.com/problems/valid-parentheses/）

思路：遍历序列，遇到所有类型左括号，入栈；遇到右括号，判定栈顶元素与之是否匹配，匹配则出栈，不匹配则说明整体不匹配

class Solution {
public:
    bool isValid(string s) {
        stack<char> S;
        for(int i = 0; i < s.length(); i++){
            if(s[i] == '(' || s[i] == '[' || s[i] == '{'){
                S.push(s[i]);
                continue;
            }
            if(s[i] == ')'){
                if(S.empty() || S.top() != '('){
                    return false;
                }
                S.pop();
                continue;
            }
            if(s[i] == ']'){
                if(S.empty() || S.top() != '['){
                    return false;
                }
                S.pop();
                continue;
            }
            if(s[i] == '}'){
                if(S.empty() || S.top() != '{'){
                    return false;
                }
                S.pop();
                continue;
            }
        }
        return S.empty();
    }
            
};

 

1.4 逆波兰表达式求解 （leetcode 150 https://leetcode.com/problems/evaluate-reverse-polish-notation/）

思路：根据逆波兰表达式定义，建立栈

遍历字符串，遇到数字，入栈，遇到运算符，取出栈顶两元素执行相应计算后将结果入栈

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        stack<int> s;
        for(int i = 0;i < tokens.size();i++){
            if(tokens[i] == "+" || tokens[i] == "-" || tokens[i]== "*" || tokens[i] == "/"){
                int num1 = s.top();
                s.pop();
                int num2 = s.top();
                s.pop();
                if(tokens[i] == "+"){
                    int num = num1 + num2;
                    s.push(num);
                }
                if(tokens[i] == "-"){
                    int num = num2 - num1;
                    s.push(num);
                }
                if(tokens[i] == "*"){
                    int num = num2 * num1;
                    s.push(num);
                }
                if(tokens[i] == "/"){
                    int num = num2 / num1;
                    s.push(num);
                }
            }
            else{
                s.push(atoi(tokens[i].c_str()));
            }
        }
        int ans = s.top();
        return ans;
    }
};