基于先序遍历 输出二叉树叶子节点的路径(非递归)

基于先序遍历 输出二叉树叶子节点的路径(非递归)

思路：
1. 先序遍历二叉树，入栈，直到访问到叶子节点；
2. 如果达到叶子节点，遍历当前栈，获取当前叶子节点的路径；然后进入回退模式，直到有新的右节点。
3. 在回退的过程中，如果是父节点为了不再重复进入进入左右子树，使用一个pre指针指向最近回退点(pre肯定是当前父节点的左或右孩子)。

定义节点，为了简化，省略访问修饰、泛型、get&set、null ……

public class TreeNode {

    Object value;
    TreeNode left;
    TreeNode right;

    public TreeNode() {
    }

    public TreeNode(Object value) {
        this.value = value;
    }

    public TreeNode(Object value, TreeNode left, TreeNode right) {
        this.value = value;
        this.left = left;
        this.right = right;
    }
}

遍历方法：

public static void main(String[] args) {
        TreeNode root = buildTree();
        List<String> pathList = getTreeAllPath(root);
        System.out.println("====== Tree All Path =========");
        for (String s : pathList) {
            System.out.println("Path: " + s);
        }
    }

    public static List<String> getTreeAllPath(TreeNode root) {
        Stack<TreeNode> s = new Stack<TreeNode>();
        List<String> pathList = new ArrayList<String>();

        TreeNode ptr = root;
        TreeNode pre = null;
        TreeNode top = null;

        do {
            //push left
            while (ptr != null && pre == null) {
                s.push(ptr);
                ptr = ptr.left;
            }
            top = s.peek();
            if (top.right != null && top.right != pre) {
                ptr = top.right;
                pre = null;
            } else {
                if (pre == null) {//it is leaf
                    pathList.add(getPath(s, "->"));
                }
                pre = s.pop();//(back mode) back until new right node
            }

        } while (!s.isEmpty());

        return pathList;
    }

    private static String getPath(Stack<TreeNode> s, String sp) {
        Iterator<TreeNode> it = s.iterator();
        StringBuilder buf = new StringBuilder();
        while (it.hasNext()) {
            if (buf.length() != 0) {
                buf.append(sp);
            }
            buf.append(String.valueOf(it.next().value));
        }
        return buf.toString();
    }

    public static TreeNode buildTree() {
        TreeNode[] nodes = new TreeNode[12];
        for (int i = 0; i <= 11; i++) {
            nodes[i] = new TreeNode(i);
        }
        TreeNode root = nodes[1];
        root.left = nodes[2];
        root.right = nodes[6];

        nodes[2].left = nodes[3];
        nodes[2].right = nodes[5];

        nodes[3].left = nodes[4];
        nodes[3].right = null;

        nodes[4].left = null;
        nodes[4].right = nodes[9];

        nodes[9].left = nodes[10];
        nodes[9].right = nodes[11];

        nodes[6].left = nodes[7];
        nodes[6].right = nodes[8];

        return root;
    }

如下面的二叉树

输出结果：

====== Tree All Path =========
Path: 1->2->3->4->9->10
Path: 1->2->3->4->9->11
Path: 1->2->5
Path: 1->6->7
Path: 1->6->8