contenido
Implementación no recursiva del recorrido previo al pedido (LeetCode144)
Implementación no recursiva del recorrido en orden (LeetCode94)
Implementación no recursiva del recorrido posterior (LeetCode145)
Implementación no recursiva del recorrido previo al pedido (LeetCode144)
Nota: Los elementos recorridos a continuación se guardarán en la Lista y se devolverán
El orden de recorrido previo al pedido: root---left---right
Para la implementación no recursiva del recorrido en orden previo del árbol binario, la pila es una estructura de datos. Los métodos específicos son los siguientes:
1. Cree una pila y guarde el nodo raíz del árbol binario en la pila
2. Cuando la pila no esté vacía, retire el elemento superior de la pila y recorra
3. Si el nodo raíz tiene un subárbol derecho, guarde el nodo raíz del subárbol derecho en la pila.
4. Luego atraviese el subárbol izquierdo de la raíz, y el orden para atravesar el subárbol izquierdo también es atravesar primero la raíz para ver si hay un subárbol derecho, luego continúe atravesando el subárbol izquierdo y haga un bucle en este orden
5. Finalmente, cuando la pila esté vacía, regrese a Lista
El proceso anterior se ilustra con un diagrama para una fácil comprensión:
Código de referencia:
public class Solution {
public IList<int> PreorderTraversal(TreeNode root) {
List<Integer> list = new ArrayList<>();
Stack<TreeNode> s = new Stack<>();
if(root==null){
return list;
}
TreeNode cur = root;
s.push(cur);
while(!s.empty()){
cur = s.pop();
while(cur!=null){
list.add(cur.val);
if(cur.right!=null){
s.push(cur.right);
}
cur = cur.left;
}
}
return list;
}
}Implementación no recursiva del recorrido en orden (LeetCode94)
El orden del recorrido en orden: izquierda---raíz---derecha , guarde el resultado del recorrido en la Lista
Para lograr un recorrido no recursivo con la ayuda de la estructura de datos de pila, los métodos específicos son los siguientes:
1. Empuje el nodo raíz y el nodo raíz del subárbol izquierdo en la pila a su vez
2. Saque el elemento superior de la pila y atraviese
3. Acceda al subárbol derecho del elemento superior de la pila.
4. El subárbol derecho del elemento superior de la pila también es un árbol binario, por lo que las operaciones anteriores se repiten
Instrucciones de dibujo:
Código de referencia:
class Solution {
public List<Integer> inorderTraversal(TreeNode root) {
List<Integer> list = new ArrayList<>();
Stack<TreeNode> s = new Stack<>();
if(root == null){
return list;
}
TreeNode cur = root;
while(!s.empty()||cur!=null){
while(cur!=null){
s.push(cur);
cur = cur.left;
}
cur = s.pop();
list.add(cur.val);
cur = cur.right;
}
return list;
}
}Implementación no recursiva del recorrido posterior (LeetCode145)
Orden de recorrido posterior: izquierda---derecha---raíz , guarde el resultado del recorrido en la Lista
Para lograr un recorrido posterior no recursivo, la pila también es una estructura de datos.Los métodos específicos son los siguientes:
1. El primer paso es el mismo que el recorrido en orden, y el nodo raíz del subárbol izquierdo se almacena en la pila a su vez.
2. Obtenga el elemento superior de la pila, si el subárbol derecho del nodo está vacío, atraviese el nodo; de lo contrario, atraviese el subárbol derecho del nodo
3. El subárbol derecho es nuevamente un árbol binario, continúe con las operaciones anteriores.
Nota: marque cada elemento recorrido con pre, aquí cada vez que se obtiene el elemento superior de la pila, cuando la derecha del elemento superior de la pila está vacía o igual al nodo marcado, el elemento se recorre en este momento, el propósito de esto es para evitar bucles, lo que resulta en un desbordamiento de pila.
Instrucciones de dibujo:
Código de referencia:
class Solution {
public List<Integer> postorderTraversal(TreeNode root) {
List<Integer> list = new ArrayList<>();
Stack<TreeNode> s = new Stack<>();
if(root==null){
return list;
}
TreeNode cur = root;
TreeNode pre = null;
while(!s.empty()||cur!=null){
while(cur!=null){
s.push(cur);
cur = cur.left;
}
cur = s.peek();
if(cur.right==null||cur.right==pre){
list.add(cur.val);
s.pop();
pre = cur;
cur = null;
}else{
cur = cur.right;
}
}
return list;
}
}