编程题－算法－中等－牛客网－NC60 判断一个树是否是搜索二叉树和完全二叉树

1、题目：判断一个树是否是搜索二叉树和完全二叉树

2、编程解答

１）什么是搜索二叉树？

因为左子树的节点全部小于父节点，所以按照中序遍历的话，如果是搜索二叉树的话，一定是升序的。

可以采用深度优先遍历，使用stack栈结构来解决。下面使用了３种方式来解答：递归＋列表、递归、非递归，由浅入深比较好理解。

２）什么是完全二叉树？
如果二叉树中除去最后一层节点为满二叉树，且最后一层的结点依次从左到右分布，则此二叉树被称为完全二叉树。

因此可以采用广度优先遍历，使用queue队列结构来解决。
１）如果左子树为空，而右子树不为空，那么肯定不是完全二叉树；
２）如果右子树为空，那么说明后面的节点都应该是叶子节点。此时需要将leafFlag设置为true，当leafFlag为true，之后的每一个节点如果还有子节点，那么就不是完全二叉树。

2.1 方式一：搜索（递归+列表）、完全（非递归）

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 * }
 */

public class Solution {
    /**
     * 
     * @param root TreeNode类 the root
     * @return bool布尔型一维数组
     */
    public boolean[] judgeIt (TreeNode root) {
        // write code here
        if (root==null) {
            return new boolean[]{true, true};
        }
        
        // 判断是否是搜索二叉树
        boolean searchTree = true;
        // 方法一：中序遍历递归＋列表
        ArrayList<Integer> list = new ArrayList<>();
        midSearch(root, list);
        // 如果是搜索二叉数的话，那么中序遍历的结果应该是递增的
        int pre = Integer.MIN_VALUE;
        for (Integer i:list) {
            if (i<=pre) {
                searchTree = false;
                break;
            }
            pre = i;
        }
        
        // 判断是否是完全二叉树
        boolean fullTree = isCompleteTree(root);
        
        return new boolean[]{searchTree, fullTree};
    }
    
    // 中序遍历二叉树
    public void midSearch(TreeNode root, ArrayList<Integer> list) {
        if (root==null) {
            return;
        }
        midSearch(root.left, list);
        list.add(root.val);
        midSearch(root.right, list);
    }
    
    // 判断是否是完全二叉树，可以使用层序遍历+叶子节点标志（leafFlag）
    // １）如果左子树为空，而右子树不为空，那么肯定不是完全二叉树；
    // ２）如果右子树为空，那么说明后面的节点都应该是叶子节点，此时需要将leafFlag设置为true;
    public boolean isCompleteTree(TreeNode root) {
        if (root == null) {
            return true;
        }
        Deque<TreeNode> queue = new ArrayDeque<>();
        queue.add(root);
        boolean leafFlag = false;
        while (!queue.isEmpty()) {
            int num = queue.size();
            for (int i=0; i<num; i++) {
                TreeNode cur = queue.pollFirst();
                // 当叶子节点变为true了，当出现该节点非叶子节点的话，那么就不是完全二叉树
                if (leafFlag && (cur.left!=null || cur.right!=null)) {
                    return false;
                }
                // 当左子树为空，而右子树不为空，那么肯定不是完全二叉树
                if (cur.left==null && cur.right!=null) {
                    return false;
                } else if (cur.right==null) {
                    leafFlag = true;
                }
                if (cur.left!=null) queue.addLast(cur.left);
                if (cur.right!=null) queue.addLast(cur.right);
            }
        }
        return true;
    }
}

2.2 方式二：搜索（递归）、完全（非递归）

方式二相比于方式一，将判断搜索二叉树的方式中，去掉了list的辅助，直接在中序遍历的递归中进行判断。

import java.util.*;

public class Solution {
    public static int pre = Integer.MIN_VALUE;
    
    public boolean[] judgeIt (TreeNode root) {
        // write code here
        if (root==null) {
            return new boolean[]{true, true};
        }
        
        // 判断是否是搜索二叉树
        // 方法二：中序遍历递归中直接处理，不再借助列表了
        boolean searchTree = isSeachTreeByMidSearch(root);
        
        // 判断是否是完全二叉树
        boolean fullTree = isCompleteTree(root);
        
        return new boolean[]{searchTree, fullTree};
    }
    
    // 中序遍历递归中直接处理，不再借助列表了
    public boolean isSeachTreeByMidSearch(TreeNode root) {
        if (root==null) {
            return true;
        }
        // 如果左子树不是搜索二叉树，直接返回
        boolean isLeftSt = isSeachTreeByMidSearch(root.left);
        if (!isLeftSt) {
            return false;
        }
        // 当前节点值如果比之前小，那么就不是二叉树
        if (root.val<=pre) {
            return false;
        } else {
            pre = root.val;
        }
        return isSeachTreeByMidSearch(root.right);
    }
    
    // 判断是否是完全二叉树，可以使用层序遍历+叶子节点标志（leafFlag）
    // １）如果左子树为空，而右子树不为空，那么肯定不是完全二叉树；
    // ２）如果右子树为空，那么说明后面的节点都应该是叶子节点，此时需要将leafFlag设置为true;
    public boolean isCompleteTree(TreeNode root) {
        // 与方式一代码一致，此处省略。
        return true;
    }
}

2.3 方式三：搜索（非递归）、完全（非递归）

方式三采用了非递归。

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 * }
 */

public class Solution {
    /**
     * 
     * @param root TreeNode类 the root
     * @return bool布尔型一维数组
     */
    public static int pre = Integer.MIN_VALUE;
    
    public boolean[] judgeIt (TreeNode root) {
        // write code here
        if (root==null) {
            return new boolean[]{true, true};
        }
        
        // 判断是否是搜索二叉树
        // 方法三：非递归（使用栈结构深度遍历）
        boolean searchTree = isSeachTreeByStack(root);
        
        // 判断是否是完全二叉树
        boolean fullTree = isCompleteTree(root);
        
        return new boolean[]{searchTree, fullTree};
    }
    
    // 非递归（使用栈结构深度遍历）
    public boolean isSeachTreeByStack(TreeNode root) {
        if (root ==null) {
            return true;
        }
        Stack<TreeNode> stack = new Stack<>();
        Integer pre = Integer.MIN_VALUE;
        while (!stack.isEmpty() || root!=null) {
            // 把当前节点的左节点压入栈
            if (root!=null) {
                stack.push(root);
                root = root.left;
            } else {
                // 所有左节点压入栈后，弹出栈顶节点
                root = stack.pop();
                if (root.val<=pre) {
                    return false;
                } else {
                    pre = root.val;
                }
                // 然后将弹出栈顶节点的右子树循环以上步骤
                root = root.right;
            }
        }
        return true;
    }
    
    // 判断是否是完全二叉树，可以使用层序遍历+叶子节点标志（leafFlag）
    // １）如果左子树为空，而右子树不为空，那么肯定不是完全二叉树；
    // ２）如果右子树为空，那么说明后面的节点都应该是叶子节点，此时需要将leafFlag设置为true;
    public boolean isCompleteTree(TreeNode root) {
        // 与方式一代码一致，此处省略。
        return true;
    }
}