Tema
- Árbol
- Búsqueda en profundidad primero
- Recursividad
Descripción
https://leetcode.com/problems/binary-tree-tilt/
Dado el valor rootde un árbol binario, devuelve la suma de la inclinación de cada nodo del árbol .
La inclinación de un nodo de árbol es la diferencia absoluta entre la suma de todos los valores del nodo del subárbol izquierdo y todos los valores del nodo del subárbol derecho . Si un nodo no tiene un hijo izquierdo, entonces la suma de los valores del nodo del subárbol izquierdo se trata como 0. La regla es similar si el nodo no tiene un hijo derecho.
Ejemplo 1 :
Input: root = [1,2,3]
Output: 1
Explanation:
Tilt of node 2 : |0-0| = 0 (no children)
Tilt of node 3 : |0-0| = 0 (no children)
Tilt of node 1 : |2-3| = 1 (left subtree is just left child, so sum is 2; right subtree is just right child, so sum is 3)
Sum of every tilt : 0 + 0 + 1 = 1
Ejemplo 2 :
Input: root = [4,2,9,3,5,null,7]
Output: 15
Explanation:
Tilt of node 3 : |0-0| = 0 (no children)
Tilt of node 5 : |0-0| = 0 (no children)
Tilt of node 7 : |0-0| = 0 (no children)
Tilt of node 2 : |3-5| = 2 (left subtree is just left child, so sum is 3; right subtree is just right child, so sum is 5)
Tilt of node 9 : |0-7| = 7 (no left child, so sum is 0; right subtree is just right child, so sum is 7)
Tilt of node 4 : |(3+5+2)-(9+7)| = |10-16| = 6 (left subtree values are 3, 5, and 2, which sums to 10; right subtree values are 9 and 7, which sums to 16)
Sum of every tilt : 0 + 0 + 0 + 2 + 7 + 6 = 15
Ejemplo 3 :
Input: root = [21,7,14,1,1,2,2,3,3]
Output: 9
Restricciones :
- El número de nodos en el árbol está en el rango [0, 10⁴].
- -1000 <= Node.val <= 1000
Análisis
Utilice el algoritmo de recorrido posterior al pedido del árbol binario.
Sumisión
import com.lun.util.BinaryTree.TreeNode;
public class BinaryTreeTilt {
public int findTilt(TreeNode root) {
int[] sum = {
0};
findTilt(root, sum);
return sum[0];
}
private int findTilt(TreeNode root, int[] sum) {
if (root == null) return 0;
int leftSum = findTilt(root.left, sum);
int rightSum = findTilt(root.right, sum);
sum[0] += Math.abs(leftSum - rightSum);
return leftSum + rightSum + root.val;
}
}
Prueba
import static org.junit.Assert.*;
import org.junit.Test;
import com.lun.util.BinaryTree;
public class BinaryTreeTiltTest {
@Test
public void test() {
BinaryTreeTilt obj = new BinaryTreeTilt();
assertEquals(1, obj.findTilt(BinaryTree.integers2BinaryTree(1, 2, 3)));
assertEquals(15, obj.findTilt(BinaryTree.integers2BinaryTree(4, 2, 9, 3, 5, null, 7)));
assertEquals(9, obj.findTilt(BinaryTree.integers2BinaryTree(21, 7, 14, 1, 1, 2, 2, 3, 3)));
}
}