Java数据结构栈

栈（Stack）

概念

栈是一种先进后出的数据结构。

栈的使用

import java.util.Stack;
public class Test {
    public static void main(String[] args) {
        Stack<Integer> s = new Stack();
        s.push(1);
        s.push(2);
        s.push(3);
        s.push(4);
        System.out.println(s.size()); // 获取栈中有效元素个数---> 4
        System.out.println(s.peek()); // 获取栈顶元素---> 4 但不删除
        s.pop(); // 4出栈，栈中剩余1 2 3，栈顶元素为3
        System.out.println(s.pop()); // 3出栈，栈中剩余1 2 栈顶元素为3
        if (s.empty()) {
            System.out.println("栈空");
        } else {
            System.out.println(s.size());
        }
    }
}

栈的模拟实现

import java.util.Arrays;

public class MyStack {
    public int[] elem;
    public int usedSize;

    public MyStack() {
        this.elem = new int[10];
    }

    public void push(int val) {
        if (isFull()) {
            //扩容
            elem = Arrays.copyOf(elem, 2 * elem.length);
        }
        elem[usedSize] = val;
        usedSize++;
    }

    public boolean isFull() {
        return usedSize == elem.length;
    }

    public int pop() {
        if (empty()) {
            return -1;
        }
        int oldVal = elem[usedSize - 1];
        usedSize--;
        //如果为引用类型 还需加上elem[usedSize]=null;
        return oldVal;
    }

    public boolean empty() {
        return usedSize == 0;
    }

    public int peek() {
        if (empty()) {
            return -1;
        }
     /* int oldVal=elem[usedSize-1];
      usedSize--;
      return oldVal;*/
        return elem[usedSize - 1];
    }
}

栈的应用场景

1. 改变元素的序列

1. 若进栈序列为 1,2,3,4 ，进栈过程中可以出栈，则下列不可能的一个出栈序列是（）
A: 1,4,3,2    B: 2,3,4,1    C: 3,1,4,2    D: 3,4,2,1

2.一个栈的初始状态为空。现将元素1、2、3、4、5、A、B、C、D、E依次入栈，然后再依次出栈，则元素出栈的顺序是（ ）。
A: 12345ABCDE    B: EDCBA54321    C: ABCDE12345    D: 54321EDCBA

2. 将递归转化为循环
比如：逆序打印链表

// 递归方式
void printList(Node head){
if(null != head){
printList(head.next);
System.out.print(head.val + " ");
}
} 

// 循环方式
void printList(Node head){
if(null == head){
return;
} 

Stack<Node> s = new Stack<>();
// 将链表中的结点保存在栈中
Node cur = head;
while(null != cur){
s.push(cur);
cur = cur.next;
}

//将栈中的元素出栈
while(!s.empty()){
System.out.print(s.pop().val + " ");
}
}

3.逆波兰表达式求值

class Solution {
    public int evalRPN(String[] tokens) {
        Stack<Integer> stack = new Stack<>();
        for (int i = 0; i < tokens.length; i++) {
            String tmp = tokens[i];
            if (!isOpearation(tmp)) {
                Integer val = Integer.valueOf(tmp);
                stack.push(val);
            } else {
                Integer val2 = stack.pop();
                Integer val1 = stack.pop();
                switch (tmp) {
                    case "+":
                        stack.push(val1 + val2);
                        break;

                    case "-":
                        stack.push(val1 - val2);
                        break;

                    case "*":
                        stack.push(val1 * val2);
                        break;

                    case "/":
                        stack.push(val1 / val2);
                        break;
                }
            }
        }
        return stack.pop();
    }

    public boolean isOpearation(String s) {
        if (s.equals("+") || s.equals("-") || s.equals("*") || s.equals("/")) {
            return true;
        }
        return false;
    }
}

4.括号匹配

class Solution {
    public boolean isValid(String s) {
        Stack<Character> stack = new Stack<>();
        for (int i = 0; i < s.length(); i++) {
            char ch = s.charAt(i);
            // 1.左括号入栈
            if (ch == '(' || ch == '{' || ch == '[') {
                stack.push(ch);
            } else {
                // 2.遇到了右括号
                if (stack.empty()) {
                    return false;
                } else {
                    // 3.取栈顶元素的左括号 看和 当前右括号是否匹配
                    char chL = stack.peek();
                    if (chL == '(' && ch == ')' || chL == '[' && ch == ']'
                            || chL == '{' && ch == '}') {
                        // 4.证明当前这一对括号是匹配的
                        stack.pop();
                    } else {
                        // 5.当前括号不匹配
                        return false;
                    }
                }
            }
        }
        return stack.empty();
    }
}

5.出栈入栈次序匹配

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param pushV int整型一维数组
     * @param popV int整型一维数组
     * @return bool布尔型
     */
    public boolean IsPopOrder (int[] pushV, int[] popV) {
        // write code here
        Stack<Integer> stack = new Stack<>();
        int j = 0;
        for (int i = 0; i < pushV.length; i++) {
            stack.push(pushV[i]);
            while (j < popV.length && !stack.empty()
                    && stack.peek() == popV[j]) {
                stack.pop();
                j++;
            }
        }
        return stack.empty();
    }
}

6. 最小栈

class MinStack {
    Stack<Integer> stack;
    Stack<Integer> minStack;

    public MinStack() {
        stack = new Stack<>();
        minStack = new Stack<>();
    }

    public void push(int val) {
        stack.push(val);
        if (minStack.empty()) {
            minStack.push(val);
        } else {
            Integer peekVal = minStack.peek();
            if (val <= peekVal) {
                minStack.push(val);
            }
        }
    }

    public void pop() {
        if (stack.empty()) {
            return;
        }
        int popVal = stack.pop();
        if (popVal == minStack.peek()) {
            minStack.pop();
        }
    }

    public int top() {
        if (stack.empty()) {
            return -1;
        }
        return stack.peek();
    }

    // 要求：常数时间范围内 获取到栈当中的最小值
    public int getMin() {
        if (minStack.empty()) {
            return -1;
        }
        return minStack.peek();
    }
}

/**
 * Your MinStack object will be instantiated and called as such:
 * MinStack obj = new MinStack();
 * obj.push(val);
 * obj.pop();
 * int param_3 = obj.top();
 * int param_4 = obj.getMin();
 */

Java集合类的Stack底层是一个数组，这种栈叫做顺序栈，栈可以用链表实现。

import java.util.LinkedList;

public class Test {
    public static void main(String[] args) {
        LinkedList<Integer> stack = new LinkedList<>();
        stack.push(10);//头插法入栈
        stack.push(20);
        stack.push(30);

        stack.pop();
    }
}