Queue-队列-bfs遍历

Queue与Stack为两个接口，均需要通过具体的类来实现，可以通过LinkList链表list实现，stack<>()默认使用的是ArrayList<>()数组List实现的，而queue没有默认选择。

题一：树的层序遍历

通过一个队列来一直往里面加东西，然后依次取出。

public ArrayList<Integer> PrintFromTopToBottom(TreeNode root) {
        ArrayList<Integer> result = new ArrayList<Integer>();
        if(root==null){
            return result;
        }
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.offer(root);
        while(!queue.isEmpty()){
            TreeNode out = queue.poll();
            result.add(out.val);
            if(out.left!=null){
                queue.offer(out.left);
            }
            if(out.right!=null){
                queue.offer(out.right);
            }
        }
        return result;
    }

树的后序遍历判断是否为BST

最大值最小值临界法

三、上下界约束法
以下c+程序是看了网上大神的方法；
1.分析：BST的特征是左<根<右（这个特点确定唯一的中序序列），后序遍历的顺序是左右根，基于此，当从后向前遍历后序序列时， 先遍历到根，然后遍历到大于根的结点则向右（并把未向左的结点压入栈中），最后遇到小于根的结点则向左（之后序列中的结点值不能大于此结点）。
2.代码

    bool VerifySquenceOfBST(vector<int> sequence) {
        if (!sequence.size()) return false;
        stack<int> min;
        int max=0x7fffffff;
        min.push(sequence.back());

        for (int i=sequence.size()-1; i>=0; --i){
            if (sequence[i]>max) return false;
            if (min.empty() || sequence[i]>min.top()) min.push(sequence[i]); //向右
            while (!min.empty() && sequence[i]<min.top()) {
                max = min.top();
                min.pop();
            } // 退栈，向左
        }
        return true;
    }
3.复杂度
时间复杂度：O(n)
空间复杂度：O(n)

参考了大神的想法写了以下版本，不明白为什么上程序大神的思想中当当前值sequence[i]<stack.peek()的时候为什么不用把sequence加入进去？这样判断子树的时候不会出现错误么？

import java.util.*;
public class Solution {
    public boolean VerifySquenceOfBST(int [] sequence) {
            if(sequence.length==0){
                return false;
            }
            Stack<Integer> stackmin = new Stack<Integer>();
            int maxLimit = Integer.MAX_VALUE;
            stackmin.push(sequence[sequence.length-1]);
            for(int i = sequence.length-1 ; i >=0 ; i--){
                if(sequence[i] > maxLimit) {
                    return false;
                }else{
                    while (!stackmin.isEmpty()&&sequence[i]<stackmin.peek()){
                        maxLimit = stackmin.peek();
                        stackmin.pop();
                    }
                    stackmin.push(sequence[i]);
                }
            }
            return true;
        }
}