二叉树四种遍历方式（前、中、后、层）

一. 遍历方式

1. 前序遍历:根节点，左子树，右子树；
2. 中序遍历：左子树，根节点，右子树；
3. 后序遍历：左子树，右子树，根节点；
4. 层序遍历：一层一层的横向遍历。
   前三种遍历方式统称为：深度优先遍历；第四种遍历方式又叫：广度优先遍历

二. 示例

1. 要求：用四种遍历方式遍历如下二叉树
   

2. 代码实现

   import java.util.Arrays;
   import java.util.LinkedList;
   import java.util.Queue;
   
   public class MyBinaryTree {
       //二叉树节点
       private static class TreeNode{
           int data;
           TreeNode leftChild;
           TreeNode rightChile;
   
           public TreeNode(int data) {
               this.data = data;
           }
       }
   
       //构建二叉树
       public static TreeNode createBinaryTree(LinkedList<Integer> inputList) {
           TreeNode node = null;
           if(inputList == null || inputList.isEmpty()) {
               return null;
           }
           Integer data = inputList.removeFirst();
   
           //如果元素为空，则不再递归
           if(data != null){
               node = new TreeNode(data);
               node.leftChild = createBinaryTree(inputList);
               node.rightChile = createBinaryTree(inputList);
           }
           return node;
       }
   
       //前序遍历:根节点，左子树，右子树
       public static void preOrderTraveral(TreeNode node) {
           if (node == null) {
               return;
           }
           System.out.println(node.data);
           preOrderTraveral(node.leftChild);
           preOrderTraveral(node.rightChile);
       }
   
       //中序遍历：左子树，根节点，右子树
       public static void inOrderTraveral(TreeNode node) {
           if(node == null) {
               return;
           }
   
           inOrderTraveral(node.leftChild);
           System.out.println(node.data);
           inOrderTraveral(node.rightChile);
   
       }
   
       //后序遍历：左子树，右子树，根节点
       public static void postOrderTraveral(TreeNode node) {
           if (node == null) {
               return;
           }
   
           postOrderTraveral(node.leftChild);
           postOrderTraveral(node.rightChile);
           System.out.println(node.data);
       }
   
       //层序遍历
       public static void levelOrderTraveral(TreeNode root) {
           Queue<TreeNode> queue = new LinkedList<TreeNode>();
           queue.offer(root);
           while (!queue.isEmpty()) {
               TreeNode node = queue.poll();
               System.out.println(node.data);
               if(node.leftChild != null) {
                   queue.offer(node.leftChild);   //offer():向队列添加一个元素
               }
               if(node.rightChile != null) {
                   queue.offer(node.rightChile);
               }
           }
       }
   
       public static void main(String[] args) {
          LinkedList<Integer> inputList = new LinkedList<Integer>(Arrays.asList(new Integer[]{3,2,9,null,null,10,null,null,8,null,4}));
          TreeNode treeNode = createBinaryTree(inputList);
          System.out.println("前序遍历：");
          preOrderTraveral(treeNode);
   
           System.out.println("中序遍历：");
           inOrderTraveral(treeNode);
   
           System.out.println("后序遍历：");
           postOrderTraveral(treeNode);
   
           System.out.println("层序遍历：");
           levelOrderTraveral(treeNode);
       }
   }
   

3. 运行结果

   前序遍历：
   3
   2
   9
   10
   8
   4
   中序遍历：
   9
   2
   10
   3
   8
   4
   后序遍历：
   9
   10
   2
   4
   8
   3
   层序遍历：
   3
   2
   8
   9
   10
   4