【剑指offer】包含min函数的栈 *栈的压入、弹出序列 *从上到下打印二叉树 *二叉搜索树的后序遍历序列

定义栈的数据结构，请在该类型中实现一个能够得到栈最小元素的min函数。

import java.util.Stack;

public class Solution {

  	Stack<Integer> stack = new Stack<Integer>();
	Stack<Integer>smin=new Stack<Integer>();//存最小值

	//入栈
	public void push(int node) {
		int min=0;
		stack.push(node);
		if(smin.empty()){
			smin.push(node);
		}else{
			min=min();			
			if(min>node){
				//新的最小值
				smin.push(node);
			}else{
				smin.push(min);
			}
		}
	}

	//出栈
	public void pop() {
		if(!stack.empty()&&!smin.empty()){
			stack.pop();
			smin.pop();
		}
	}

	public int top() {
		return stack.peek();
		//peek和pop相同点：大家都返回栈顶的值。
        //不同点：peek 不改变栈的值(不删除栈顶的值)，pop会把栈顶的值删除。
	}

	//返回最小元素
	public int min() {
		int min = 0;
		if(!smin.empty()){
			min=smin.peek();
		}
		return min;
	}
}

输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列4，5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。（注意：这两个序列的长度是相等的）

import java.util.ArrayList;
import java.util.Stack;

public class Solution {
    public boolean IsPopOrder(int[] pushA, int[] popA) {
		boolean flag=false;
		if(pushA.length==0||popA.length==0){
			return false;
		}
		//标记弹出序列的位置
		int popindex=0;
		Stack<Integer> s=new Stack<Integer>();
        for(int i=0;i<pushA.length;i++){
        	s.push(pushA[i]);
        	//栈顶元素等于弹出序列
        	while(!s.isEmpty()&&s.peek()==popA[popindex]){
        		s.pop();
        		popindex++;
        	}
        }
        if(s.empty()){
        	flag=true;
        }
		return flag;
	}
}

从上往下打印出二叉树的每个节点，同层节点从左至右打印。

deque 即双端队列，pop取开头的元素

import java.util.Deque;
import java.util.ArrayList;
import java.util.LinkedList;
/**
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}
*/
public class Solution {
   public  ArrayList<Integer> PrintFromTopToBottom(TreeNode root) {
		ArrayList<Integer> list = new ArrayList<Integer>();
		//deque 即双端队列。是一种具有队列和栈的性质的数据结构。
		//双端队列中的元素可以从两端弹出，其限定插入和删除操作在表的两端进行。
       //模拟链表的先进先出
		Deque<TreeNode>deque=new LinkedList<TreeNode>();
		if(root==null){
			return list;
		}
		deque.add(root);
		while(!deque.isEmpty()){
			TreeNode t=deque.pop();
			list.add(t.val);
			if(t.left!=null)
				deque.add(t.left);
			if(t.right!=null)
				deque.add(t.right);
		}
		return list;
	}

}

输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。

public class Solution {
   // 判断数组是不是二叉树后序遍历的结果
	// 二叉搜索树的特点:左叶子<根<右叶子
	public boolean VerifySquenceOfBST(int[] sequence) {
		if (sequence.length == 0) {
			return false;
		} else {
			return VerifySquence(sequence, 0, sequence.length - 1);
		}
	}

	public boolean VerifySquence(int[] sequence, int start, int end) {
		if(end <= start) return true;
        int i = start;
        //sequence[end]是根
        //左子树
        for (; i < end; i++) {
            if(sequence[i] > sequence[end]) break;
        }
        //右子树有小于根的就是错误的
        for (int j = i; j < end; j++) {
            if(sequence[j] < sequence[end]) return false;
        }
        return VerifySquence(sequence, start, i-1) && VerifySquence(sequence, i, end-1);
	}


}