包含min函数的栈

题目描述

定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O（1））。

package xidian.lili.niuke;

import java.util.Arrays;
import java.util.Stack;

public class MyStack {
	private int size;
	private int min=Integer.MAX_VALUE;
	private Stack<Integer> minStack=new Stack<Integer>();
	private Integer [] elements=new Integer[10];
    public void push(int node) {
        ensureCapacity(size+1);
        elements[size++]=node;
        if(node<=min){
        	minStack.push(node);
        	min=minStack.peek();
        }else{
        	minStack.push(min);
        }
    } 
    private void ensureCapacity(int i) {
    	int len=elements.length;
		if(size>len){
			int newlen=len*3/2+1;
			elements=Arrays.copyOf(elements,newlen);
		}
		
	}
	public void pop() {
		Integer top=top();
        if(top!=null){
        	elements[size-1]=null;
        }
        size--;
        minStack.pop();
        min=minStack.peek();
    }
    
    public int top() {
    	if(!empty()){
    		if(size-1>0){
    			return elements[size-1];
    		}
    	}
        return (Integer) null;
    }
    
    public boolean empty() {
		return size==0;
	}
	public int min() {
        return min;
    }
}

另外定义个栈维护最小元素的栈结构

内部元素用数组来实现

package xidian.lili.niuke;

import java.util.Arrays;
import java.util.Stack;

public class MySatck2 {
	Stack<Integer> datastack=new Stack<Integer>();
	Stack<Integer> minstack=new Stack<Integer>();
    public void push(int node) {
    	datastack.add(node);
    	if(minstack.isEmpty()){
    		minstack.add(node);
    	}else if(node<=minstack.peek()){
    		minstack.add(node);
    	}else{
        	minstack.add(minstack.peek());
        }
    } 
	public void pop() {
		datastack.pop();
		minstack.pop();
    }
    
    public int top() {
    	return datastack.peek();
    }

	public int min() {
		return minstack.peek();
	}
}

是stack的函数实现，维护一和minstack的栈结构