求二叉树中第K层结点的个数

一，问题描述

构建一棵二叉树（不一定是二叉查找树），求出该二叉树中第K层中的结点个数（根结点为第0层）

二，二叉树的构建

定义一个BinaryTree类来表示二叉树，二叉树BinaryTree 又是由各个结点组成的，因此需要定义一个结点类BinaryNode，BinaryNode作为BinaryTree的内部类。

此外，在BinaryTree中需要一定一个BinaryNode属性来表示树的根结点。

public class BinaryTree<T extends Comparable<? super T>> {
    
    private static class BinaryNode<T>{
        T element;
        BinaryNode<T> left;
        BinaryNode<T> right;
        
        public BinaryNode(T element) {
            this.element = element;
            left = right = null;
        }
    
        public BinaryNode(T element, BinaryNode<T> left, BinaryNode<T> right){
            this.element = element;
            this.left = left;
            this.right = right;
        }
    }
    
    private BinaryNode<T> root;

//other code.....

第一行是二叉树类的定义，第三行是结点类的定义，第20行是二叉树根的定义。

三，求解第K层结点个数的算法实现

感觉对二叉树中的许多操作都可以用递归来实现。因此，二叉树是理解递归一个好实例。比如，二叉树的操作之统计二叉树中节点的个数 和 二叉树的先序遍历和后序遍历的应用--输出文件和统计目录大小

求第K层结点的个数也可以用递归来实现：

①若二叉树为空或者K小于0，返回0

②若K等于0，第0层就是树根，根只有一个，返回1

③若K大于0，返回左子树中第K-1层结点个数 加上 右子树中第K-1层结点的个数

因为，第K层结点，相对于根的左子树 和 右子树 而言，就是第K-1层结点

其实，这是有改进的地方：对于K<0的情形，准确地说：它只是一个非法输入，而不是递归的结束条件(基准条件)。可以看出，①不要把非法输入与递归的基准条件混淆，②把非法输入的判断放到递归中判断的开销是很大的。因为每进行一次递归就需要进行一次非法输入判断。而如果在开始就把非法输入过滤掉，在递归过程中就不会存在每一次递归就判断一次非法输入了。

递归的基准条件只有两个：

1) k==0 当递归到K==0时，说明：第K层是有结点的

2) root==null  当递归到root==null时，说明：第K层没有结点

因此，可以进一步将代码改进如下：这样，不需要在每次递归的过程中还可能附加一次 k<0 的判断

    /**
     * 
     * @param k
     * @return 二叉树中第K层结点的个数(根位于第0层)
     */
    public int k_nodes(int k){
        if(k < 0)
            return 0;
        return k_nodes(root, k);
    }
    private int k_nodes(BinaryNode<T> root, int k){
        if(root == null)
            return 0;
        if(k == 0)
            return 1;//根结点
        else
            return k_nodes(root.left, k-1) + k_nodes(root.right, k-1);
    }

可参考：按层打印二叉树--每行打印一层 来测试每一层是否有正确的结点个数。

四，代码实现

public class BinaryTree<T extends Comparable<? super T>> {
    
    private static class BinaryNode<T>{
        T element;
        BinaryNode<T> left;
        BinaryNode<T> right;
        
        public BinaryNode(T element) {
            this.element = element;
            left = right = null;
        }
    }
    
    private BinaryNode<T> root;
    
    /**
     * 向二叉树中插入一个元素
     * @param element
     */
    public void insert(T element){
        root = insert(root, element);
    }
    private BinaryNode<T> insert(BinaryNode<T> root, T element){
        if(root == null)
            return new BinaryNode<T>(element);
        int r = (int)(2*Math.random());
        //随机地将元素插入到左子树 或者 右子树中
        if(r==0)
            root.left = insert(root.left, element);
        else
            root.right = insert(root.right, element);
        return root;
    }
    
    /**
     * 
     * @param k
     * @return 二叉树中第K层结点的个数(根位于第0层)
     */
    public int k_nodes(int k){
        return k_nodes(root, k);
    }
    private int k_nodes(BinaryNode<T> root, int k){
        if(root == null || k < 0)
            return 0;
        if(k == 0)
            return 1;//根结点
        else
            return k_nodes(root.left, k-1) + k_nodes(root.right, k-1);
    }
    
    public static void main(String[] args) {
        BinaryTree<Integer> tree = new BinaryTree<>();
        
        int[] ele = C2_2_8.algorithm1(4);//构造一个随机数组,数组元素的范围为[1,4]
        for (int i = 0; i < ele.length; i++) {
            tree.insert(ele[i]);
        }
        
        int k_nodes = tree.k_nodes(2);//第二层
        int k_nodes2 = tree.k_nodes(-1);//第-1层
        int k_nodes3 = tree.k_nodes(0);
        int k_nodes4 = tree.k_nodes(1);
        int k_nodes5 = tree.k_nodes(4);//若超过了树的高度,结果为0
        System.out.println(k_nodes);
        System.out.println(k_nodes2);
        System.out.println(k_nodes3);
        System.out.println(k_nodes4);
        System.out.println(k_nodes5);
    }
}

关于 C2_2_8类，参考：随机序列生成算法---生成前N个整数的一组随机序列

五，参考资料

http://blog.csdn.net/luckyxiaoqiang/article/details/7518888