Java 二叉树四种遍历

基于二叉树的四种遍历

import java.util.LinkedList;

/**
 * @description： 二叉树节点类
 * @author: ShaoYJ
 * @date: 2022/8/6 11:30
 */
class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    TreeNode() {
    }

    TreeNode(int val) {
        this.val = val;
    }

    TreeNode(int val, TreeNode left, TreeNode right) {
        this.val = val;
        this.left = left;
        this.right = right;
    }
}


/**
 * @description： 主类
 * @author: ShaoYJ
 * @date: 2022/8/5 19:58
 */
public class Q623 {
    static int counter = 0;

    /**
     * 创建一个二叉树
     * @param root 根节点（null）
     * @param nums 整数数组
     * @param index 数组索引，可用于定位到将要被插入的元素
     * @return 树根节点
     */
    public TreeNode createTreeNode(TreeNode root, int[] nums, int index) {
        if (index < nums.length) {
            if (nums[index] == 0) {
                return null;
            } else {
                root.val = nums[index];
                TreeNode left = new TreeNode();
                root.left = createTreeNode(left, nums, ++counter);
                TreeNode right = new TreeNode();
                root.right = createTreeNode(right, nums, ++counter);
                return root;
            }
        }
        return root;
    }


    /**
     * 先序遍历
     *
     * @param root 根节点
     */
    public static void preTraverse(TreeNode root) {
        if (root != null) {
            preTraverse(root.left);
            System.out.print(root.val);
            preTraverse(root.right);
        }
    }

    /**
     * 中序遍历
     *
     * @param root 根节点
     */
    public static void inTraverse(TreeNode root) {
        if (root != null) {
            System.out.print(root.val);
            inTraverse(root.left);
            inTraverse(root.right);
        }
    }

    /**
     * 后序遍历
     *
     * @param root 根节点
     */
    public static void postTraverse(TreeNode root) {
        if (root != null) {
            postTraverse(root.left);
            postTraverse(root.right);
            System.out.print(root.val);
        }
    }
  
    /**
     * 层次遍历
     * 基于队列的思想，实现父节点出队的时候，对应孩子节点同步入队
     * @param root 根节点
     */
    public static void levelTraverse(TreeNode root) {
        if (root != null) {
            LinkedList<TreeNode> queue = new LinkedList<>();
            TreeNode current;
            queue.offer(root);
            while (!queue.isEmpty()) {
                //  依次出队
                current = queue.poll();
                System.out.print(current.val);
                /*
                 将被出队的元素的孩子节点入队
                 */
                if (current.left != null) {
                    queue.offer(current.left);
                }
                if (current.right != null) {
                    queue.offer(current.right);
                }
            }
        }
    }

    public static void main(String[] args) {
        Q623 q623 = new Q623();
        int[] nums = new int[]{1, 2, 4, 0, 0, 0, 3, 0, 0};
        TreeNode root = q623.createTreeNode(new TreeNode(), nums, counter);
        System.out.print("中序遍历");
        inTraverse(root);

        System.out.print("\n先序遍历");
        preTraverse(root);

        System.out.print("\n后序遍历");
        postTraverse(root);

        System.out.print("\n层次遍历");
        levelTraverse(root);

    }
}