剑指Offer(牛客网 Java)20——包含min函数的栈

题目描述

定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O（1））。

解题思路

• List排序
  在push的时候，用一个List同步存储数据。
  每一次调用min的时候，将List排序，获取最小值。
  虽然这个代码牛客可以通过，但是这时候的时间复杂度并不符合要求。
• Stack存储
  使用一个新的Stack<Integer> min存储最小值。
  当push的时候，在stack入栈之后，如果min为空，直接将该值入栈min。
  如果不为空，判断min中栈顶元素是否和需要入栈的元素谁小，将小的值入栈min，这样就能保证min的栈顶永远是当前stack中的最小值。

举个栗子：

假设有一组数组要入栈：{12，26，3，25}

首先入栈 12，stack中12压栈，min中为空，所以12为最小值，12压栈。

下一个入栈的是 26，stack中26压栈，min中栈顶为12，比26小，所以12再次压栈。

下一个入栈的是 3，stack中3压栈，min中栈顶为12，比3大，所以3压栈。

下一个入栈的是 25，stack中25压栈，min中栈顶为3，比25小，所以3压栈。

我们发现，不管是哪一步，min中栈顶保存的总是stack中的最小值。

代码实现

• List排序

  import java.util.*;
  
  public class Solution {
      Stack<Integer> stack = new Stack<>();
      List<Integer> minList = new ArrayList<>();
  
      public void push(int node) {
          minList.add(node);
          stack.push(node);
      }
  
      public void pop() {
          minList.remove(stack.pop());
      }
  
      public int top() {
          return stack.peek();
      }
  
      public int min() {
  	    minList.sort(Comparator.comparingInt(a -> a));
          return minList.get(0);
      }
  }
  

• Stack存储

  import java.util.Stack;
  
  public class Solution {
      Stack<Integer> stack = new Stack<>();
      Stack<Integer> min = new Stack<>();
  
      public void push(int node) {
          stack.push(node);
          if (min.empty() || min.peek() > node) {
              min.add(node);
          } else {
              min.add(min.peek());
          }
      }
  
      public void pop() {
          min.pop();
          stack.pop();
      }
  
      public int top() {
          return stack.peek();
      }
  
      public int min() {
          return min.peek();
      }
  }