LeetCode 155 最小栈：题解

题目如图：

链接：

解法一：
思路：
1.构造链表栈
2.在每次push的时候检查最小值变动
3.在每次pop的时候遍历检查最小值变动
4.top和getMin直接返回
代码：

  public class leetcode155 {
    static class Stack {
    Node head;
    Node tail;
    Node curr;
    Node min;
    boolean isEmpty;

    public Stack(){
        isEmpty = true;
    }

    public void push(int x){
        if(isEmpty){
            head = new Node(x);
            tail = head;
            curr = head;
            min = head;
            isEmpty = false;
        }else {
            tail.next = new Node(x);
            tail.next.pre = tail;
            tail = tail.next;
            if(tail.value < min.value){
                min = tail;
            }
        }
    }

    public void pop(){
        if(!isEmpty){
            if(tail == head){
                head = null;
                tail = null;
                min = null;
                curr = null;
                isEmpty = true;
            }else {
                if(tail == min){
                    tail = tail.pre;
                    tail.next.pre = null;
                    tail.next = null;
                    curr = head;
                    min = tail;
                    while (curr!=null){
                        if(curr.value < min.value){
                            min = curr;
                        }
                        curr = curr.next;
                    }
                }else {
                    tail = tail.pre;
                    tail.next.pre = null;
                    tail.next = null;
                }
            }
        }
    }

    public int top(){
        return tail.value;
    }

    public int getMin(){
        return min.value;
    }



    class Node{
        int value;
        Node next;
        Node pre;

        public Node(){

        }

        public Node(int value){
            this.value = value;
        }
    }
    }
  }

解法二
思路：
构造辅助栈，在每次push的时候将该状态最小值放进辅助栈中，每次pop的时候同时从辅助栈和主栈pop，getMin返回辅助栈top
代码：

    public class leetcode155_2 {


    class MinStack{
        Stack mainStack = new Stack();
        Stack minStack = new Stack();

        class Stack{
            Node head;
            Node curr;

            public Stack(){
                head = new Node();
                curr = head;
            }

            public void push(int x){
                curr.next = new Node(x);
                curr.next.pre = curr;
                curr = curr.next;
            }

            public void pop(){
                if(curr != head){
                    curr = curr.pre;
                    curr.next.pre = null;
                    curr.next = null;
                }
            }

            public int top(){
                return curr.value;
            }

            class Node{
                int value;
                Node pre;
                Node next;

                public Node(){}

                public Node(int value){
                    this.value = value;
                }
            }
        }

        public MinStack(){

        }

        public void push(int x){
            mainStack.push(x);
            if(minStack.curr == minStack.head){
                minStack.push(x);
            }else{
                if(x < minStack.curr.value){
                    minStack.push(x);
                }else {
                    minStack.push(minStack.curr.value);
                }
            }
        }

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

        public int top(){
            return mainStack.curr.value;
        }

        public int getMin(){
            return minStack.curr.value;
        }
    }



}

解法三：
思路：
将辅助栈去掉将每次的min放到node里面
代码：

 class MinStack {
      private Node head;

      public void push(int x) {
          if(head == null) 
              head = new Node(x, x);
          else 
              head = new Node(x, Math.min(x, head.min), head);
      }
  	  public void pop() {
          head = head.next;
      }
  public int top() {
          return head.val;
      }
  public int getMin() {
          return head.min;
      }

      private class Node {
          int val;
          int min;
          Node next;
    
          private Node(int val, int min) {
              this(val, min, null);
          }
    
          private Node(int val, int min, Node next) {
              this.val = val;
              this.min = min;
              this.next = next;
          }
      }
  }