leetcode 之Min Stack

Total Accepted: 15967Total Submissions:103378

Design a stack that supports push, pop, top, and retrieving the minimum element in constant time.

• push(x) -- Push element x onto stack.
• pop() -- Removes the element on top of the stack.
• top() -- Get the top element.
• getMin() -- Retrieve the minimum element in the stack.

class MinStack {
    public void push(int x) {
        
    }

    public void pop() {
        
    }

    public int top() {
        
    }

    public int getMin() {
        
    }
}

class Node {
		int number;
		Node next;
		Node pre;

		Node(int x) {
			this.number = x;
		}
	}

	Node head;
	Node tail;
	int size = 0;

	public void push(int x) {
		if (size == 0) {
			head = new Node(x);
			head.pre = null;
			tail = head;
			tail.next = null;
		} else {
			Node node = new Node(x);
			tail.next = node;
			node.pre = tail;
			tail = node;
			tail.next = null;
		}
		size++;
	}

	public void pop() {
		if (tail.pre != null) {
			tail = tail.pre;
		}
		size--;
	}

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

	public int getMin() {
		int Min = 0;
		Node t = head;
		while (t.next != null) {
			Min = Min > t.number ? t.number : Min;
			t = t.next;
		}
		return Min;
	}
}

Time Limit Exceeded

第一次time超时

问题：getMin方法时间复杂度太高，问题点在于找一个最方便于查找最小数的数据结构， 不用说也知道这就是数组了。

当最小数被删除时，它并不一定是处于栈顶的位置，所以虽然说是栈的题。

刚才灵光一闪。我是不是可以不用栈。。

直接用数组。有一个变量用于记录当前下标。就可以实现栈的效果。

但是问题仍然在于如何快速的查找到最小值。

用数组的问题是扩充问题

当下标超出数组初始化的时候要进行扩充。如果有必要我们可以在pop加缩减数组大小。但是这里不是特别需要。

	public void push(int x) {

		if (index + 1 == SIZE) {

			SIZE = SIZE << 1;
			int[] temp = new int[SIZE];
			for (int i = 0; i < index + 1; i++) {
				temp[i] = Number[i];
			}
			Number = temp;
		}
		Number[++index] = x;
		System.out.println(Number[index]);
	}

新方案第一次尝试。

public class MinStack {

	public static void main(String[] args) {
		MinStack min = new MinStack();
		for (int i = -3; i < 100; i++) {
			min.push(i);
		}
		System.out.println(min.getMin());
	}

	int index = 0;
	int SIZE = 10;
	int[] Number = new int[SIZE];

	public void push(int x) {

		if (index + 1 == SIZE) {

			SIZE = SIZE << 1;
			int[] temp = new int[SIZE];
			for (int i = 0; i < index + 1; i++) {
				temp[i] = Number[i];
			}
			Number = temp;
		}
		Number[++index] = x;
		System.out.println(Number[index]);
	}

	public void pop() {
		index--;

	}

	public int top() {

		return Number[index];
	}

	public int getMin() {
		int result = 0;
		for (int i = 0; i < index; i++) {
			System.out.println(Number[i]);
			result = result > Number[i] ? Number[i] : result;

		}
		return result;

	}

}

结果还是超时了。

数组部分也调到了1000的初始值，所以我认为应该是getmin方法造成了。

刚才想到的方案不是去优化排序算法，而是选择性调用 。

有一个值去做最小值缓存，只有在pop最小值的时候才再去找最小值

事实证明成功啦~~

总结一下：主要是因为对栈结构不熟QAQ.然后此算法效率之高也是出乎我的意料。。运算时间小于所有java的代码，都赶上python了。

public class MinStack {

	public static void main(String[] args) {
		MinStack min = new MinStack();
		min.push(2);
		min.push(1);
		min.push(3);
		min.push(0);
		System.out.println(min.getMin());
		min.pop();
		min.pop();
		min.pop();
		System.out.println(min.getMin());
	}

	int index = -1;
	int SIZE = 10;
	int Min = Integer.MAX_VALUE;
	int[] Number = new int[SIZE];

	public void push(int x) {

		if (index + 1 == SIZE) {

			SIZE = SIZE << 1;
			int[] temp = new int[SIZE];
			for (int i = 0; i < index + 1; i++) {
				temp[i] = Number[i];
			}
			Number = temp;
		}
		if (x < Min) {
			Min = x;
		}
		Number[++index] = x;
	}

	public void pop() {
		if (top() == Min) {
			System.out.println("Min" + Number[index]);
			int result = Integer.MAX_VALUE;
			for (int i = 0; i < index; i++) {
				result = result > Number[i] ? Number[i] : result;

			}
			Min = result;
			System.out.println("result" + Min);
		}
		if (index > 0) {
			index--;
		}

	}

	public int top() {
		return Number[index];
	}

	public int getMin() {
		return Min;

	}

}