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;

	}

}













评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值