Não recursivo passagem de árvore binária após preâmbulo da

forma recursiva para conseguir passagem de árvore binária, segundo a ordem antes que seja simples, só precisa usar uma forma muito simples declarações recursivas, pilha função irá nos ajudar automaticamente para executar operações complexas. Usando forma não recursiva de uma árvore binária em caminhamento pós-fixado frente, essencialmente, criar uma pilha a pilha função humana simulação.

1. preorder travessia não recursivo

1. Uma pilha de aplicativos pilha, ea pilha é pressionado para o nó principal.

2. Pop nó pilha da pilha, a impressão, então o seu nó filho direita (não esvaziar então) ser pressionado na pilha e, finalmente, seu nó filho esquerdo (se não esvaziar) pressionado na pilha.

3. Passo 2 é repetido até que a pilha está vazia, todo o processo termina.

private static void firstSearch(TreeNode t){

        Stack<TreeNode> stack = new Stack<>();
        // 先放根，然后pop出来放右节点和左节点，然后重复上述操作
        stack.push(t);
        while(!stack.isEmpty()){
            TreeNode temp = stack.peek();
            stack.pop();
            System.out.println(temp.val);
            if(temp.right != null){
                stack.push(temp.right);
            }
            if(temp.left != null){
                stack.push(temp.left);
            }
        }
    }

2. A fim de alcançar o percurso não-recursiva

1. Aplicar uma pilha pilha, cur sazonal inicial = cabeça

2. Cur empurrado primeiro para a pilha, a fronteira esquerda são sequencialmente colocado na pilha, isto é, mantido a fazer t = t.left, repetir os passos 2

3. 2 repetido até que é nulo, um nó pop da pilha, referido como um nó, o valor do nó da impressão e tomar t = node.right, repita os passos 2

4. Quando a pilha está vazia e t está vazia, o processo pára.

private static void midSearch(TreeNode t){
        Stack<TreeNode> stack = new Stack<>();
        // 首先不断入栈顶节点的左节点，直到入不了为止，然后pop出栈顶节点，入一个右节点，然后入该右节点的左子节点直到
        // 入不了为止，重复上述步骤
        if(t != null){
            while(t != null || !stack.isEmpty()){
                if(t != null){
                    stack.push(t);
                    t = t.left;
                }else{
                    System.out.println(stack.peek().val);
                    t = stack.pop().right;
                }
            }
        }
    }

3. Não postorder recursiva

1. Aplique uma s1 pilha, então o nó principal para a pilha de s1.

2. A partir dos nós de pop-S1 registrados como temp, temperatura e ligue nó filho esquerdo eo S1 nó filho direito pressionado.

3. Ao longo do processo, cada nó é ejetado S1 e S2 são colocados.

4. Repetir os passos 2 e 3 até que S1 estiver vazia, o processo pára.

5. Sequencialmente ejetado a partir do nó de impressão eo s2, a ordem de impressão, segundo a ordem está atravessando.

private static void lastSearch(TreeNode t){
        // 仿照先序遍历的相反顺序，但是pop出来后需要放入另一个栈中
        Stack<TreeNode> stack1 = new Stack<>();
        Stack<TreeNode> stack2 = new Stack<>();
        stack1.push(t);
        while(!stack1.isEmpty()){
            TreeNode temp = stack1.peek();
            stack2.push(stack1.pop());
            if(temp.left != null){
                stack1.push(temp.left);
            }
            if(temp.right != null){
                stack1.push(temp.right);
            }
        }
        while(!stack2.isEmpty()){
            System.out.println(stack2.pop().val);
        }
    }