递归遍历树结构

遍历树结构有三种顺序，根左右，左根右，左右根。

1、构造树结构

public class TreeNode<T> {
    public TreeNode<T> left;
    public TreeNode<T> right;
    public T data;

    public TreeNode(T data) {
        this.data = data;
    }
}

2、遍历

public class TreeSearch<T> {

    public StringBuffer path = new StringBuffer();

    public void per(TreeNode<T> root) {
        // 递归返回条件
        if (root == null) {
            return;
        }
        // 去掉开始的箭头
        if (!path.toString().equals("")) {
            path.append("->");
        }
        //  先输出根节点
        path.append(root.data);
        // 递归左节点
        per(root.left);
        // 递归右节点
        per(root.right);
    }

    public void mid(TreeNode<T> root) {
        if (root == null) {
            return;
        }
        mid(root.left);
        if (!path.toString().equals("")) {
            path.append("->");
        }
        path.append(root.data);
        mid(root.right);
    }

    public void suf(TreeNode<T> root) {
        if (root == null) {
            return;
        }
        suf(root.left);
        suf(root.right);
        if (!path.toString().equals("")) {
            path.append("->");
        }
        path.append(root.data);
    }

}

3、测试一下

public class TreeSearchTest {
    private static TreeNode<Integer> root = new TreeNode<>(1);
    @BeforeClass
    public static void beforeClass() {
        root.left = new TreeNode<>(2);
        root.right = new TreeNode<>(3);

        root.left.left = new TreeNode<>(4);
        root.left.right = new TreeNode<>(5);
        root.right.left = new TreeNode<>(6);
        root.right.right = new TreeNode<>(7);

        root.left.left.left = new TreeNode<>(8);
        root.left.left.right = new TreeNode<>(9);
        root.left.right.left = new TreeNode<>(10);
        root.left.right.right = new TreeNode<>(11);
        root.right.left.left = new TreeNode<>(12);
        root.right.left.right = new TreeNode<>(13);
        root.right.right.left = new TreeNode<>(14);
        root.right.right.right = new TreeNode<>(15);

    }

    @Test
    public void test() {
        TreeSearch<Integer> treeSearch = new TreeSearch<>();
        TreeSearch<Integer> treeSearch2 = new TreeSearch<>();
        TreeSearch<Integer> treeSearch3 = new TreeSearch<>();
        treeSearch.per(root);
        treeSearch2.mid(root);
        treeSearch3.suf(root);
        System.out.println(treeSearch.path);
        System.out.println(treeSearch2.path);
        System.out.println(treeSearch3.path);
    }

}

1->2->4->8->9->5->10->11->3->6->12->13->7->14->15
8->4->9->2->10->5->11->1->12->6->13->3->14->7->15
8->9->4->10->11->5->2->12->13->6->14->15->7->3->1

理解递归遍历树结构很简单，对遍历到的节点套用遍历规则即可。