数据结构 - 栈

一、栈的概念

栈是一种运算受限的线性表，只允许在固定的一端进行添加和删除操作。进行添加和删除的一端被称为栈顶，另一端成为栈底。栈中的数据元素遵循先进后出LIFO(Last In First Out)的原则。

二、栈的特点及应用

1.特点

栈的特点我们可以将栈想象成一个水杯，只能在一段进行操作。从一端插入元素，也只能从这一段取出元素。
先进后出，后出先进的线性表，添加元素和删除元素的一段称为栈顶，另一端称为栈底。

2.应用

栈的应用无处不在
（1）.undo（撤销）操作，当我们输错一个内容时，常用ctrl + z 返回上一次输入的内容。
（2）.操作系统栈：程序在执行的过程中，从A调用B函数，从B调用C函数，返回执行的行数就是利用栈的这个结构。

三、栈的实现

基于数组 -> 顺序栈

/**
 * 基于动态数组实现的栈
 * @param <E>
 */
public class MyStack<E>{
    private int size;
    private List<E> data = new ArrayList<>();

    /**
     * 在当前数组中添加元素 -> 压栈操作
     * @param val
     */
    public void push(E val){
        data.add(val);
        size++;
    }

    /**
     * 弹出当前栈顶元素，返回栈顶元素的值
     * @return
     */
    public E pop(){
        if (data.isEmpty()){
            throw new NoSuchElementException("stack is empty! cannot pop!");
        }
        E val = data.remove(size - 1);
        size --;
        return val;
    }

    /**
     * 查看当前栈顶的值，不弹出该元素
     * @return
     */
    public E peek(){
        if (data.isEmpty()){
            throw new NoSuchElementException("stack is empty! cannot peek!");
        }
        return data.get(size - 1);
    }

    public String toString(){
        StringBuilder sb = new StringBuilder();
        sb.append('[');
        for (int i = 0; i < size; i++) {
            sb.append(data.get(i));
            if (i != size -1) {
                sb.append(',');
            }
        }
        sb.append("] top");
        return sb.toString();
    }

    private boolean isEmpty(){return size == 0;}
}

四、栈的一些常见问题

1.括号匹配问题

LeetCode括号匹配问题
题目描述：

给定一个只包括 ‘(’，‘)’，‘{’，‘}’，‘[’，‘]’ 的字符串 s ，判断字符串是否有效。
有效字符串需满足：
左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。

解题思路：
找反例，先遍历字符串，将字符串转为字符数组，如果遇到左括号就将它压入栈中，将右括号与弹出元素比较，若左括号未匹配到右括号，就找到反例，可能会遇到左括号大于右括号就需要对栈进行判空操作。

class Solution {
    public boolean isValid(String s) {
        Stack<Character> stack = new Stack<>();
        for(int i = 0;i < s.length();i++){
            char c = s.charAt(i);
            if(c == '(' || c == '[' || c == '{'){
                stack.push(c);
            }else{
            if(stack.isEmpty()){
            return false;
            }
            char top = stack.pop();
            if(c == ')' && top != '('){
                return false;
            }
            if(c == '}' && top != '{'){
                return false;
            }
            if(c == ']' && top != '['){
                return false;
    }
}
        }
        return stack.isEmpty();
    }
}

2.实现一个最小栈

LeetCode实现一个最小栈
题目描述：

设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。
实现 MinStack 类:
MinStack() 初始化堆栈对象。
void push(int val) 将元素val推入堆栈。
void pop() 删除堆栈顶部的元素。
int top() 获取堆栈顶部的元素。
int getMin() 获取堆栈中的最小元素。

解题思路：采用双栈思路，一个栈储存实际元素，一个栈储存当前最小元素。若s2为空，直接将元素入栈，若当前元素小于栈顶元素，直接入栈，若当前元素大于栈顶元素，就将栈顶元素再入一次栈（s2与s1元素个数保持先相同）

class MinStack {
    //s1保存实际元素
    Stack<Integer> s1 = new Stack<>();
    //s2保存最小元素
    Stack<Integer> s2 = new Stack<>();
    public MinStack() {
        
    }
    
    public void push(int val) {
        s1.push(val);
        if(s2.isEmpty()){
            s2.push(val);
        }else{
        int peek = s2.peek();
        s2.push(Math.min(val,peek));
    }
}
    
    public void pop() {
        s1.pop();
        s2.pop();
    }
    
    public int top() {
        return s1.peek();
    }
    
    public int getMin() {
        return s2.peek();
    }
}

3.用栈实现队列

LeetCode用栈实现队列
题目描述：

请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）：
实现 MyQueue 类：
void push(int x) 将元素 x 推到队列的末尾 int pop() 从队列的开头移除并返回元素 int peek()
返回队列开头的元素 boolean empty() 如果队列为空，返回 true ；否则，返回 false

解题思路：双栈思路，一个栈用于辅助，一个栈存储元素，将s1的所有元素弹出压入s2，交换顺序，s1空时再将新元素压入s1，新元素就为栈底元素，再将s2的元素弹回s1.

class MyQueue {
    //s1保存元素
    Stack<Integer> s1 = new Stack<>();
    //s2作为辅助，s1的栈顶元素会弹出压入s2中(交换顺序)
    Stack<Integer> s2 = new Stack<>();

    public MyQueue() {

    }
    
    public void push(int x) {
        //让si的所有元素弹出压入s2中，交换顺序
        while(!s1.isEmpty()){
            s2.push(s1.pop());
        }
        //s1为空，新元素直接压入s1为栈底元素
        s1.push(x);
        //将s2的元素依次弹回s1
        while(!s2.isEmpty()){
            s1.push(s2.pop());
        }
    }
    
    public int pop() {
        return s1.pop();
    }
    
    public int peek() {
        return s1.peek();
    }
    
    public boolean empty() {
        return s1.isEmpty();
    }
}