Quelques exercices sur les arbres binaires

La troisième partie de l'arbre binaire

Cette partie - Oui. À propos de Arbre binaire De Exercices

Même arbre

Joindre le Code

class Solution {
    
    public boolean isSameTree(TreeNode p, TreeNode q) {
    
       if(p!= null && q == null || p == null && q != null) {
    
            return false;
        }
        
        if(p == null && q == null ) {
    
            return true;
        }
        if(p.val != q.val) {
    
            return false;
        }
        
       return isSameTree(p.left,q.left) && isSameTree(p.right,q.right);
    }
}

Complexité temporelle

Il y a un Problèmes mineurs Voilà. Fonctions La complexité temporelle de Pour Combien?

Ici, nous allons tous traverser les noeuds de deux arbres ,Ici. J'ai besoin de voir.pEt q Nombre de noeuds par arbre

S'il vous plaît. p De NoeudM Et q De Arbre nodalN Minimum de

0(min(M,N))

Après avoir vu le même Les arbres, alors Viens voir. Un sujet similaire

Un enfant d'un autre arbre

Joindre le Code

class Solution {
    
    private boolean isSamTree(TreeNode p,TreeNode q) {
    
        if(p == null && q != null || p != null && q == null) {
    
            return false;
        }
        if(p == null && q == null) {
    
            return true;
        }
        if(p.val != q.val) {
    
            return false;
        }
        return isSamTree(p.left,q.left) && isSamTree(p.right,q.right);
    }
    public boolean isSubtree(TreeNode root, TreeNode subRoot) {
    
        if(root == null || subRoot == null) {
    
            return false;
        }
        //  Noeud racinaire et  subrootDeux arbres identiques
        if(isSamTree(root,subRoot)) {
    
            return true;
        }
        //subRoot C'est ça? root Sous - arbre gauche de
        if(isSubtree(root.left,subRoot)) {
    
            return true;
        }
        if(isSubtree(root.right,subRoot)) {
    
            return true;
        }
        return false;
        
    }
}

Complexité temporelle

Ici. Besoin root Chaque noeud de Avec subRoot Comparaison Alors... Si root Oui. S Noeuds subRoot Oui. T Noeuds,Chaque SIl faut y aller T Comparaison

Donc la complexité temporelle C'est tout.0(S * N)

Arbre binaire équilibré

Joindre le Code

class Solution {
    
       public int height(TreeNode root) {
    
        if(root == null) {
    
            return 0;
        }
        int leftHeight = height(root.left);
        int rightHeight = height(root.right);
        return Math.max((leftHeight+1),(rightHeight+1));
    }
    //  Déterminer si un arbre est  Arbre binaire équilibré
    public boolean isBalanced(TreeNode root) {
    
        if(root == null) {
    
            return true;
        }
        int left = height(root.left);
        int right = height(root.right);
        return    Math.abs(left - right) <= 1 && isBalanced(root.left) && isBalanced(root.right);
    }
}

Après optimisation

class Solution {
    
       public int height(TreeNode root) {
    
        if(root == null) {
    
            return 0;
        }
        int leftHeight = height(root.left);
        int rightHeight = height(root.right);
        if(leftHeight >=0 && rightHeight >=0 && Math.abs(leftHeight - rightHeight) <=1) {
    
            return Math.max(leftHeight,rightHeight) + 1;
        }else {
    
            return -1;
        }
    }
    public boolean isBalanced(TreeNode root) {
    
        if(root == null) {
    
            return true;
        }
        return height(root) >=0;
    }
}

Arbre binaire symétrique

Joindre le Code

class Solution {
    
    //Créer une méthode,Pour jugerrootDe l'arbre gauche et  Droite 
    public boolean isSymmetricChild(TreeNode leftTree,TreeNode rightTree) {
    
        if(leftTree == null && rightTree != null || leftTree != null && rightTree == null) {
    
            return false;
        }
        if(leftTree == null &&rightTree == null) {
    
            return true;
        }
        if(leftTree.val == rightTree.val) {
    
            return isSymmetricChild(leftTree.left,rightTree.right) &&isSymmetricChild(leftTree.right,rightTree.left);
        }
        return false;
    }
    public boolean isSymmetric(TreeNode root) {
    
      if(root == null) return true;
      return isSymmetricChild(root.left,root.right);
    }
}

Créer un arbre binaire

Rappelez - vous ci - dessus si nous avons créé un arbre binaire Adoption Pauvre. Pour créer un arbre binaire ,Alors Maintenant, nous allons créer un arbre binaire en utilisant la première traversée de séquence

Arbre binaire traversant

Joindre le Code

import java.util.Scanner;
import java.util.*;
class TreeNode{
    
    public char val;
    public TreeNode left;
    public TreeNode right;
    public TreeNode(char val) {
    
        this.val = val;
    }
}
public class Main{
    
    
    public static int i= 0;
    public static TreeNode createTree(String str) {
    
        
        TreeNode root = null;
        if(str.charAt(i) != '#') {
    
            root = new TreeNode(str.charAt(i));
            i++;
            root.left = createTree(str);
            root.right = createTree(str);
        }else {
    
            i++;
        }
        return root;
    }
    public static void inorter(TreeNode root){
    
        if(root == null) {
    
            return;
        }
        inorter(root.left);
        System.out.print(root.val+" ");
        inorter(root.right);
    }
    public static void main(String[] args) {
    
        Scanner sc = new Scanner(System.in);
        // Il faut faire attention ici.hasNext Avec hasNextLine La différence entre
        // hasNextLine L'espace rencontré ne se termine pas
        // hasNext Fin de l'espace rencontré
        while(sc.hasNextLine()) {
    
            String str = sc.nextLine();
            TreeNode root = createTree(str);
            inorter(root);
        }
   

​ Enfin, pour compléter la procédure précédente Traversée ,Rappelle - toi Ci - dessus Écris. De Juger un arbre binaire complet

En fait, la traversée du programme est aussi Cette idée Adoption Une file d'attente,Vide Juste - Non. Rejoindre la file d'attente,

Traversée du programme

 // Traversée du programme
    public void levelOrder(TreeNode root) {
    
        if(root == null) {
    
            return;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()) {
    
            TreeNode tmp = queue.poll();
            System.out.print(tmp.val+ " ");
            if(tmp.left!= null) {
    
                queue.offer(tmp.left);
            }
            if(tmp.right != null) {
    
                queue.offer(tmp.right);
            }
        }
    }

Écris. C'est fini. Le programme passe à travers, alors on va Boucle de force Écris ça oj Question hehe hehe

Traversée séquentielle de l'arbre binaire

class Solution {
    
     public List<List<Integer>> levelOrder(TreeNode root) {
    
        List<List<Integer>> list = new ArrayList<>();
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        if(root == null) return list;
        while(!queue.isEmpty()) {
    
           int size = queue.size();
            List<Integer> list2 = new ArrayList<>();
            while(size != 0) {
    
                TreeNode tmp = queue.poll();
                list2.add(tmp.val);
                if(tmp.left != null) {
    
                    queue.offer(tmp.left);
                }
                if(tmp.right != null) {
    
                    queue.offer(tmp.right);
                }
                size--;
            }
            list.add(list2);
        }
        return list;