判断一棵二叉树是否为搜索二叉树和完全二叉树

/**
 * #[derive(PartialEq, Eq, Debug, Clone)]
 * pub struct TreeNode {
 *     pub val: i32,
 *     pub left: Option<Box<TreeNode>>,
 *     pub right: Option<Box<TreeNode>>,
 * }
 *
 * impl TreeNode {
 *     #[inline]
 *     fn new(val: i32) -> Self {
 *         TreeNode {
 *             val: val,
 *             left: None,
 *             right: None,
 *         }
 *     }
 * }
 */
struct Solution{

}

impl Solution {
    fn new() -> Self {
        Solution{}
    }

    /**
    * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
    *
    * 
        * @param root TreeNode类 the root
        * @return bool布尔型一维数组
    */
    pub fn judgeIt(&self, root: Option<Box<TreeNode>>) -> Vec<bool> {
        if root.is_none() {return vec![true, true]}
        // write code here
        vec![self.isBST(&root).is_some(), self.isCBT(&root)]
    }
    fn isBST(&self, bt: &Option<Box<TreeNode>>) -> Option<(i32, i32)> {
        if bt.is_none() {return None}
        let m = self.getVal(&bt);
        let mut max = m;
        let mut min = m;
        if bt.as_ref().unwrap().left.is_some() {
            let lmax = self.isBST(&bt.as_ref().unwrap().left);
            if lmax.is_none() || lmax.as_ref().unwrap().1 > m {return None}
            min = lmax.unwrap().0
        }
        if bt.as_ref().unwrap().right.is_some() {
            let rmin = self.isBST(&bt.as_ref().unwrap().right);
            if rmin.is_none() || rmin.as_ref().unwrap().0 < m {return None}
            max = rmin.unwrap().1
        }

        Some((min, max))
    }
    fn getVal(&self, node: &Option<Box<TreeNode>>) -> i32 {
        node.as_ref().unwrap().val
    }
    fn isCBT(&self, bt: &Option<Box<TreeNode>>) -> bool {
        let mut level_node_num = 1; //非最底层节点数满足 2^N
        use std::collections::VecDeque;
        let mut q = VecDeque::new();
        q.push_back(bt);
        let mut end = false; //最底下一层结点必须靠左
        //层序遍历
        while q.len() > 0 {
            let _t = q.len();
            if _t == level_node_num {
                for _ in 0 .. _t {
                    let node = q.pop_front().unwrap();
                    if node.as_ref().unwrap().left.is_some() {
                        if end {return false}
                        q.push_back(&node.as_ref().unwrap().left);
                    } else {
                        end = true;
                    }
                    if node.as_ref().unwrap().right.is_some() {
                        if end {return false}
                        q.push_back(&node.as_ref().unwrap().right);
                    } else {
                        end = true;
                    }
                }
                level_node_num *= 2;
            } else {
                // 最底下一层结点不存在左右孩子
                for _ in 0 .. _t {
                    let node = q.pop_front().unwrap();
                    if node.as_ref().unwrap().left.is_some() {
                        return false
                    }
                    if node.as_ref().unwrap().right.is_some() {
                        return false
                    }
                }
            }
        }
        true
    }
}