Leetcode-Stack-Easy(20, 155, 225, 232)

最新推荐文章于 2025-07-29 14:24:32 发布

原创最新推荐文章于 2025-07-29 14:24:32 发布 · 154 阅读

0 ·

CC 4.0 BY-SA版权

本文介绍如何使用栈进行括号匹配验证，并提供两种不同的实现方式。此外，还展示了如何利用队列和栈的基本操作实现栈和队列的功能，包括关键方法如push、pop、top等。

Valid Parentheses
Given a string s containing just the characters ‘(’, ‘)’, ‘{’, ‘}’, ‘[’ and ‘]’, determine if the input string is valid.
对string遍历，左括号压栈，右括号检测栈不为空，且pop出来的是配对的符号，否则无效return false

//1 ms，37.2 MB
class Solution1 {
    public boolean isValid(String s) {
        Stack<Character> stack = new Stack<>();
        
        for(int i=0;i<s.length();i++){
            char c = s.charAt(i);
            switch(c) {
                case ')':
                  if(stack.isEmpty() || stack.pop()!='('){return false;}
                  break;
                case '}':
                    if(stack.isEmpty() || stack.pop()!='{'){return false;}
                    break;
                case ']':
                    if(stack.isEmpty() || stack.pop()!='['){return false;}
                    break;
                default:
                  stack.push(c);
            }
        }
        return stack.isEmpty();
    }
}

用HashMap记录的方法如下

//1 ms,37.2 MB
class Solution2 {
    public boolean isValid(String s) {
        Stack<Character> stack = new Stack<>();
        Map<Character,Character> map = new HashMap<>();
        map.put('(',')');
        map.put('{','}');
        map.put('[',']');
        
        for(int i=0;i<s.length();i++){
            char c = s.charAt(i);
            if(map.containsKey(c)){
                stack.push(c);
            }else{
                if(!stack.isEmpty()){
                   if(c!=map.get(stack.pop())){
                       return false;
                   }
                }else{
                    return false;
                }
            }
        }
        return stack.isEmpty();
    }
}

Min Stack

/**
 * ArrayList用来遍历更新最小值，因此pop()时间复杂度是O(n),其余操作为O(1)
 */
class MinStack {
    private Stack<Integer> stackData;
    private ArrayList<Integer> listData;
    private int min;

    /** initialize your data structure here. */
    public MinStack() {
        stackData = new Stack<Integer>();
        listData = new ArrayList<Integer>();
        min = Integer.MAX_VALUE;
    }
    
    public void push(int x) {
        stackData.push(x);
        listData.add(x);
        if(x<min){
            min = x;
        }
    }
    
    public void pop() {
        int item=stackData.pop();
        if(listData.size()>0){
            listData.remove(listData.size()-1);
            min = Integer.MAX_VALUE;
            for(int i=0;i<listData.size();i++){
                if(min>listData.get(i)){
                    min=listData.get(i);
                }
            }
        }
    }
    
    public int top() {
       return stackData.peek(); 
    }
    
    public int getMin() {
        return min;
    }
}

/**
 * 神奇的算法：用min作为最小栈来记录，如果新入元素比顶端元素小就进，否则进顶端元素
 * num和min元素数量保持一致
 */
class MinStack {
    Stack<Integer> num;
    Stack<Integer> min;

    /** initialize your data structure here. */
    public MinStack() {
        num = new Stack<Integer>();
        min = new Stack<Integer>();
    }
    
    public void push(int x) {
        num.push(x);
        if(min.empty() || x<min.peek()){
            min.push(x);
        }else{
            min.push(min.peek());
        }
    }
    
    public void pop() {
        num.pop();
        min.pop();
    }
    
    public int top() {
        return num.peek();
    }
    
    public int getMin() {
        return min.peek();
    }
}

Implement Stack using Queues
void push(int x) Pushes element x to the top of the stack.
int pop() Removes the element on the top of the stack and returns it.
int top() Returns the element on the top of the stack.
boolean empty() Returns true if the stack is empty, false otherwise.
Notes:
You must use only standard operations of a queue, which means only push to back, peek/pop from front, size, and is empty operations are valid.
Depending on your language, the queue may not be supported natively. You may simulate a queue using a list or deque (double-ended queue), as long as you use only a queue’s standard operations.

/**
 * 直白的思路：q记录所有元素，temp打辅助
 * 0 ms	36.8 MB 
 */
class MyStack {
    Queue<Integer> q;
    Queue<Integer> temp;

    /** Initialize your data structure here. */
    public MyStack() {
        q = new LinkedList<>();
        temp = new LinkedList<>();
    }
    
    /** Push element x onto stack. */
    public void push(int x) {
        q.offer(x);
    }
    
    /** Removes the element on top of the stack and returns that element. */
    public int pop() {
        while(q.size()>1){
            temp.offer(q.poll());
        }
        int rtn = q.poll();
        q=temp;
        temp=new LinkedList<Integer>();
        return rtn;
    }
    
    /** Get the top element. */
    public int top() {
         while(q.size()>1){
            temp.offer(q.poll());
        }
        int rtn = q.poll();
        q=temp;
        q.offer(rtn);
        temp=new LinkedList<Integer>();
        return rtn;
    }
    
    /** Returns whether the stack is empty. */
    public boolean empty() {
        return q.isEmpty();
    }
}

/**
 * 神奇的思路：q记录所有元素，push方法中保证新入元素在队列首
 * 0 ms	36.9 MB 
 */
class MyStack {
    Queue<Integer> q = new LinkedList<>();;

    /** Push element x onto stack. */
    public void push(int x) {
        q.offer(x);
        for(int i=0;i<q.size()-1;i++){
            q.offer(q.poll());
        }
    }
    
    /** Removes the element on top of the stack and returns that element. */
    public int pop() {
       return q.poll();
    }
    
    /** Get the top element. */
    public int top() {
       return q.peek();
    }
    
    /** Returns whether the stack is empty. */
    public boolean empty() {
        return q.isEmpty();
    }
}

Implement Queue using Stacks
void push(int x) Pushes element x to the back of the queue.
int pop() Removes the element from the front of the queue and returns it.
int peek() Returns the element at the front of the queue.
boolean empty() Returns true if the queue is empty, false otherwise.
Notes:
You must use only standard operations of a stack, which means only push to top, peek/pop from top, size, and is empty operations are valid.
Depending on your language, the stack may not be supported natively. You may simulate a stack using a list or deque (double-ended queue) as long as you use only a stack’s standard operations.

/**
 * 直白的思路：stack记录所有元素，temp打辅助
 * 0 ms	37.2 MB
 */
class MyQueue {
    Stack<Integer> stack = new Stack<>();
    Stack<Integer> temp = new Stack<>();
    
    /** Initialize your data structure here. */
    public MyQueue() {        
    }
    
    /** Push element x to the back of queue. */
    public void push(int x) {
        stack.push(x);
    }
    
    /** Removes the element from in front of queue and returns that element. */
    public int pop() {
        while(!stack.isEmpty()){
            temp.push(stack.pop());
        }
        int rtn = temp.pop();
        while(!temp.isEmpty()){
            stack.push(temp.pop());
        }
        return rtn;
    }
    
    /** Get the front element. */
    public int peek() {
        while(!stack.isEmpty()){
            temp.push(stack.pop());
        }
        int rtn = temp.peek();
        while(!temp.isEmpty()){
            stack.push(temp.pop());
        }
        return rtn;
    }
    
    /** Returns whether the queue is empty. */
    public boolean empty() {
        return stack.isEmpty();
    }
}

/**
 * 神奇的思路：stack用来记录进来的元素，helper负责出去的元素，peek()保证了helper里有内容，代码简洁一些
 * 0 ms	36.6 MB
 */
class MyQueue {
    Stack<Integer> stack = new Stack<>();
    Stack<Integer> helper = new Stack<>();

    /** Initialize your data structure here. */
    public MyQueue() {
        
    }
    
    /** Push element x to the back of queue. */
    public void push(int x) {
        stack.push(x);
    }
    
    /** Removes the element from in front of queue and returns that element. */
    public int pop() {
        peek();
        return helper.pop();
    }
    
    /** Get the front element. */
    public int peek() {
        if(helper.isEmpty()){
            while(!stack.isEmpty()){
                helper.push(stack.pop());
            }
        }
        return helper.peek();
    }
    
    /** Returns whether the queue is empty. */
    public boolean empty() {
        return stack.isEmpty()&&helper.isEmpty();
    }
}