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;

	}

}