二叉树 — 判断是否是完全二叉树

完全二叉树的数据结构特点在堆的篇章中提到过，这里不进行过多赘述。堆结构

采用队列方式

1. 如果节点的左侧没有节点但是右侧有节点，毫无疑问，不是完全二叉树。
2. 如果遍历过程中，遇到左右子节点有为null的情况，则进行标记，之后的遍历再次碰到左右子节点任意一个不为null的情况，那必然不是完全二叉树。

代码

 public static boolean isCBT(Node head) {
        //边界条件：先默认空树是一个完全二叉树
        if (head == null) {
            return true;
        }

        Queue<Node> heap = new LinkedList<>();
        heap.add(head);
        //标记位
        boolean leaf = false;

        while (!heap.isEmpty()) {
            Node cur = heap.poll();
			//如果之前已经遇到过左右子节点为null的情况，但是cur.left cur.right不为null，则必然不是完全二叉树
            if ((leaf && (cur.left != null || cur.right != null)) ||
                    (cur.left == null && cur.right != null)) {
                return false;
            }
            if (cur.left != null) {
                heap.add(cur.left);
            }
            if (cur.right != null) {
                heap.add(cur.right);
            }

            if (cur.left == null || cur.right == null) {
                leaf = true;
            }
        }
        return true;
    }

递归方式

1. 需要类来进行辅助判断该二叉树是否是完全二叉树
2. 采用递归的方式收集左右子节点信息（如果要左右子节点信息不同，则将子节点信息进行融合）
3. 每一棵子树，都需要判断是否是满二叉树，完全二叉树，以及需要收集树的高度

public static class IsCTBInfo{
        boolean isFull;
        boolean isCTB;
        int height;

        public IsCTBInfo(boolean isFull,boolean isCTB,int height){
            this.height = height;
            this.isCTB = isCTB;
            this.isFull = isFull;
        }
    }

public static boolean isCTB2(Node head){
        if (head == null){
            return true;
        }
        return process(head).isCTB;
    }

    public static IsCTBInfo process(Node head){
    	//如果对象方便进行创建，则创建对象并return，如果不方便，不知道传什么值，则return null，在下面进行判断
        if (head == null){
            return new IsCTBInfo(true,true,0);
        }
		
		//递归方式，我每一个节点都返回IsCTBInfo的信息
        IsCTBInfo leftInfo = process(head.left);
        IsCTBInfo rightInfo = process(head.right);

		//构建我自己节点的IsCTBInfo信息
		
        //只有我左右两侧都是满二叉树，并且我左右两侧树的高度相同，那么我整棵树才是满二叉树。
        boolean isFull = leftInfo.isFull && rightInfo.isFull && leftInfo.height == rightInfo.height? true :false;
        boolean isCTB = false;
        int height = Math.max(leftInfo.height,rightInfo.height) + 1;

        //如果我整棵树是满二叉树，那当然也是一颗完全二叉树
        if (isFull){
            isCTB = true;
        }else{
            //不满，但是是完全二叉树
            if (leftInfo.isCTB && rightInfo.isCTB){
           		//如果左树是满二叉树，但右侧不满，那左右高度必须相等，整棵树才是一颗完全二叉树
                if (leftInfo.isFull && rightInfo.isCTB && leftInfo.height == rightInfo.height) {
                    isCTB = true;
                }
				//如果左侧不满右侧满，那右侧高度 + 1 必须和左树相等，整棵树才是一颗完全二叉树
                if (leftInfo.isCTB && rightInfo.isFull && leftInfo.height == rightInfo.height +1){
                    isCTB = true;
                }
				//如果左右都满，那右侧高度 + 1必须和左树相等， 整棵树才是一颗完全二叉树
                if (leftInfo.isFull && rightInfo.isFull && leftInfo.height == rightInfo.height + 1){
                    isCTB = true;
                }
            }
        }
        //构建好我当前节点信息
        return new IsCTBInfo(isFull,isCTB,height);
    }

对数器
随机生成二叉树

  public static Node generateRandomNode(int maxLength, int maxValue) {
        return generateNode(1, maxLength, maxValue);
    }

    public static Node generateNode(int level, int maxLength, int maxValue) {
        if (level > maxLength || Math.random() < 0.5) {
            return null;
        }
        Node head = new Node((int) (Math.random() * maxValue));
        head.left = generateNode(level + 1, maxLength, maxValue);
        head.right = generateNode(level + 1, maxLength, maxValue);
        return head;
    }

测试
大数据样本进行测试，如果结果不相同，则说明出现了问题

 public static void main(String[] args) {
        int maxValue = 1000;
        int maxLength = 300;
        int testNum = 100000;
        for (int i = 0; i < testNum; i++) {
            Node head = generateRandomNode(maxLength, maxValue);
            if (isCBT1(head) !=  isCBT2(head)) {
                System.out.println("Fucking Fuck");
                break;
            }
        }
        System.out.println("finish");
    }