recorrido de árbol binario
Clásico recorrido de árbol binario de cuatro, preorden de recorrido, en el recorrido de orden, orden posterior y transversal nivel.
En el que, antes, durante y después de la secuencia representada por el nodo a sus subárboles izquierdo y derecho de los nodos atravesados orden de impresión.
medios de recorrido preorden que, para cualquier nodo en el árbol, la primera impresión de este nodo, y luego imprimirlo dejó sub-árbol, y finalmente imprimir su subárbol derecho.
medios preorden, para cualquier nodo en el árbol, la primera impresión de su subárbol izquierdo, y luego imprimir por sí mismos, y finalmente imprimir su subárbol derecho.
medios orden posterior que, para cualquier nodo en el árbol, la primera imprimen su subárbol izquierdo, y luego imprimirlo subárbol derecho, y finalmente imprimir el propio nodo.
En pensamientos (algoritmo primero en profundidad) posteriores hace DFS
De hecho, el árbol binario antes, durante y después de atravesar el orden es un proceso recursivo.
Preorden de recorrido, de hecho, es el primero en imprimir el nodo raíz, luego imprime de forma recursiva el subárbol izquierdo, y finalmente el subárbol derecho imprimir de forma recursiva.
前序遍历的递推公式：
preOrder(r) = print r->preOrder(r.left)->preOrder(r.right)
中序遍历的递推公式：
inOrder(r) = inOrder(r.left)->print r->inOrder(r.right)
后序遍历的递推公式：
postOrder(r) = postOrder(r.left)->postOrder(r.right)->print r
recursiva
/**
* 先序遍历
*/
public static void preOrder(Node root) {
if (root == null) {
return;
}
System.out.print(root.value + " -> ");
preOrder(root.left);
preOrder(root.right);
}
/**
* 中序遍历
*/
public static void inOrder(Node root) {
if (root == null) {
return;
}
inOrder(root.left);
System.out.print(root.value + " -> ");
inOrder(root.right);
}
/**
* 后序遍历
*/
public static void postOrder(Node root) {
if (root == null) {
return;
}
postOrder(root.left);
postOrder(root.right);
System.out.print(root.value + " -> ");
}
No recursivo
Con la pila en sí es una implementación recursiva, la implementación no recursiva también tienen que apilar para lograr, en esencia, en realidad nos convertimos en "Manual de recursividad"
/**
* 前序遍历
*/
public static void preOrder2(Node root) {
if (root == null) {
return;
}
Stack<Node> s = new Stack<>();
s.push(root);
Node curNode;
while (!s.isEmpty()) {
curNode = s.pop();
System.out.print(curNode.data + "->");
// 栈先进后出，所以先加入右侧节点，这样输出的时候，先输出左侧节点
if (curNode.right != null) {
s.push(curNode.right);
}
if (curNode.left != null) {
s.push(curNode.left);
}
}
}
/**
* 中序遍历
*/
public static void inOrder2(Node root) {
if (root == null) {
return;
}
Stack<Node> s = new Stack<>();
Node curNode = root;
while (!s.isEmpty() || curNode != null) {
// 入栈所有左节点并输出左节点
while (curNode != null) {
s.push(curNode);
curNode = curNode.left;
}
// 弹出左节点
curNode = s.pop();
System.out.print(curNode.data + "->");
// 弹出后，指向当前节点的右节点
curNode = curNode.right;
}
}
/**
* 后序遍历
*/
public static void postOrder2(Node root) {
if (root == null) {
return;
}
Stack<Node> s1 = new Stack<>();
Stack<Node> s2 = new Stack<>();
s1.push(root);
Node curNode;
while (!s1.isEmpty()) {
curNode = s1.pop();
// 中、右、左顺序压入栈中
s2.push(curNode);
// 压入s1为先左后右，保证中、右、左顺序压入s2中
if (curNode.left != null) {
s1.push(curNode.left);
}
if (curNode.right != null) {
s1.push(curNode.right);
}
}
while (!s2.isEmpty()) {
System.out.print(s2.pop().data + "->");
}
}Atravesar el nivel
BFS de salto de nivel (algoritmo primero en amplitud) de pensamiento.
Nivel recorrido de árbol binario consigue por medio de una cola general.
Paso traverse el nivel es:
1. Para el nodo no está vacío, se añade el primer nodo a la cola
2. fuera del nodo de equipo, el nodo si el niño no se deja vacío, los niños fueron dejados para ser añadido a la cola, o no hacer nada. Del mismo modo derecho del niño
3. La operación anterior se repite hasta que la cola está vacía, el extremo atravesar el nivel
public static void LevelTraversal(Node root) {
if (root == null) {
return;
}
Queue<Node> queue = new LinkedList<Node>();
Node curNode = null;
queue.offer(root);//将根节点入队
while (!queue.isEmpty()) {
curNode = queue.poll();//出队队头元素并访问
System.out.print(curNode.data + "->");
if (curNode.left != null)//如果当前节点的左节点不为空入队
{
queue.offer(curNode.left);
}
if (curNode.right != null)//如果当前节点的右节点不为空，把右节点入队
{
queue.offer(curNode.right);
}
}
}
