程序员代码面试指南刷题--第三章.判断一棵二叉树是否为搜索二叉树和完全二叉树

题目描述
给定一棵二叉树，已经其中没有重复值的节点，请判断该二叉树是否为搜索二叉树和完全二叉树。
输入描述:

第一行输入两个整数 n 和 root，n 表示二叉树的总节点个数，root 表示二叉树的根节点。

以下 n 行每行三个整数 fa，lch，rch，表示 fa 的左儿子为 lch，右儿子为 rch。(如果 lch 为 0 则表示 fa 没有左儿子，rch同理)

ps:节点的标号就是节点的值

输出描述:

第一行输出该二叉树是否为搜索二叉树的答案，如果是则输出 “true”，否则输出 “false”。

第二行输出该二叉树是否为完全二叉树的答案，如果是则输出 “true”，否则输出 “false”。

示例1

输入

3 2
2 1 3
1 0 0
3 0 0

输出

true
true

解法一：递归和层序遍历

import java.io.*;
import java.util.*;
public class Main{
    public static void main(String[] args) throws Exception{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        br.readLine();
        TreeNode root = createTree(br);
        boolean res1 = isBalanced(root);
        boolean res2 = isPerfect(root);
        System.out.println(res1);
        System.out.println(res2);
    }
    public static boolean isBalanced(TreeNode root){
        if(root==null) return true;
        boolean left = isBalanced(root.left);
        if(left==false) return false;
        boolean right = isBalanced(root.right);
        if(right==false) return false;
        TreeNode l = root.left;
        if(l!=null){
            while(l.right!=null){
                l = l.right;
            }
            if(l.val>root.val) return false;
        }
        TreeNode r = root.right;
        if(r!=null){
            while(r.left!=null){
                r = r.left;
            }
            if(r.val<root.val) return false;
        }
        return true;
    }
    public static boolean isPerfect(TreeNode root){
        if(root==null) return false;
        Queue<TreeNode> q = new LinkedList<>();
        //借助层序遍历判断
        q.offer(root);
        int presize = 1;
        int size = 0;
        boolean flag = false;
        while(!q.isEmpty()){
            while(presize-->0){
                TreeNode node = q.poll();
                if(node.left!=null){
                    if(flag==true) return false;
                    q.offer(node.left);
                    size++;
                }else{
                    flag = true;
                }
                if(node.right!=null){
                    if(flag==true) return false;
                    q.offer(node.right);
                    size++;
                }else{
                    flag = true;
                }
            }
            presize = size;
            size = 0;
            flag = false;
        }
        return true;
    }
    //递归建树
    public static TreeNode createTree(BufferedReader br){
        try{
            String[] ss = br.readLine().trim().split(" ");
            int data = Integer.parseInt(ss[0]);
            int left = Integer.parseInt(ss[1]);
            int right = Integer.parseInt(ss[2]);
            TreeNode root = new TreeNode(data);
            if(left!=0){
                root.left = createTree(br);
            }
            if(right!=0){
                root.right = createTree(br);
            }
            return root;
        }catch(Exception e){
            return null;
        }
    }
}
class TreeNode{
    int val;
    TreeNode left;
    TreeNode right;
    public TreeNode(int val){
        this.val = val;
    }
}