数据结构与算法---（最小栈)

Posted 2023-02-04 雾晴

最小栈

题目需求：

实现一个这样的栈，这个栈除了可以进行普通的push、pop操作以外，还可以进行getMin的操作，getMin方法被调用后，会返回当前栈的最小值。栈里面存放的都是 int 整数，
力扣题目：实现一个最小栈

暴力版本实现

时间复杂度为O(n)；空间复杂度为O(1)
采用一个指针来指向最小元素下标，每次出栈都要判断出栈元素是否是当前最小，如果是就要去遍历，更新最小指针，

class MinStack 
    int[] nums;
    int minIndex;
    int index;

    /** initialize your data structure here. */
    public MinStack() 
        this.nums=new int[20000];
        this.index=0;
        this.minIndex=-1;
        
    public void push(int x) 
        nums[index]=x;
        index++;
        if(minIndex==-1)
            minIndex=0;
        else if(x<nums[minIndex])
            minIndex=index-1;
        
    
    
    public void pop() 
        index--;
        if(index==minIndex)
            minIndex=0;
            for(int i=0;i<index;i++)
                if(nums[i]<=nums[minIndex])
                    minIndex=i;
                
            
        
        
    
    
    public int top() 
        return nums[index-1];
    
    
    public int min() 
        return nums[minIndex];
    

辅助栈实现

采用一个辅助栈来实现，其时间复杂度为O(1),空间复杂度为O(n)
有两个栈 s1和 s2，s1 是目标栈，s2 是辅助栈，用来存放最小值。

1. 每次 getMin 的时候，直接从 s2 栈顶获取即可
2. 每次入栈，s1直接入栈，s2则需要判断，若当前入栈元素小于s2的栈顶元素，则直接入栈，若当前元素大于等于s2的栈顶元素，则把s2的栈顶元素值，入栈一次。
3. 每次出栈，s1,s2都直接弹出即可
4. 需要注意，若首次入栈，也可以当s2为空栈的时候，直接将当前元素入栈

class MinStack 
    Stack<Integer> s1;
    Stack<Integer> s2;
    /** initialize your data structure here. */
    public MinStack() 
        this.s1=new Stack<Integer>();
        this.s2=new Stack<Integer>();
        
    public void push(int x) 
        s1.push(x);
        if(s2.empty())
            s2.push(x);
        else
            if(x<s2.peek())
            s2.push(x);
            else
                s2.push(s2.peek());
            
        
    
    
    public void pop() 
        s1.pop();
        s2.pop();
    
    
    public int top() 
        return s1.peek();
    
    
    public int min() 
        return s2.peek();
    

使用存差值实现(最优)

public class MinStack 

    private Stack<Integer> stack = new Stack<Integer>();
    private int min;

    public void push(int x) 
        if (stack.isEmpty()) 
            min = x;
            stack.push(0);
         else 
            // 计算差值
            int compare = x - min;
            stack.push(compare);
            // 如果差值小于0，显然 x 成为最小值，否则最小值不变
            min = compare < 0 ? x : min;
        
    

    public void pop() 
        int top = stack.peek();
        // 如果top小于0，显然最小值也一并会被删除，此时更新最小值
		
        min = top < 0 ? (min - top) : min;
        stack.pop();
    

    public int getMin() 
        return min;