数据结构与算法|深度&广度优先遍历算法简单示例

数据结构与算法|深度&广度优先遍历算法简单示例

package com.example.order00.datastructure;

import java.util.Arrays;
import java.util.LinkedList;
import java.util.Queue;

/**
 * description:
 * <p>
 * 树的遍历
 * </p>
 *
 * @author : dzx
 * Date : 2019/10/21 18:25
 */
public class TreeForEach {

    /**
     * 构建二叉树
     *
     * @param inputList 输入序列
     */
    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.rightChild = createBinaryTree(inputList);

        }
        return node;

    }

    /**
     * 二叉树前序遍历
     *
     * @param node 二叉树节点
     */

    public static void preOrderTraveral(TreeNode node) {
        if (node == null) {
            return;

        }
        System.out.println(node.data);
        preOrderTraveral(node.leftChild);
        preOrderTraveral(node.rightChild);

    }

    /**
     * 二叉树中序遍历
     * param node 二叉树节点
     */

    public static void inOrderTraveral(TreeNode node) {
        if (node == null) {
            return;

        }
        inOrderTraveral(node.leftChild);
        System.out.println(node.data);
        inOrderTraveral(node.rightChild);

    }

    /**
     * 二叉树后序遍历 48. * @param node 二叉树节点
     */

    public static void postOrderTraveral(TreeNode node) {
        if (node == null) {
            return;

        }
        postOrderTraveral(node.leftChild);
        postOrderTraveral(node.rightChild);
        System.out.println(node.data);

    }

    /**
     * 二叉树节点
     */
    private static class TreeNode {
        int data;
        TreeNode leftChild;
        TreeNode rightChild;

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

        }
    }

    /**
     * 二叉树层序遍历
     *
     * @param root 二叉树根节点
     */
    public static void levelOrderTraversal(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);
            }
            if (node.rightChild != null) {
                queue.offer(node.rightChild);
            }
        }
    }


    /**
     * 测试main方法
     *
     * @param args
     */
    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);
        //构建的树为(前序遍历)
        /*
                           3
                         /   \
                        2     8
                       / \   / \
                      9  10 n   4
                     /\  /\
                    n n n  n
         */
        System.out.println(" 前序遍历：");
        preOrderTraveral(treeNode);
        System.out.println(" 中序遍历：");
        inOrderTraveral(treeNode);
        System.out.println(" 后序遍历：");
        postOrderTraveral(treeNode);

    }
}