[Registro de cepillado de LeetCode] 31. Verifique el saldo

Llega oferta, cava amigos a recoger! Estoy participando en el evento de registro de reclutamiento de primavera de 2022, haga clic para ver los detalles del evento .

1. Descripción del tema:

Fuente del tema: LeetCode - Comprobación de saldo

Implemente una función que compruebe si un árbol binario está equilibrado. En este problema, un árbol equilibrado se define de la siguiente manera: para cualquier nodo, la diferencia de altura entre sus dos subárboles no excede de 1.

Ejemplo 1:

Dado un árbol binario [3,9,20,null,null,15,7]

Devolver verdadero.

Ejemplo 2:

Dado un árbol binario [1,2,2,3,3,null,null,4,4]

Falso retorno .

2. Análisis del pensamiento:

Idea uno:

De acuerdo con la definición de equilibrio, calcule la altura de los subárboles izquierdo y derecho de cada nodo.

Si la diferencia de altura entre los subárboles izquierdo y derecho de un nodo es mayor que 1, se desequilibrará, devolverá falso y terminará; de lo contrario, significa que el subárbol enraizado en el nodo actual está equilibrado y continúe verificando el equilibrio de los subárboles izquierdo y derecho del nodo actual.

Calcular la altura de un árbol binario.

Recursión, la altura del árbol binario actual = max(altura del subárbol izquierdo, altura del subárbol derecho) + 1max(altura del subárbol izquierdo, altura del subárbol derecho)+1

La altura del subárbol izquierdo se calcula de la misma manera

Si el nodo actual es nulo, devuelve 0, que es la salida recursiva

De acuerdo con el método de descomposición anterior, se puede llegar a la salida recursiva

Idea dos:

De arriba a abajo, cada nodo se juzga una vez

Idea tres:

De abajo hacia arriba, cree un método que calcule la altura máxima y devuelva -1 si la diferencia entre la izquierda y la derecha es mayor que 1

3. Código de CA:

4. Resumen:

Idea uno:

    class Solution {
        public boolean isBalanced(TreeNode root) {
            if (root == null) return true;
            int leftTreeD = treeDepth(root.left);
            int rightTreeD = treeDepth(root.right);
            if (Math.abs(leftTreeD - rightTreeD) > 1) return false;
            return isBalanced(root.left) && isBalanced(root.right);
        }

        public int treeDepth(TreeNode root) {
            if (root == null) return 0;
            return Math.max(treeDepth(root.left), treeDepth(root.right)) + 1;
        }
    }
复制代码

Idea dos:

    class Solution {

        public boolean isBalanced(TreeNode root) {
            if (root == null) {
                return true;
            }
            if (Math.abs(check(root.left) - check(root.right)) > 1) {
                return false;
            }
            return isBalanced(root.left) && isBalanced(root.right);
        }

        public int check(TreeNode root) {
            if (root == null) {
                return 0;
            }
            int maxLong = Math.max(check(root.left), check(root.right)) + 1;
            return maxLong;
        }
    }
复制代码

Idea tres:

    class Solution {
        public boolean isBalanced(TreeNode root) {
            return recursion(root) != -1;
        }

        private int recursion(TreeNode root) {
            if (root == null) {
                return 0;
            }
            int leftValue = recursion(root.left);
            if (leftValue == -1) {
                return -1;
            }
            int rightValue = recursion(root.right);
            if (rightValue == -1) {
                return -1;
            }
            if (Math.abs(leftValue - rightValue) > 1) {
                return -1;
            }
            return Math.max(leftValue, rightValue) + 1;
        }
    }
复制代码