¡He preparado 1,000 libros electrónicos y 100 mapas mentales de alta definición en varios campos de la informática, y responderé a [Recursos] después de prestar atención para conseguirlo! ¡Incluso puede responder [introducción] para unirse al grupo introductorio de BAT!
En informática, un árbol binario es una estructura de árbol con un máximo de dos subárboles por nodo . Por lo general, los subárboles se denominan "subárbol izquierdo" y "subárbol derecho". Los árboles binarios se utilizan a menudo para implementar árboles de búsqueda binarios y montones binarios. Los árboles son un poco más complicados que las listas vinculadas porque las listas vinculadas son estructuras de datos lineales y los árboles no lo son. Muchos problemas de árboles pueden resolverse mediante una búsqueda inicial amplia o una búsqueda inicial profunda .
En esta serie, aprenderemos sobre las operaciones clásicas de árboles binarios a través de algunos ejemplos.
01, análisis de tema
Pregunta 104: La profundidad máxima de un árbol binario
Dado un árbol binario, encuentre su profundidad máxima. La profundidad del árbol binario es el número de nodos en la ruta más larga desde el nodo raíz hasta el nodo hoja más lejano.
Explicación: Un nodo hoja se refiere a un nodo sin nodos secundarios.
Ejemplo:
给定二叉树 [3,9,20,null,null,15,7]，
3
/ \
9 20
/ \
15 702, solución recursiva
Sabemos que la profundidad de cada nodo está relacionada con la profundidad de sus subárboles izquierdo y derecho, y es igual al valor de profundidad máxima de sus subárboles izquierdo y derecho más 1. cual es:
maxDepth(root) = max(maxDepth(root.left),
maxDepth(root.right)) + 1Tome [3,4,20, null, null, 15,7] como ejemplo:
<1> Si queremos resolver la profundidad máxima del nodo raíz, debemos resolver la profundidad de sus subárboles izquierdo y derecho
<2> Vemos. El subárbol con 4 como nodo raíz no tiene nodos izquierdo ni derecho, y su profundidad es 1. La profundidad del subárbol con 20 como nodo raíz también depende de la profundidad de sus subárboles izquierdo y derecho.
<3> Para los subárboles de 15 y 7, podemos ver que la profundidad es 1 de un vistazo.
<4> De esto podemos obtener la profundidad máxima del nodo raíz como:
maxDepth(root-3)
=max(**maxDepth**(sub-4),**maxDepth**(sub-20))+1
=max(1,max(**maxDepth**(sub-15),**maxDepth**(sub-7))+1)+1
=max(1,max(1,1)+1)+1
=max(1,2)+1
=3Según el análisis, resolvemos el código mediante recursividad de la siguiente manera:
func maxDepth(root *TreeNode) int {
if root == nil {
return 0
}
return max(maxDepth(root.Left), maxDepth(root.Right)) + 1
}
func max(a int, b int) int {
if a > b {
return a
}
return b
}03 、 DFS
De hecho, el método recursivo que usamos anteriormente usa esencialmente la idea de DFS. Permítanme presentarles primero DFS: Depth First Search. Para árboles binarios, atraviesa los nodos del árbol a lo largo de la profundidad del árbol y busca las ramas del árbol lo más profundo posible . Este proceso continúa hasta que se encuentra la fuente. todos los nodos accesibles por el nodo.
Como se muestra en la figura anterior, la secuencia de acceso del árbol binario es:
A-B-D-E-C-F-GABDECFG
Aquí, pensamos en una pregunta? Aunque usamos un método recursivo para completar con éxito el tema basándonos en la idea de DFS. Pero las deficiencias de este enfoque son obvias. Porque en la recursividad, si la jerarquía es demasiado profunda, es probable que guardemos demasiadas variables temporales, provocando un desbordamiento de la pila . Es por eso que generalmente no usamos la recursividad en el código de fondo. Si no entiende, expliquemos en detalle a continuación:
De hecho, los parámetros de la llamada a la función se pasan a través del espacio de la pila y los recursos de la pila del subproceso se ocuparán durante la llamada . Para las llamadas recursivas, las funciones solo pueden salir después de alcanzar el punto final. Antes de llegar al punto final, el espacio de pila ocupado no se ha liberado. Si el número de llamadas recursivas es demasiado, los recursos de pila ocupados pueden exceder el subproceso El valor máximo de, que hace que la pila se desborde y el programa se cierre de forma anormal.
Entonces, traemos el siguiente tema: cómo convertir código recursivo en una forma no recursiva. Tenga en cuenta aquí que el 99% de recursivo a no recursivo se puede lograr a través de la pila.
DFS no recursivo, el código es el siguiente:
private List<TreeNode> traversal(TreeNode root) {
List<TreeNode> res = new ArrayList<>();
Stack<TreeNode> stack = new Stack<>();
stack.add(root);
while (!stack.empty()) {
TreeNode node = stack.peek();
res.add(node);
stack.pop();
if (node.right != null) {
stack.push(node.right);
}
if (node.left != null) {
stack.push(node.left);
}
}
return res;
}En el código anterior, lo único que se debe enfatizar es, ¿por qué necesitamos insertar datos a la derecha y luego a la izquierda? Esto se debe a que primero debemos acceder a los datos y luego insertarlos en la pila (considere las características de la pila).
Si no comprende el código, consulte la siguiente imagen:
1: Primero empuja a en la pila
2: a saca la pila y empuja cyb hacia la pila (observe el orden)
3: b abre la pila, empuja eyd dentro de la pila
4: d, e, c abre la pila, empuja g, f en la pila
5: f, g pila de bombas
En este punto, la explicación de DFS no recursiva está completa.