Java vérifie si un arbre est un arbre binaire complet

Arbre binaire complet

　　Si la profondeur de l'arbre binaire est k, le nombre de nœuds dans les autres couches (1 ～ k-1) a atteint le maximum sauf pour la kème couche, et tous les nœuds de la kème couche sont continuellement concentrés sur le côté gauche , qui est un arbre binaire complet.

 

 

Déterminez si l'arbre binaire est un arbre binaire complet. La définition d'un arbre binaire complet est que les n-1 premiers niveaux sont pleins, et s'il y a une vacance dans le nième niveau, il manque à droite, c'est-à-dire le nœud le plus à droite du nième niveau, et sa gauche le côté est plein et le côté droit est vide.

En prenant un arbre binaire à 3 niveaux comme exemple, la situation suivante est un arbre binaire complet:

 

Nous pouvons poser la question en fonction de la signification de la question. Nous pouvons utiliser la méthode de traversée hiérarchique. Lors du jugement d'un nœud spécifique, nous pouvons avoir la base de jugement suivante:
(1). Si le sous-arbre gauche de ce nœud est nul, si le bon sous-arbre n'est pas nul, il ne doit pas être un arbre binaire complet.
(2) . Si les sous-arbres gauche et droit de ce nœud sont tous nuls (il n'est pas nécessaire de déterminer si la couche actuelle ou la couche suivante ne peut plus contenir de nœuds contenant des sous-arbres gauche et droit) , ou le sous-arbre gauche de ce nœud n'est pas nul mais le sous-arbre droit est nul, les nœuds contenant des sous-arbres gauche et droit ne peuvent plus apparaître dans la couche courante ou la couche suivante.
(3). Si les sous-arbres gauche et droit du nœud courant ne sont pas nuls, observez le nœud suivant.

public boolean isCompleteTree(TreeNode root){
        
        if(root == null){
            return false;
        }
        
        // 1. 先对树进行层序遍历
        // 如果这个标记为 false, 说明还是处在第一阶段
        // 如果这个标记为 true , 接下来的节点就不能有子树
        // 也就是第二阶段开始了
        int flg = 1;//第一阶段:1 第二阶段:2
        
        LinkedList<TreeNode> queue = new LinkedList();
        
        queue.add(root);
        
        while(!queue.isEmpty()){
            TreeNode temp = queue.poll();
            
            if(flg == 1){
                
                // 合格的状态, 继续往下遍历.
                // 就把左右子树加入队列就行了
                if(temp.left != null && temp.right != null){
                    queue.offer(temp.left);
                    queue.offer(temp.right);
                }else if(temp.left == null && temp.right != null){
                    // 这种情况铁定不是完全二叉树
                    return false;
                }else if(temp.left != null && temp.right == null){
                    // 这是临界状态, 开启第二阶段
                    queue.offer(temp.left);
                    //开启第二阶段
                    flg = 2;
                }else{
                    // 左右子树都为空, 开启第二阶段
                    flg = 2;
                }
            }else{
                //开启第二阶段
                // 第二阶段要求节点必须没有子树. 只要子树存在, 就不是完全二叉树
                if(temp.left != null || temp.right != null){
                    return false;
                }
            }
        }
        
        return true;
    }

. Si les sous-arbres gauche et droit de ce nœud sont nuls (cela n'a pas besoin de déterminer la couche courante ou la couche inférieure ne peut pas être un nœud de sous-arbre gauche contenant un présent) libellé:

C'est plus facile à comprendre: 

import java.util.*;

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

public class Solution {
    
    //是否是儿茶搜索树
    boolean isTwoSearchFlg = true;
    
    /**
     * 
     * @param root TreeNode类 the root
     * @return bool布尔型一维数组
     */
    public boolean[] judgeIt (TreeNode root) {
        boolean[] result = new boolean[2];
        istwoSearchTree(root);
        result[0] = isTwoSearchFlg;
        
        result[1] = isFullTree(root);
        
        return result;
    }
    
    int preTreeNodeVal = Integer.MIN_VALUE;
    public void istwoSearchTree(TreeNode root){
       
        if(root == null || !isTwoSearchFlg){
            return;
        }
        
        istwoSearchTree(root.left);
        if(root.val > preTreeNodeVal){
            preTreeNodeVal = root.val;
        }else{
            isTwoSearchFlg = false;
            return;
        }
        istwoSearchTree(root.right);
    }
    
    
    
    public boolean isFullTree(TreeNode root){
        
        if(root == null){
            return false;
        }
        
        int condition = 1;
        
        LinkedList<TreeNode> queue = new LinkedList();
        queue.offer(root);
            
        while(!queue.isEmpty()){
            TreeNode temp = queue.poll();
            
            if(1 == condition){
                if(temp.left!=null && temp.right!=null){
                    queue.offer(temp.left);
                    queue.offer(temp.right);
                }else if(temp.left == null && temp.right != null){
                    return false;
                }else if(temp.left!=null && temp.right == null){
                    condition = 2;
                    queue.offer(temp.left);
                }
            }else{
                if(temp.left!=null || temp.right != null){
                    return false;
                }
            }
        }
        
        return true;
    }
}