知识改变命运 数据结构【栈和队列面试题】

1.最小栈

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 {
            int topval=minStack.peek();
            if(val<=topval) {
                minStack.push(val);
            }
        }
       
    }
    
    public void pop() {
        if(stack.peek().equals(minStack.peek())) {
            minStack.pop();
        }
        stack.pop();

    }
    
    public int top() {
       return stack.peek();
    }
    
    public int getMin() {
       return minStack.peek();
    }
}

2. 括号匹配

public class Solution {

    public boolean isValid(String s) {
        Stack<Character> stack=new Stack<>();
        char ch;
        for (int i = 0; i < s.length(); i++) {
            ch=s.charAt(i);
            if(ch=='{'||ch=='['||ch=='(') {
                stack.push(ch);
            } else if (stack.empty()){
                return false;
            } else if(stack.peek().equals('(')&&ch==')'||
                    stack.peek().equals('{')&&ch=='}'||
                    stack.peek().equals('[')&&ch==']'){
                stack.pop();
            } else {
                return false;
            }
        }
        return stack.empty();
    }
}

3. 逆波兰表达式求值

public class Solution {
    public int evalRPN(String[] tokens) {
        Stack<Integer> stack=new Stack<>();
        for (int i = 0; i <tokens.length; i++) {
            if(opinion(tokens[i])) {
                int val1=stack.pop();
                int val2=stack.pop();
                switch(tokens[i]) {
                    case "+":
                        stack.push(val1+val2);
                        break;
                    case "-":
                        stack.push(val2-val1);
                        break;
                   case  "*":
                        stack.push(val1*val2);
                        break;
                    case "/":
                        stack.push(val2/val1);
                        break;
                }
            } else {
                stack.push(Integer.parseInt(tokens[i]));
            }

        }
       return stack.pop();
    }
    private boolean opinion(String ch) {
        return ch.equals("*")||ch.equals("+")
                ||ch.equals("/")||ch.equals("-");
    }
}

4.出栈入栈次序匹配

  public boolean IsPopOrder (int[] pushV, int[] popV) {
    
         Stack<Integer> stack1=new Stack();
     
         int j=0;
         for(int i=0;i<pushV.length;i++) {
            stack1.push(pushV[i]);
            while(j<popV.length&&!stack1.empty()&&stack1.peek()==popV[j]) {
                stack1.pop();
                j++;
            }
            
         }
        return stack1.empty();
    }
}

5. 用队列实现栈。OJ链接

public class MyStack {
    Queue<Integer> queue1;
    Queue<Integer> queue2;
    public MyStack() {
        queue1=new LinkedList<>();
        queue2=new LinkedList<>();
    }

    public void push(int x) {
        if(empty()){
            queue1.offer(x);
        } else if  (!queue2.isEmpty()){
            queue2.offer(x);

        } else  {
            queue1.offer(x);
        }
    }


    public int pop() {
        int val=0;
        if(empty()) {
            return -1;
        } else {
            if (!queue1.isEmpty()) {
                int count=queue1.size()-1;
                while(count!=0) {
                    queue2.offer(queue1.poll());
                    count--;
                }
                val=queue1.poll();
            }else {
                int count=queue2.size()-1;
                while(count!=0) {
                    queue1.offer(queue2.poll());
                    count--;
                }
                val= queue2.poll();
            }
        }
        return val;
    }

    public int top() {
        int temp=0;
        if(empty()) {
            return -1;
        } else {
            if (!queue1.isEmpty()) {
                int count=queue1.size();
                while(count!=0) {
                    temp=queue1.peek();
                    queue2.offer(queue1.poll());
                    count--;
                }
            }else  {
                int count=queue2.size();
                while(count!=0) {
                    temp=queue2.peek();
                    queue1.offer(queue2.poll());
                    count--;
                }
            }
        }
        return temp;

    }

    public boolean empty() {
        return queue1.isEmpty()&&queue2.isEmpty();
    }
}

2. 用栈实现队列。OJ链接

public class MyQueue {
    Stack<Integer> stack1;
    Stack<Integer> stack2;
    public MyQueue() {
        stack1=new Stack<>();
        stack2=new Stack<>();
    }

    public void push(int x) {
        stack1.push(x);
    }

    public int pop() {
        if(!stack2.empty()) {
             int val= stack2.pop();
           return val;
        } else if(!stack1.empty()) {
           int count = stack1.size();
           while(count!=0) {
               stack2.push(stack1.pop());
               count--;
           }
           return stack2.pop();
        }
        return -1;
    }

    public int peek() {
        if(!stack2.empty()) {
            int val= stack2.peek();
           return val;
        } else if(!stack1.empty()) {
            int count = stack1.size();
            while(count!=0) {
                stack2.push(stack1.pop());
                count--;
            }
           int val=stack2.peek();
            return val;
        }
        return -1;
    }

    public boolean empty() {
        return stack1.empty()&&stack2.empty();
    }
}