最小栈

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

实现 MinStack 类:

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

提示：

-231 <= val <= 231 - 1
pop、top 和 getMin 操作总是在非空栈上调用
push, pop, top, and getMin最多被调用 3 * 104 次

解答一

用一个栈同时保持入栈的值和当前栈的最新值

ts 复制代码

class MinStack {
    private data: {val: number;min:number}[] = []
    constructor() {
        
    }

    push(val: number): void {
        
        if (this.data.length === 0) {
            this.data.push({
                val,min:val
            })
        } else {
            const top = this.data[this.data.length-1]
            this.data.push({
                val,
                min: Math.min(val,top.min)
            })
        }
        
    }

    pop(): void {
        this.data.pop()
    }

    top(): number {
        return this.data[this.data.length-1].val
    }

    getMin(): number {
        return this.data[this.data.length-1].min
    }
}

解答二

用一个链表，链表中的每个节点保存到当前位置最小的值。

ts 复制代码

interface ValNode {
    val: number;
    min: number;
    next: ValNode | null
}

class MinStack {
    private head: ValNode | null = null
    constructor() {
        
    }

    push(val: number): void {
        if (this.head) {
            const prevHead = this.head
            this.head = {
                val,
                min: Math.min(prevHead.min,val),
                next:prevHead
            }
        } else {
            this.head = {
                val,
                min:val,
                next: null
            }
        }
    }

    pop(): void {
        if(this.head) {
            this.head = this.head.next
        }
    }

    top(): number {
        return this.head.val
    }

    getMin(): number {
        return this.head.min
    }
}

解答三

用单独的变量 min 表示栈在目前位置的最小值，维护一个 diff 栈，其中保存入栈的值与 min 的差值。

ts 复制代码

class MinStack {
    private diff: number[] = []
    private min: number | undefined
    constructor() {
        
    }

    push(val: number): void {
        if(this.diff.length === 0) {
            this.min = val
            this.diff.push(0)
        } else {
            const diff = val - this.min
            this.diff.push(diff)
            // 入栈的值更小了
            if (diff < 0) {
                this.min = val
            } 
        }
    }

    pop(): void {
        const diff = this.diff.pop()
        if(diff < 0) {
            this.min = this.min - diff
        }
    }

    top(): number {
        const diff = this.diff[this.diff.length-1]
        if(diff < 0) {
            return this.min
        } else {
            return diff + this.min
        }
    }

    getMin(): number {
        return this.min
    }
}