Java:数据结构-栈(Stack)

一 栈(Stack) 

栈是一种特殊的线性表，只允许一边进，一边出

进法：

出法： 

 注：遵循后进先出原则

栈的使用

自己模拟实现一下栈的方法：

1.数组法：

public class MyStack {
    public int[] elem;
    public int usedSize;
    public MyStack(){
        this.elem=new int[10];
    }
//加入栈的元素
    public void push(int val){
        if(isFull()){
            this.elem= Arrays.copyOf(elem,2*elem.length);
        }
        elem[usedSize++]=val;

    }
    public boolean isFull(){
        return usedSize==elem.length;
    }
    //删除栈中的元素
    public int pop(){
        if (isEmpty()){
            throw new EmptyStackException("栈为空");
        }
        int val=elem[usedSize-1];
        usedSize--;
        return val;
    }
    //获取栈中的元素，但不删除
    public int peek(){
        if (isEmpty()){
            throw new EmptyStackException("栈为空");
        }
        return elem[usedSize-1];
    }

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

}

2.如果要用单链表实现栈：

要注意使用尾插法，入栈的时间复杂度为O（N），如果有last，时间复杂度为O（1），但是出栈时时间复杂度一定是O（N）。如果使用头插法，入栈和出栈的时间复杂度都是O（1）。

3.如果使用双链表实现栈：

不管是头插还是尾插时间复杂度都可以达到O（1）。

一些关于栈的面试题

1.括号匹配

题目链接：. - 力扣（LeetCode）

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);
            if(ch=='{' || ch=='('|| ch=='['){
                stack.push(ch);
            }else{
                if(stack.isEmpty()){
                    return false;
                }
                char ch2=stack.peek();
                if((ch == '}' && ch2 == '{') || (ch == ')' && ch2 == '(') || (ch == ']' && ch2 == '[')){
                    stack.pop();
                }else{
                    return false;
                }
            }
        }
        return stack.isEmpty();
    }
}

2.逆波兰表达式求值

 题目链接：. - 力扣（LeetCode）

如果要完全理解这道题，首先你需要了解中缀表达式和后缀表达式，

class Solution {
    public int evalRPN(String[] tokens) {
        Stack<Integer> stack =new Stack<>();
        for(String str:tokens){
             if(!isOperator(str)) {
                int x=Integer.parseInt(str);
                stack.push(x);
            }else{
                int val2=stack.pop();
                int val1=stack.pop();
                switch(str){
                    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();
    }
    private boolean isOperator(String str){
        if(str.equals("+") || str.equals("-") || str.equals("*") || str.equals("/")){
            return true;
        }
        return false;
    }

}

3.出栈入栈次序匹配

题目链接：栈的压入、弹出序列_牛客题霸_牛客网 

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

}

4.最小栈

题目链接：. - 力扣（LeetCode） 

class MinStack {
    public Stack<Integer> stack;
    public 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{
            int peekval=minStack.peek();
            if(peekval>=val){
                minStack.push(val);
            }
        }
    }
    
    public void pop() {
        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;
        }else{
            return minStack.peek();
        }
    }
}

 希望能对大家有所帮助！！！！