Likou 二叉树递归实现深度，宽度，前序遍历，中序遍历，后序遍历，层次遍历

package tree;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

/**
 * 功能描述:二叉树的基本功能
 */
class TreeNode {
    Integer val;
    TreeNode left;
    TreeNode right;

    TreeNode(int x) {
        val = x;
    }
}

class Tree {
    /*使用一维数组构造完全二叉树*/
    public static TreeNode creatTree(Integer[] array, int index) {
        TreeNode treeNode = null;
        if (index < array.length && array[index] != null) {
            treeNode = new TreeNode(array[index]);
            treeNode.left = creatTree(array, index * 2 + 1);
            treeNode.right = creatTree(array, index * 2 + 2);
            return treeNode;
        }
        return treeNode;
    }

    /*二叉树的最大深度*/
    public static int getMaxHigh(TreeNode head) {
        if (head == null) {
            return 0;
        }
        int leftHigh = getMaxHigh(head.left);
        int righHigh = getMaxHigh(head.right);
        return Math.max(leftHigh, righHigh) + 1;
    }

    /*二叉树的最小深度：根节点到最近的叶子节点的距离*/
    public static int getMinHigh(TreeNode head) {
        if (head == null) {
            return 0;
        }
        if (head.left == null) {
            return getMinHigh(head.right) + 1;
        }
        if (head.right == null) {
            return getMinHigh(head.left) + 1;
        }
        int leftHigh = getMinHigh(head.left);
        int righHigh = getMinHigh(head.right);
        return Math.min(leftHigh, righHigh) + 1;
    }

    /*二叉树的前序遍历*/
    public static void preOrderTraverse(TreeNode head) {
        if (head != null) {
            System.out.print(head.val + " ");
            preOrderTraverse(head.left);
            preOrderTraverse(head.right);
        }
    }

    /*二叉树的中序遍历*/
    public static void midOrderTraverse(TreeNode head) {
        if (head != null) {
            midOrderTraverse(head.left);
            System.out.print(head.val + " ");
            midOrderTraverse(head.right);
        }
    }

    /*二叉树的后序遍历*/
    public static void postOrderTraverse(TreeNode head) {
        if (head != null) {
            postOrderTraverse(head.left);
            postOrderTraverse(head.right);
            System.out.print(head.val + " ");
        }
    }

    /*二叉树的层次遍历*/
    public static void levelOrderTraverse(TreeNode head) {
        if (head != null) {
            Queue<TreeNode> queue = new LinkedList<>();
            queue.add(head);
            while (!queue.isEmpty()) {
                TreeNode currentNode = queue.poll();
                System.out.print(currentNode.val + " ");
                if (currentNode.left != null) {
                    queue.add(currentNode.left);
                }
                if (currentNode.right != null) {
                    queue.add(currentNode.right);
                }
            }

        }
    }

    /*二叉树的层次遍历:分层次的输出*/
    public static List<List<Integer>> levelOrderTraverse_2(TreeNode head) {
        List<List<Integer>> result = new ArrayList<>();
        if (head == null) {
            return result;
        }

        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(head);

        while (!queue.isEmpty()) {
            List<Integer> temp = new ArrayList<>();
            int queueSize = queue.size();
            for (int i = 0; i < queueSize; i++) {
                TreeNode currentNode = queue.poll();
                temp.add(currentNode.val);
                if (currentNode.left != null) {
                    queue.add(currentNode.left);
                }
                if (currentNode.right != null) {
                    queue.add(currentNode.right);
                }
            }
            result.add(temp);
            //result.add(0, temp); //如果每次add的時候，add到 index 为0 的地方可以实现自下而上的输出
        }
        return result;
    }

    /*二叉树的层次遍历: 二叉树的层平均值*/
    public static List<Double> averageOfLevels(TreeNode head) {
        List<Double> result = new ArrayList<>();
        if (head == null) {
            return result;
        }

        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(head);

        while (!queue.isEmpty()) {
            List<Integer> temp = new ArrayList<>();
            double sum = 0.0d;
            int queueSize = queue.size();
            for (int i = 0; i < queueSize; i++) {
                TreeNode currentNode = queue.poll();
                temp.add(currentNode.val);
                sum += currentNode.val;
                if (currentNode.left != null) {
                    queue.add(currentNode.left);
                }
                if (currentNode.right != null) {
                    queue.add(currentNode.right);
                }
            }
            result.add(sum / queueSize);
        }
        return result;
    }

    /*二叉树的最大宽度*/
    public static int getMaxWidth(TreeNode head) {
        if (head == null) {
            return 0;
        }

        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(head);
        int maxWidth = 0;
        while (!queue.isEmpty()) {
            int queueSize = queue.size();
            for (int i = 0; i < queueSize; i++) {
                TreeNode currentNode = queue.poll();
                if (currentNode.left != null) {
                    queue.add(currentNode.left);
                }
                if (currentNode.right != null) {
                    queue.add(currentNode.right);
                }
            }
            maxWidth = Math.max(maxWidth, queueSize);
        }
        return maxWidth;
    }

    /*二叉树的叶子节点*/
    public static void main(String[] args) {

        Integer[] array = new Integer[]{1, 2, 3, 4, null, null, 5, null, 6, null, null, null, null, 7, null};
        TreeNode head = creatTree(array, 0);
        int maxHigh = getMaxHigh(head);
        System.out.println("二叉树的最大深度：" + maxHigh);

        int minHigh = getMinHigh(head);
        System.out.println("二叉树的最小深度：" + minHigh);

        System.out.println("二叉树的前序遍历");
        preOrderTraverse(head);

        System.out.println("\n二叉树的中序遍历");
        midOrderTraverse(head);

        System.out.println("\n二叉树的后序遍历");
        postOrderTraverse(head);

        System.out.println("\n二叉树的层次遍历");
        levelOrderTraverse(head);

        System.out.println("\n二叉树的层次遍历,分层次的输出");
        List<List<Integer>> result = levelOrderTraverse_2(head);
        System.out.println(result.toString());

        int maxWidth = getMaxWidth(head);
        System.out.println("二叉树的最大深度：" + maxWidth);
    }
}