Java实现二叉树的遍历

    最近在复习Java数据结构与算法的知识，这里编写代码实现二叉树的遍历。

    二叉树的遍历分为两个方面，即深度优先和广度优先。深度优先遍历包含前序遍历、中序遍历、和后续遍历；广度优先遍历包含层序遍历。不同的遍历原理我在下面的代码注释中有简单的标注。这里编写代码实现这四种遍历。

    

package com.zhangyu.study.test20191113;

import java.util.*;

/**
 * Function: 二叉树测试
 *
 * @author zhangyu
 * Date: 2019/11/13
 * @since JDK 1.8
 */
public class MyTree {

    /**
     * 节点类
     */
    private static class Node {
        /**
         * 数据
         */
        private int data ;

        /**
         * 左孩子
         */
        private Node left;

        /**
         * 右孩子
         */
        private Node right;

        /**
         * 节点构造器
         * @param data  数据
         */
        public Node(int data) {
            this.data = data;
        }
    }

    /**
     * 构造一个二叉树
     * @return 返回
     */
    public static Node createBinaryTree(List<Integer> numberList){
        if (numberList == null || numberList.isEmpty()) {
            return null;
        }
        Node dataNode = null;
        // 获取第一个元素病移除
        Integer first = numberList.remove(0);
        if (first != null) {
            dataNode = new Node(first);
            dataNode.left = createBinaryTree(numberList);
            dataNode.right = createBinaryTree(numberList);
        }
        return dataNode;
    }

    /**
     * 前序遍历 【递归写法】
     *
     * 顺序是：根 -> 左 -> 右
     *
     * @param rootNode  二叉树根节点
     */
    public static void preTraverse(Node rootNode) {
        System.out.print(rootNode.data + "\t");
        if (Objects.nonNull(rootNode.left)) {
           preTraverse(rootNode.left);
       }
        if (Objects.nonNull(rootNode.right)) {
            preTraverse(rootNode.right);
        }
    }

    /**
     * 中序遍历 【递归写法】
     *
     * 顺序是： 左 -> 根 -> 右
     *
     * @param rootNode  二叉树根节点
     */
    public static void midTraverse(Node rootNode) {
        if (Objects.nonNull(rootNode.left)) {
            midTraverse(rootNode.left);
        }
        System.out.print(rootNode.data + "\t");
        if (Objects.nonNull(rootNode.right)) {
            midTraverse(rootNode.right);
        }
    }

    /**
     * 后序遍历 【递归写法】
     *
     * 顺序是：左 -> 右 -> 根
     *
     * @param rootNode  二叉树根节点
     */
    public static void postTraverse(Node rootNode) {
        if (Objects.nonNull(rootNode.left)) {
            postTraverse(rootNode.left);
        }
        if (Objects.nonNull(rootNode.right)) {
            postTraverse(rootNode.right);
        }
        System.out.print(rootNode.data + "\t");

    }

    /**
     * 层序遍历 【非递归写法】
     *
     * 从根节点开始，由左及右遍历完一层再遍历下一层
     * 采用队列，如果
     *
     * @param rootNode  根节点
     */
    public static void levelTraverse(Node rootNode) {
        // 存放dian
        Queue<Node> nodeQueue = new LinkedList<>();
        nodeQueue.offer(rootNode);
        while ( ! nodeQueue.isEmpty()) {
            Node node = nodeQueue.poll();
            System.out.print(node.data + "\t");
            if (Objects.nonNull(node.left)) {
                nodeQueue.offer(node.left);
            }
            if (Objects.nonNull(node.right)) {
                nodeQueue.offer(node.right);
            }
        }
    }


    /**
     * 测试遍历方法
     *
     * 测试数据中的二叉树为
     *
     *                    3
     *                  /    \
     *                2        6
     *             /    \        \
     *           1       10      7
     *
     *                    3
     *                  /    \
     *                2        6
     *             /    \     /   \
     *           1       10  null  7
     *         /  \    /   \
     *     null  null null null
     */
    public static void main(String[] args) {
        LinkedList<Integer> dataList = new LinkedList<>(Arrays.asList(3,2,1,null,null,10,null,null,6,null,7));
        // 构建二叉树
        Node binaryTree = createBinaryTree(dataList);
        // 前序遍历
        preTraverse(binaryTree);    // 3	2	1	10	6	7
        System.out.println();
        midTraverse(binaryTree);    // 1	2	10	3	6	7
        System.out.println();
        postTraverse(binaryTree);   // 1	10	2	7	6	3
        System.out.println();
        levelTraverse(binaryTree);  // 3	2	6	1	10	7
        System.out.println();

    }

}

    

    在代码中，前序遍历、中序遍历、后续遍历采用递归方法实现，层序遍历采用队列的思想实现。在未来，我将补全前中后序三种遍历方式的非递归写法，以及层序遍历的递归写法。

    如文章中有错误，欢迎您批评指正！