【数据结构】：二叉树的遍历（递归）

二叉树的遍历（递归）

二叉树的遍历：是指沿着某条搜索路线，依次对树中每个节点做一次且仅做一次访问。

N：代表根结点

L：代表根结点的左子树

R：代表根结点的右子树

NLR：先序遍历，又称作前序遍历，访问顺序为：根结点-->根的左子树-->根的右子树

LNR：中序遍历，访问顺序为：根的左子树-->根结点-->根的右子树

LRN：后序遍历，访问顺序为：根的左子树-->根的右子树-->根结点

1、二叉树的先序遍历

//先序遍历
public static void postOrder(TreeNode root){
        if (root==null){
            return;
        }
        // 递归遍历左子树
        preOrder(root.left);
​
        // 递归遍历右子树
        preOrder(root.right);
​
        // 访问根节点. 此处的访问就是打印操作
        System.out.print(root.val);
    }

2、二叉树的中序遍历

//中序遍历
public static void inOrder(TreeNode root){
    if (root==null){
        return;
    }
    // 递归遍历左子树
    preOrder(root.left);
​
    // 访问根节点. 此处的访问就是打印操作
    System.out.print(root.val);
​
    // 递归遍历右子树
    preOrder(root.right);
}

3、二叉树的后序遍历

//后序遍历
public static void postOrder(TreeNode root){
    if (root==null){
        return;
    }
    // 递归遍历左子树
    preOrder(root.left);
​
    // 递归遍历右子树
    preOrder(root.right);
​
    // 访问根节点. 此处的访问就是打印操作
    System.out.print(root.val);
}

完整代码：

package java_03_23;
​
public class TreeNode {
    char val;
    TreeNode left;
    TreeNode right;
​
    public TreeNode(char val) {
        this.val=val;
    }
}
​

package java_03_23;
​
public class Tree {
    public static TreeNode buildTree() {
        // 先构造结点
        TreeNode a = new TreeNode('A');
        TreeNode b = new TreeNode('B');
        TreeNode c = new TreeNode('C');
        TreeNode d = new TreeNode('D');
        TreeNode e = new TreeNode('E');
        TreeNode f = new TreeNode('F');
        TreeNode g = new TreeNode('G');
        TreeNode h = new TreeNode('H');
        TreeNode i = new TreeNode('I');
        TreeNode j = new TreeNode('J');
​
​
        a.left = b;
        a.right = c;
​
        b.left = d;
        b.right = null;
​
        c.left = e;
        c.right = f;
​
        d.left = g;
        d.right = h;
​
        e.left = null;
        e.right = i;
​
        f.left = null;
        f.right = null;
​
        g.left = null;
        g.right = null;
​
        h.left = null;
        h.right = null;
​
        i.left = null;
        i.right = null;
​
        return a;
}
    //二叉树的遍历
    // 先序遍历
    public static void preOrder(TreeNode root) {
        if (root == null) {
            return;
        }
        // 访问根节点. 此处的访问就是打印操作
        System.out.print(root.val);
​
        // 递归遍历左子树
        preOrder(root.left);
​
        // 递归遍历右子树
        preOrder(root.right);
    }
​
    //中序遍历
    public static void inOrder(TreeNode root){
        if (root==null){
            return;
        }
        // 递归遍历左子树
        preOrder(root.left);
​
        // 访问根节点. 此处的访问就是打印操作
        System.out.print(root.val);
​
        // 递归遍历右子树
        preOrder(root.right);
    }
​
    public static void postOrder(TreeNode root){
        if (root==null){
            return;
        }
        // 递归遍历左子树
        preOrder(root.left);
​
        // 递归遍历右子树
        preOrder(root.right);
​
        // 访问根节点. 此处的访问就是打印操作
        System.out.print(root.val);
    }
    public static void main(String[] args) {
        TreeNode root=buildTree();
        System.out.println("先序遍历结果：");
        preOrder(root);
        System.out.println();
        System.out.println("中序遍历结果：");
        inOrder(root);
        System.out.println();
        System.out.println("后序遍历结果：");
        postOrder(root);
    }
}
​

结果：