卜若的代码笔记-算法实验室：十一：二叉树的遍历(基于栈)

1 我们直接参考

https://blog.csdn.net/rikeyone/article/details/94407275

这个老哥给出的图了：

先构成一个节点树：

深度搜索可以实现前序遍历：

package 二叉树;

public class Node {

    public Node(String value){

        this.value = value;
    }

    public Node addLeft(Node nd){
        this.left = nd;

        return this.left;
    }

    public Node addRight(Node nd){

        this.right = nd;
        return  this.right;
    }


    public Node left;
    public Node right;

    public String value;
}

package 二叉树;

import java.util.Stack;

public class NodeManager {

    public Node tree(){

        Node root = new Node("A");
        Node l1 = root.addLeft(new Node("B"));
        Node l2 = root.addRight(new Node("E"));
        l1.addLeft(new Node("C"));
        l1.addRight(new Node("D"));
        l2.addLeft(new Node("F"));
        l2.addRight(new Node("G"));
        return root;
    }

    public void dfs(Node root){

        Stack<Node> sd = new Stack<Node>();


        sd.push(root);
        while (!sd.isEmpty()){


            Node temp = sd.pop();

            System.out.print(temp.value+" ");


            if(temp.right != null){

                sd.push(temp.right);
            }
            if(temp.left!= null){
                sd.push(temp.left);
            }
        }

    }
}

 结果：

 

所以先序遍历时最简单的

中序遍历要复杂一些，单是理解就比较麻烦，这篇讲的其实不错：

https://blog.csdn.net/u012877472/article/details/49401751

我们继续使用栈来实现：

入栈顺序： 

 顺着root的left方向遍历所有的left节点直到c节点，入栈顺序是A,B,C，

C出栈并输出C，并将C的右子节点作为新的root

为空

B出栈，并将B的右子节点D作为新的root

D入栈，

D出栈，将D的右节点作为新的root，依旧为空，A出栈

此时的出栈顺序为C,B,D,A

将A的右子节点作为新的root

...

总结下来就是：while(){

searchRootLeft(Node root);

出栈

右节点入栈

}

    public void inorderTraversal(Node curr){
        Stack<Node> stack = new Stack<Node>();
        Node root = curr;
        while (!stack.isEmpty()){

            while (root!= null){
                stack.push(root);
                root = root.left;
            }
            Node outData = stack.pop();
            System.out.print(outData.value+" ");
            root = outData.right;
        }
    }

 

后续我感觉就比较奇葩了...

就是深搜的逆过程：

复杂度为o(2n)

    public void dfs(Node root){

        Stack<Node> sd = new Stack<Node>();

        Stack<Node> reback = new Stack<Node>();
        sd.push(root);
        while (!sd.isEmpty()){


            Node temp = sd.pop();
            reback.push(temp);


            if(temp.left!= null){
                sd.push(temp.left);
            }
            if(temp.right != null){

                sd.push(temp.right);


            }

        }

        while (!reback.isEmpty()){

            System.out.print(reback.pop().value+" ");
        }

    }