《算法通关村—最大小栈问题解析》

最小栈

描述

leetCode 155: 设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。

实现最小栈

MinStack() 初始化堆栈对象。
void push(int val) 将元素val推入堆栈。 
void pop() 删除堆栈顶部的元素。 
int top() 获取堆栈顶部的元素。
int getMin() 获取堆栈中的最小元素。

怎么才能在常数时间内拿到最小元素，我们通过设计两个栈，一个栈存储元素，一个栈存储最小元素（这个存储的是当前元素加入进来的时候，整个栈中最小的元素，比如说）

# 储存元素的栈为stack，最小元素的栈为minStack 
push(5);
stack -> [5];
minStack -> [5];
push(6) ;
stack -> [5,6];
minStack -> [5,5]; # 这里如果插入的时候就跟当前最小栈中的元素比较，如果更小就插入，如果没有更小就插入原来最小的。

通过有这样两个栈，对原来元素的栈进行操作的时候，同时对最小栈进行操作，这样就能保证在常数时间内获得栈内最小元素了。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

实现代码

package AlgorithmForth;

import java.util.Deque;
import java.util.LinkedList;

/**
 * 最小栈
 */
public class MinStack {
    Deque<Integer> xStack;
    Deque<Integer> minStack;

    public MinStack() {
        xStack = new LinkedList<>();
        minStack = new LinkedList<>();
        minStack.push(Integer.MAX_VALUE);
    }

    public void push(int x) {
        xStack.push(x);
        minStack.push(Math.min(minStack.peek(), x));
    }

    public void pop() {
        xStack.pop();
        minStack.pop();
    }

    public int top() {
        return xStack.peek();
    }

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

    public static void main(String[] args) {
        MinStack minStack1  = new MinStack();
        minStack1.push(1);
        minStack1.push(8);
        minStack1.push(2);
        minStack1.push(12);
        minStack1.push(8);
        System.out.println(minStack1.getMin());
    }
}

最大栈

LeetCode 716.设计一个最大栈数据结构，既支持栈操作，又支持查找栈中最大元素

实现MaxStack

MaxStack() 初始化栈对象 
void push(int x) 将元素 x 压入栈中。 
int pop() 移除栈顶元素并返回这个元素。 
int top() 返回栈顶元素，无需移除。 
int peekMax() 检索并返回栈中最大元素，无需移除。 
int popMax() 检索并返回栈中最大元素，并将其移除。 如果有多个最大元素，只要移除 最靠近栈顶 的那个。

最大栈的实现其实和最小栈是差不多的，都是通过两个栈来实现常数查找到最大。

直接上代码

package AlgorithmForth;

import java.util.Stack;

/**
 * 最大栈
 */
public class MaxStack {
    Stack<Integer> stack;
    Stack<Integer> maxStack;

    public MaxStack() {
        stack = new Stack<>();
        maxStack = new Stack<>();
    }

    public void push(int x) {
        int max = maxStack.isEmpty() ? x : maxStack.peek();
        maxStack.push(max > x ? max : x);
        stack.push(x);
    }

    public int pop() {
        maxStack.pop();
        return stack.pop();
    }

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

    public int peekMax() {
        return maxStack.peek();
    }

    public int popMax() {
        int max = peekMax();
        Stack<Integer> buffer = new Stack<>();
        while (top() != max) buffer.push(pop());
        pop();
        while (!buffer.isEmpty()) push(buffer.pop());
        return max;
    }

    public static void main(String[] args) {
        MaxStack maxStack1 = new MaxStack();
        maxStack1.push(1);
        maxStack1.push(8);
        maxStack1.push(2);
        maxStack1.push(12);
        maxStack1.push(8);
        System.out.println(maxStack1.peekMax());
    }
}