数据结构与算法之队列与栈训练营

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/boker_han/article/details/83831870

1.用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。

	public class QueueImplementedByStack {
	    Stack<Integer> stack1 = new Stack<Integer>();
	    Stack<Integer> stack2 = new Stack<Integer>();
	    //固定使用stack1作为push操作的目标容器
	    public void push(int node) {
	        stack1.push(node);
	    }
	    //固定使用stack2作为pop操作的目标容器
	    public int pop() {
	        if(stack2.isEmpty()){
	            while(stack1.size() != 0){
	                stack2.push(stack1.pop());
	            }
	        }
	        if(stack2.size() != 0){
	            return stack2.pop();
	        }
	        return -99999999;
	    }
	}

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

	public class StackWIthMinStack{
	    Stack<Integer> stack = new Stack<>();
	    Stack<Integer> min = new Stack<>();
	    public void push(int node) {
	        //判断压入最小栈的值
	        if(stack.size() == 0){
	            min.push(node);
	        }else{
	            Integer top = min.peek();
	            if(top <= node){
	                min.push(top);
	            }else{
	                min.push(node);
	            }
	        }
	        //压入数据栈
	        stack.push(node);
	    }
	    public void pop() {
	        //弹出数据
	        stack.pop();
	        //弹出当前最小元素，保持最小栈的栈顶元素是弹出元素之后的最小元素
	        min.pop();
	    }
	    public int top() {
	        return stack.peek();
	    }
	    public int min() {
	        return min.peek();
	    }
	}

3. 输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否可能为该栈的弹出顺序。假设压入栈的所有数字均不相等

	 public boolean IsPopOrder(int [] pushA,int [] popA) {
	        if(pushA == null || popA == null || popA.length <= 0 || pushA.length != pushA.length)
	            return false;
	        int len = popA.length;
	        int index = 0;
	        Stack<Integer> stack = new Stack<>();
	        for(int i = 0 ; i < len ; i++){
	            //栈中有元素
	            if(stack.size() != 0){
	                //栈顶元素不等于当前待弹出元素
	                if(stack.peek() != popA[i]){
	                    //循环判断压入数组中元素是否等于待弹出元素
	                    while(index < len && pushA[index] != popA[i]){
	                        stack.push(pushA[index]);
	                        index++;
	                    }
	                    //压入数组中没有待弹出元素，不匹配
	                    if(index == len){
	                        return false;
	                    }
	                    index++;
	                }else{
	                    //栈顶元素等于当前待弹出元素，弹出栈顶元素
	                    stack.pop();
	                }
	             }else{
	                //栈中无元素
	                //循环判断压入数组中元素是否等于待弹出元素
	                while(index < len && pushA[index] != popA[i]){
	                    stack.push(pushA[index]);
	                    index++;
	                }
	                //压入数组中没有待弹出元素，不匹配
	                    if(index == len){
	                        return false;
	                    }
	                    index++;
	            }
	        }
	        if(index < len)
	            return false;
	        return true;
	    }