二叉树的遍历(先序，中序，后序，层序）

数据结构里，我们都学过二叉树，二叉树的遍历分为先序遍历，中序遍历和后序遍历，还有相对不常用的层序遍历。
先序遍历：先遍历根再遍历左子树再遍历右子树
中序遍历：先遍历左子树再遍历根再遍历右子树
后序遍历：先遍历左子树再遍历右子树再遍历根
层序遍历：把一棵二叉树按照从左到右，从上到下的顺序遍历，以层来分
例如：有这么一棵树

那么这棵树的先序，中序，后序的遍历依次为
先序：ABDHECFIG
中序：HDBEAFICG
后序：HDEBIFGCA
层序：ABCDEGFHI

那么实现二叉树遍历的代码如下：

import java.util.Arrays;
import java.util.List;

public class Trees { //在这里是构建一棵树，以便检验代码的正确性
public static Node buildTrees(){
Node a = new Node(‘A’);
Node b = new Node(‘B’);
Node c = new Node(‘C’);
Node d = new Node(‘D’);
Node e = new Node(‘E’);
Node f = new Node(‘F’);
Node g = new Node(‘G’);
Node h = new Node(‘H’);
Node i = new Node(‘I’);

    a.left = b;a.right = c;
    b.left = d;b.right = e;
    c.left = f;c.right = g;
    d.left = h;d.right = null;
    e.left = null;e.right = null;
    f.left = null;f.right = i;
    g.left = null;g.right = null;
    h.left = null;h.right = null;
    i.left = null;i.right = null;

    return a;
}
public static void preOrderTraversal(Node root){
    if(root == null){
        return ;
    }
    System.out.println(root.value);
    preOrderTraversal(root.left);
    preOrderTraversal(root.right);
}
public static void inOrderTraversal(Node root){
    if(root == null){
        return;
    }
    inOrderTraversal(root.left);
    System.out.println(root.value);
    inOrderTraversal(root.right);
}
public static void postOrderTraversal(Node root){
    if(root == null){
        return;
    }
    postOrderTraversal(root.left);
    postOrderTraversal(root.right);
    System.out.println(root.value);
}
public static void main(String[] args){
    Node root = buildTrees();
    preOrderTraversal(root);
    System.out.println("----------------------------------");
    inOrderTraversal(root);
    System.out.println("----------------------------------");
    postOrderTraversal(root);
    System.out.println("----------------------------------");
}

}

打印结果如下图：

上面是先序，中序和后序，然后层序在下面：
代码：
class solution {
public static void levelOrderTraversal(TreeNode root) {
if (root == null) {
return;
}
Queue queue = new LinkedList<>();
queue.add(root);
while(!queue.isEmpty()){
TreeNode front = queue.poll();
System.out.println(front.value);
if(front.left!=null){
queue.add(front.left);
}
if(front.right!=null){
queue.add(front.right);
}
}
}
public static TreeNode buildTrees(){
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’);

    a.left = b;a.right = c;
    b.left = d;b.right = e;
    c.left = f;c.right = g;
    d.left = h;d.right = null;
    e.left = null;e.right = null;
    f.left = null;f.right = i;
    g.left = null;g.right = null;
    h.left = null;h.right = null;
    i.left = null;i.right = null;

    return a;
}
public static void main(String[]args){
     TreeNode root = buildTrees();
    levelOrderTraversal(root);

}

}

（还是同一棵树）
结果：