平衡二叉树的生成、遍历及计算

输入节点个数N及对应的数值（如节点个数： 9，其节点值分别为： 25 16 30 -5 20 28 42 20 35），生成二叉树，先序遍历，计算最后二层节点总数。

实现：

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import com.alibaba.fastjson.JSON;

/**
 * @Type BinaryTreeTest.java
 * @Desc 
 * @author Z.R.L
 * @date 2020年6月10日 上午10:37:49
 * @version 
 */
public class BinaryTreeTest {

    public static void main(String[] args) {
        // 输入1 -> 节点个数： 9
        // 输入2 -> 节点值： 25 16 30 -5 20 28 42 20 35
        Scanner in = new Scanner(System.in);
        in.useDelimiter("\r\n");
        // count实际不需要，根据输入的节点值即可算出节点个数
        int count = Integer.parseInt(in.nextLine());
        String numbersString = in.nextLine();
        in.close();
        List<Integer> numList = new ArrayList<Integer>();
        for (String num : numbersString.split(" ")) {
            numList.add(Integer.parseInt(num));
        }
        System.out.println("节点数：" + count);
        System.out.println("节点：" + numList);

        TreeNode treeNode = new TreeNode();
        genBinaryTree(numList, treeNode);
        System.out.println("树结构：" + JSON.toJSONString(treeNode));

        int maxDepth = preOrder(treeNode);
        System.out.println("最大深度：" + maxDepth);
        
        int last2LevelDatas = countLast2LevelDatas(treeNode, maxDepth);
        System.out.println("最后两层节点总数：" + last2LevelDatas);
    }

    /**
     * 生成二叉树
     * @param numList
     * @param treeNode
     */
    private static void genBinaryTree(List<Integer> numList, TreeNode treeNode) {
        int index = 0;
        for (Integer num : numList) {
            if (index == 0) {
                addRoot(num, treeNode);
            } else {
                compareAndAddNode(treeNode, num);
            }
            index++;
        }
    }

    /**
     * 二叉树中添加节点
     * @param treeNode
     * @param num
     */
    private static void compareAndAddNode(TreeNode treeNode, int num) {
        if (num <= treeNode.getRoot() && treeNode.getLeft() == null) {
            addLeft(num, treeNode);
            return;
        }
        if (num > treeNode.getRoot() && treeNode.getRight() == null) {
            addRight(num, treeNode);
            return;
        }
        // 递归比较
        if (num <= treeNode.getRoot()) {
            compareAndAddNode(treeNode.getLeft(), num);
        } else {
            compareAndAddNode(treeNode.getRight(), num);
        }

    }

    /**
     * 添加左节点
     * @param data
     * @param parent
     */
    private static void addLeft(int data, TreeNode parent) {
        TreeNode left = new TreeNode();
        left.setRoot(data);
        left.setDepth(parent.getDepth() + 1);
        left.setParent(parent);
        parent.setLeft(left);
    }

    /**
     * 添加右节点
     * @param data
     * @param parent
     */
    private static void addRight(int data, TreeNode parent) {
        TreeNode right = new TreeNode();
        right.setRoot(data);
        right.setDepth(parent.getDepth() + 1);
        right.setParent(parent);
        parent.setRight(right);
    }

    /**
     * 添加根节点
     * @param data
     * @param treeNode
     */
    private static void addRoot(int data, TreeNode treeNode) {
        treeNode.setRoot(data);
        treeNode.setDepth(1);
    }

    private static int maxDepth = 0;
    private static int last2LevelDatas = 0;
    
    /**
     * 先序遍历递归算法
     * @param treeNode
     */
    private static int preOrder(TreeNode treeNode) {
        if (treeNode == null) {
            return maxDepth;
        }
        System.out.println("[遍历] 节点值:" + treeNode.getRoot() + ",深度：" + treeNode.getDepth());
        if (maxDepth < treeNode.getDepth()) {
            maxDepth = treeNode.getDepth();
        }
        preOrder(treeNode.getLeft());
        preOrder(treeNode.getRight());
        return maxDepth;
    }
    
    /**
     * 计算最后2层节点数
     * @param treeNode
     */
    private static int countLast2LevelDatas(TreeNode treeNode, int maxDepth) {
        if (treeNode == null) {
            return last2LevelDatas;
        }
        if (maxDepth - treeNode.getDepth() < 2) {
            last2LevelDatas++;
        }
        countLast2LevelDatas(treeNode.getLeft(), maxDepth);
        countLast2LevelDatas(treeNode.getRight(), maxDepth);
        return last2LevelDatas;
    }
    
    /**
     * 二叉树实体类
     */
    static class TreeNode {
        // 父节点
        TreeNode parent;
        // 左节点
        TreeNode left;
        // 右节点
        TreeNode right;
        // 根节点值
        int root;
        // 当前深度
        int depth;
        int tmpMaxDepth;

        public int getTmpMaxDepth() {
            return tmpMaxDepth;
        }

        public void setTmpMaxDepth(int tmpMaxDepth) {
            this.tmpMaxDepth = tmpMaxDepth;
        }

        public TreeNode getParent() {
            return parent;
        }

        public void setParent(TreeNode parent) {
            this.parent = parent;
        }

        public int getDepth() {
            return depth;
        }

        public void setDepth(int depth) {
            this.depth = depth;
        }

        public TreeNode getLeft() {
            return left;
        }

        public void setLeft(TreeNode left) {
            this.left = left;
        }

        public TreeNode getRight() {
            return right;
        }

        public void setRight(TreeNode right) {
            this.right = right;
        }

        public int getRoot() {
            return root;
        }

        public void setRoot(int root) {
            this.root = root;
        }
    }
    
}

运行结果：

【输入】

9
25 16 30 -5 20 28 42 20 35

【输出】节点数：9
节点：[25, 16, 30, -5, 20, 28, 42, 20, 35]
树结构：{"depth":1,"left":{"depth":2,"left":{"depth":3,"parent":{"$ref":".."},"root":-5,"tmpMaxDepth":0},"parent":{"$ref":".."},"right":{"depth":3,"left":{"depth":4,"parent":{"$ref":".."},"root":20,"tmpMaxDepth":0},"parent":{"$ref":".."},"root":20,"tmpMaxDepth":0},"root":16,"tmpMaxDepth":0},"right":{"depth":2,"left":{"depth":3,"parent":{"$ref":".."},"root":28,"tmpMaxDepth":0},"parent":{"$ref":".."},"right":{"depth":3,"left":{"depth":4,"parent":{"$ref":".."},"root":35,"tmpMaxDepth":0},"parent":{"$ref":".."},"root":42,"tmpMaxDepth":0},"root":30,"tmpMaxDepth":0},"root":25,"tmpMaxDepth":0}
[遍历] 节点值:25,深度：1
[遍历] 节点值:16,深度：2
[遍历] 节点值:-5,深度：3
[遍历] 节点值:20,深度：3
[遍历] 节点值:20,深度：4
[遍历] 节点值:30,深度：2
[遍历] 节点值:28,深度：3
[遍历] 节点值:42,深度：3
[遍历] 节点值:35,深度：4
最大深度：4
最后两层节点总数：6

 

二叉树示意图：