数据结构——leetcode（栈和队列练习）【java】

leetcode-232-用栈实现队列

力扣-232
题目：
使用栈实现队列的下列操作：
push(x) – 将一个元素放入队列的尾部。
pop() – 从队列首部移除元素。
peek() – 返回队列首部的元素。
empty() – 返回队列是否为空。

示例：
MyQueue queue = new MyQueue();

queue.push(1);
queue.push(2);
queue.peek(); // 返回 1
queue.pop(); // 返回 1
queue.empty(); // 返回 false

思路：栈为先进后出，队列为先进先出，所以栈要实现队列，需要定义两个栈才能实现队列

class MyQueue {
    private Stack<Integer> in ;
    private Stack<Integer> out;
    /** Initialize your data structure here. */
    public MyQueue() {
        in = new Stack<>();
        out = new Stack<>();
    }
    
    /** Push element x to the back of queue. */
    public void push(int x) {
       in.push(x);

    }
    
    /** Removes the element from in front of queue and returns that element. */
    public int pop() {
        //如果输出栈为空，则输入栈全部压入out中，之后再out.pop
        if(out.isEmpty()){
            while(!in.isEmpty()){
                out.push(in.pop());
            }
        }
        return out.pop();
    }
    
    /** Get the front element. */
    public int peek() {
        if(out.isEmpty()){
            while(!in.isEmpty()){
                out.push(in.pop());
            }
        }
        return out.peek();

    }
    
    /** Returns whether the queue is empty. */
    public boolean empty() {
        return in.isEmpty()&&out.isEmpty();
    }
}

/**
 * Your MyQueue object will be instantiated and called as such:
 * MyQueue obj = new MyQueue();
 * obj.push(x);
 * int param_2 = obj.pop();
 * int param_3 = obj.peek();
 * boolean param_4 = obj.empty();
 */

leetcode-232-用队列实现栈

力扣-225
题目：
使用队列实现栈的下列操作：
push(x) – 元素 x 入栈
pop() – 移除栈顶元素
top() – 获取栈顶元素
empty() – 返回栈是否为空

思路：

class MyStack {
    private Queue<Integer> a;//输入队列
    private Queue<Integer> b;//输出队列
    /** Initialize your data structure here. */
    public MyStack() {
        a = new LinkedList<>();
        b = new LinkedList<>();

    }
    
    /** Push element x onto stack. */
    public void push(int x) {
        a.offer(x);
        //将b队列放入a中
        while(!b.isEmpty()){
            a.offer(b.poll());
        }
        //交换a和b，让a在没有push()为空
        Queue temp = a;
        a = b;
        b = temp;

    }
    
    /** Removes the element on top of the stack and returns that element. */
    public int pop() {
        return b.poll();
    }
    
    /** Get the top element. */
    public int top() {
        return b.peek();

    }
    
    /** Returns whether the stack is empty. */
    public boolean empty() {
        return b.isEmpty();
    }
}

/**
 * Your MyStack object will be instantiated and called as such:
 * MyStack obj = new MyStack();
 * obj.push(x);
 * int param_2 = obj.pop();
 * int param_3 = obj.top();
 * boolean param_4 = obj.empty();
 */

leetcode-155-最小栈

力扣-225
题目：
设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。
push(x) —— 将元素 x 推入栈中。
pop() —— 删除栈顶的元素。
top() —— 获取栈顶元素。
getMin() —— 检索栈中的最小元素。
示例：
输入：
[“MinStack”,“push”,“push”,“push”,“getMin”,“pop”,“top”,“getMin”]
[[],[-2],[0],[-3],[],[],[],[]]

输出：
[null,null,null,null,-3,null,0,-2]

解释：
MinStack minStack = new MinStack();
minStack.push(-2);
minStack.push(0);
minStack.push(-3);
minStack.getMin(); --> 返回 -3.
minStack.pop();
minStack.top(); --> 返回 0.
minStack.getMin(); --> 返回 -2.、

思路：辅助栈和数据栈同步,

class MinStack {
    private Stack<Integer> dataStack;
    private Stack<Integer> minStack;
    /** initialize your data structure here. */
    public MinStack() {
        dataStack = new Stack<>();
        minStack = new Stack<>();
    }
    
    public void push(int x) {
        dataStack.add(x);
        if(minStack.isEmpty()||minStack.peek()>=x){
            minStack.add(x);
        }else{
            minStack.add(minStack.peek());
        }

    }
    
    public void pop() {
        if(!dataStack.isEmpty()){
            dataStack.pop();
            minStack.pop();
        }

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

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

leetcode-20-用栈实现括号匹配

力扣-20
题目：
给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串，判断字符串是否有效。

有效字符串需满足：
左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。

示例：
示例 1:
输入: “()”
输出: true

示例 2:
输入: “()[]{}”
输出: true

示例 3:
输入: “(]”
输出: false

思路：遍历输入的字符，存入栈中（先入后出），一次压入，再把栈顶弹出，判断是否匹配

class Solution {
    public boolean isValid(String s) {
        Stack<Character> stack = new Stack<Character>();
        for(char c: s.toCharArray()){
            if(c=='(' ) stack.push(')');
            else if(c=='[') stack.push(']');
            else if(c=='{') stack.push('}');
            else if(stack.isEmpty()||c!=stack.pop()) return false;
        }
        return stack.isEmpty();
    }
}

leetcode-739-数组中元素与下一个比它大的元素之间的距离(每日温度)

力扣-739
题目：
请根据每日 气温 列表，重新生成一个列表。对应位置的输出为：要想观测到更高的气温，至少需要等待的天数。
如果气温在这之后都不会升高，请在该位置用 0 来代替。

示例：
例如，给定一个列表 temperatures = [73, 74, 75, 71, 69, 72, 76, 73]，你的输出应该是 [1, 1, 4, 2, 1, 1, 0, 0]。

思路：维护单调栈
如果第三天75则需要到4天后的76才大于75，所以对应为4，如果发现栈压入比栈底元素数据值大，则弹出栈顶元素并删除，栈底的值减去弹出的栈值。
动态图解

class Solution {
    public int[] dailyTemperatures(int[] T) {
        Stack<Integer> stack = new Stack<>();
        int length = T.length;
        int [] result = new int[length];
        for(int i = 0;i<length;i++){
            while(!stack.isEmpty()&&T[i]>T[stack.peek()]){
                int pre = stack.pop();
                result[pre] = i-pre;
            }
            stack.add(i);
        }
        return result;
    }
}

关于单调栈维护相关题：
力扣-42 接雨水
力扣-84 柱状图中最大矩形

leetcode-503-循环数组中比当前元素大的下一个元素

力扣-503
题目：
给定一个循环数组（最后一个元素的下一个元素是数组的第一个元素），输出每个元素的下一个更大元素。数字 x 的下一个更大的元素是按数组遍历顺序，这个数字之后的第一个比它更大的数，这意味着你应该循环地搜索它的下一个更大的数。如果不存在，则输出 -1。

示例：
输入: [1,2,1]
输出: [2,-1,2]
解释: 第一个 1 的下一个更大的数是 2；
数字 2 找不到下一个更大的数；
第二个 1 的下一个最大的数需要循环搜索，结果也是 2。

思路：与 739. Daily Temperatures (Medium) 不同的是，数组是循环数组，并且最后要求的不是距离而是下一个元素,单调栈维护。

class Solution {
    public int[] nextGreaterElements(int[] nums) {
        Stack<Integer> stack = new Stack<>();
        int length = nums.length;
        int[] result = new int [length];
        Arrays.fill(result, -1);
        for(int i = 0;i<2*length;i++){
            int num = nums[i%length];
            while(!stack.isEmpty()&&nums[stack.peek()]<num){
                result[stack.pop()]=num; 
            }
            if(i<length){
                stack.push(i);
            }
        }
        return result;
    }
}