二叉树的遍历-递归实现

二叉树是一种非线性结构，它的每个节点最多只包含两个孩子节点。常见的二叉树有满二叉树，完全二叉树，二叉查找树。

public class MyBinaryTree {
    public static class TreeNode {
        private int data;
        private TreeNode left;
        private TreeNode right;

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

    public static void main(String[] args) {
        MyBinaryTree myBinaryTree = new MyBinaryTree();
        LinkedList linkedList = new LinkedList(Arrays.asList(3, 2, 9, null, null, 10, null, null, 8, null, 4));
        TreeNode treeNode = myBinaryTree.createTreeNode(linkedList);
        myBinaryTree.preOrderTraversal(treeNode);
        System.out.println();
        myBinaryTree.inOrderTraversal(treeNode);
        System.out.println();
        myBinaryTree.postOrderTraversal(treeNode);
        System.out.println();
        myBinaryTree.levelOrderTraversal(treeNode);
    }

    public TreeNode createTreeNode(LinkedList<Integer> linkedList) {
        //链表转二叉树，这里按照前序遍历的方式构建二叉树
        TreeNode treeNode = null;
        if (linkedList == null || linkedList.isEmpty()) {
            return null;
        }
        Integer data = linkedList.removeFirst();
        //3, 2, 9, null, null, 10, null, null, 8, null, 4
        if (data != null) {
            treeNode = new TreeNode(data);
            treeNode.left = createTreeNode(linkedList);
            treeNode.right = createTreeNode(linkedList);
        }

        return treeNode;
    }

    public void preOrderTraversal(TreeNode root) {
        //前序遍历 顶点、左孩子、右孩子
        if (root == null) {
            return;
        }

        System.out.print(root.data + " ");
        preOrderTraversal(root.left);
        preOrderTraversal(root.right);
    }

    public void inOrderTraversal(TreeNode root) {
        //中序遍历 左孩子、顶点、右孩子
        if (root == null) {
            return;
        }

        inOrderTraversal(root.left);
        System.out.print(root.data + " ");
        inOrderTraversal(root.right);
    }

    public void postOrderTraversal(TreeNode root) {
        //后序遍历 左孩子、右孩子、顶点
        if (root == null) {
            return;
        }

        postOrderTraversal(root.left);
        postOrderTraversal(root.right);
        System.out.print(root.data + " ");
    }

    public void levelOrderTraversal(TreeNode root) {
        //层序遍历
        if (root == null) {
            return;
        }
        //获取树的高度
        int depth = getDepth(root);

        //遍历每层的节点元素
        for (int i = 1; i <= depth; i++) {
            levelOrderTraversal(root, i);
        }
    }

    //获取树的高度
    private int getDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }

        //获取左子树高度
        int left = getDepth(root.left);
        //获取右子树高度
        int right = getDepth(root.right);

        return Math.max(left, right) + 1;
    }

    //遍历某一层的逻辑
    private void levelOrderTraversal(TreeNode root, int level) {
        if (root == null || level < 1) {
            return;
        }

        if (level == 1) {
            System.out.print(root.data + " ");
            return;
        }

        levelOrderTraversal(root.left, level - 1);
        levelOrderTraversal(root.right, level - 1);
    }
}