LeetCode 腾讯精选50题--最小栈

题目很简单，实现一个最小栈，能够以线形的时间获取栈中元素的最小值

自己的思路如下：

利用数组，以及两个变量， last用于记录栈顶元素的位置，min用于记录栈中元素的最小值；

每一次push，都比较min与x的大小，其次，push操作执行时若数组已满，这需要进行扩容，将数组长度扩大为原来的两倍，并进行数组的迁移。每一次 pop 时，若删除的是最小元素，则遍历数组重新找到最小的元素，然后删除栈顶元素。

时间分析：

push: 最坏情况为O(n),其余为O(1)

pop：最坏情况:O(n)，其余为O(1)

top:O(1)

getMin: O(1)

以下是代码：

private int[] array;
    private int last;
    private int min;
    public MinStack() {
        array = new int[16];
        last=0;
        min = 0;
    }

    public void push(int x) {
        if(last >= array.length){
            this.array = expand(this.array);
        }
        array[last++] = x;
        if(min > x || last==1){
            this.min = x;
        }
    }
    public void pop() {
        if(last -1 <0){
            return;
        }
        if(this.min == array[last-1]){
            this.min = findMin(array,last-1);
        }
        this.last = this.last - 1;
        this.last = this.last < 0 ? 0:this.last;
    }

    public int top() {
        if(last -1 <0){
            return 0;
        }
        int result = this.array[last-1];
        return result;
    }

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

    private int[] expand(int[] array){

        int[] tempArray = new int[array.length*2];
        for (int i=0;i<array.length;i++){
            tempArray[i] = array[i];
        }

        return tempArray;
    }

    private int findMin(int array[],int last){

        if(last <=0){
            return 0;
        }
        int tempMin = array[last-1];
        for (int i=last-1;i>=0;i--){
            tempMin = Math.min(array[i],tempMin);
        }
        return tempMin;

    }

--------------------------------------------------------我是分割线----------------------------------------------------------------------------

好了，经过讨论学习，学会了一种新的解法：

在上面介绍的基础上在添加一个公式：

首先先介绍一下 一个公式：2*x-minEle_1 < x 其中 x是当前插入的值，minEle_1 是x插入前的最小值

详细思路如下：

入栈：

1.使用一个变量minEle 记录当前栈中的元素 （是真实值）

2.每一次插入一个元素x，比较 x 与 minEle，有如下两种情况：

　　1)、若x > = minEle，那么直接push进栈，minEle不变

　　2)、若x < minEle，那么执行以下操作：

　　　　a、首先计算要入栈的虚拟值y：y=2*x - minEle ，y入栈（注意此处y不是真实值，但是可以肯定 y < x 原因：因为x < minEle  故 x-minEle < 0  ; x+一个小于0的值一定小于x）

　　　　b、其次更新minEle 为 x

　　　以上步骤只为保存前一个最小的值。

出栈：

1、出栈前，比较当前出栈的值Y，存在两种情况：

　　1）、若Y > minEle 那么直接出栈

　　2）、若 Y < minEle，那么要执行如下操作：

　　　　　　a、X = 2*minEle - Y ,

　　　　　　b、讲 minEle出栈，同事更新minEle= X

　　　　以上步骤用于还原前一次的最小值

根据此算法可以保证 更新minEle的时间复杂度为O(1),弥补了之前自己想法上的不足，同时又不需要使用另一个辅助栈，节约了空间（虽然空间复杂度都是O(N)，但是O(N) 与 O(2N)还是有差别的）

以下是写的代码：（注意：由于int 最大值为 2147483647 最小值为 -2147483648 ，所以需要针对极限值做一次单独的转换：

入栈：

当 x - Integer.MIN_VALUE < minEle 时：

　　　　int record = last; (此处记录特殊处理的位置，当到此位置时另行处理)

　　　　int reminder = minEle % 10 (保存余数);

　　　　设Y为要存入的值：Y = x/10 *2 - minEle/10 ，然后将Y入栈

出栈：

判断当前位置 last == record:

　　若是 ： minEle = (x/10 *2 - 当前出栈的值)*10 + reminder

判断当前出栈元素是否小于 minEle

　　若是： minEle = (x*2 - 当前出栈的值）

否则直接出栈，无需操作

 package algorithm;
 import java.util.Stack;

 public class MinStack {

     private int[] array;

     private int last;

     private int min;

     private int record;

     private int min_remainder;

     public MinStack() {
         array = new int[16];
         last=0;
         min = 0;
         record=-1;
         min_remainder = -1;
     }

     public void push(int x) {
         if(last >= array.length){
             this.array = expand(this.array);
         }
         if(last==0){
             this.min = x;
             array[last++] = x;
         }else if(this.min > x){
             if(x - (Integer.MIN_VALUE+1) < this.min){
                 array[last++] = createVirtual(x);
             }else {
                 array[last++] = (x<<1) - this.min;
             }
             this.min = x;

         }else {
             array[last++] = x;
         }
     }

     public void pop() {
         if(last -1 <0){
             return;
         }
         if(record == last){
             this.min = (this.min/10 - array[last-1] + this.min/10)*10+min_remainder;
         }else {
             if(array[last-1] < this.min){
                 int temp = this.min<<1 - array[last-1];
                 this.min = temp;
             }
         }
         this.last = this.last - 1;
         this.last = this.last < 0 ? 0:this.last;
     }

     public int top() {
         if(last -1 <0){
             return 0;
         }
         int result = 0;
         if(record == last || array[last-1] < this.min){
             result = this.min;
         }else {
             result = this.array[last-1];
         }
         return result;
     }

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

     private int[] expand(int[] array){
         int[] tempArray = new int[array.length*2];
         for (int i=0;i<array.length;i++){
             tempArray[i] = array[i];
         }
         return tempArray;
     }

     private int createVirtual(int x){
         int temp = 0;
         if(x - (Integer.MIN_VALUE+1) < this.min){
             record = this.last;
             min_remainder = this.min%10;
             temp = x/10 - this.min/10 + x/10;

             return temp;
         }else {
             temp = x << 1 - this.min;
         }

         return temp;
     }

     public static void main(String[] args){
         MinStack min = new MinStack();
         min.push(2147483646);
         min.push(2147483646);
         min.push(2147483647);
         min.top();
         min.pop();
         System.out.println("min:"+min.getMin());
         min.pop();
         System.out.println("min:"+min.getMin());
         min.pop();
         min.push(2147483647);
         min.top();
         min.push(-2147483648);
         System.out.println("top"+min.top());
         System.out.println("min:"+min.getMin());
         min.pop();
         System.out.println("min:"+min.getMin());

     }

 }