平衡二叉树--c#求解--英雄会在线编程题目

      这几天写了写了几道题，觉得这道平衡二叉树的题有点意思，就把他的c#算法写出来，不足之处请大家指点。

先看题目：

平衡二叉树

难 度 等 级：

题目详情

平衡二叉树的定义是递归定义的：

（1） 单个节点是平衡二叉树

（2）平衡二叉树的左右子树分别都是平衡二叉树

（3）平衡二叉树的左右子树高度差不超过1。

求n个节点有m个叶子节点的平衡二叉树个数 (0<m <= n<=20)。

例如：

n = 1，m = 1，输出：1；

n = 2，m = 1，输出：2；

n = 2，m = 2，输出：0。

 

 

分析：

1、看完这题，从n=2,m=1，有两种结果，说明，这道题要考虑左右树交换位置，即假设找到一个满足条件的平衡二叉树，左右子树交换位置，也可能得到一个答案。

2、二叉树的一般原理可以得到，n=左右子树的节点和+1

3、同理可以得到：m=左右子树的叶子数和

4、每一个层级的最少节点数=左右子树最少节点数之和（n>1)

这一点什么意思呢？

举例来说吧，一个节点，层级是1,，也只能是1,。

对于2个层级的平衡树，如果要满足条件，最少需要2个节点，1个叶子，最多3个节点，2个叶子

对于3个层级的平衡树，如果要满足条件：

      最少节点=2级的最少节点数+1级的最少节点数+1

     最少叶子=2级的最少叶子数+1级的最少叶子数

     最多节点=2级的最多节点数*2+1

     最多叶子=2级的最多叶子数*2

 

有了这个推理过程，我们很容易得到x级的平衡树的最少节点数、叶子数，最多节点数、叶子数

为什么要得到这个推论和结果呢?因为给我们的是节点数和叶子数，所以我们要知道这样的条件能够生成多少级别的平衡二叉树

 

思路：

通过上面的分析，我们就可以将问题转换为，对于n,m可以在层级为x的平衡二叉树上有多少种方案，

当x>2时，可以将x降级为左右树的可能出现情况，这样就能得到结果=left*right

 

1、首先构造这个最大、最小节点叶子数的字典，当然，临时求出来也行，反正规律已经分析出来的：

static Dictionary<int, List<int>> dic;

dic = new Dictionary<int, List<int>>();

for (int i = 1; i <= 6; i++)
            {
                List<int> list = new List<int>();
                if (i == 1)
                {
                    list.Add(1);
                    list.Add(1);
                    list.Add(1);
                    list.Add(1);
                }
                if (i == 2)
                {
                    list.Add(2);
                    list.Add(1);
                    list.Add(3);
                    list.Add(2);
                }
                if (i > 2)
                {
                    list.Add(dic[i - 1][0] + dic[i - 2][0]+1);
                    list.Add(dic[i - 1][1] + dic[i - 2][1] );
                    list.Add(dic[i - 1][2]*2 +1);
                    list.Add(dic[i - 1][3] * 2 );
                }
                dic.Add(i, list);
            }

这里自己定义list[0]表示最少节点数，依次向后表示最少叶子数，最大节点数，最大叶子数

 

2、构造了范围集字典，下一步创建结果集字典

因为3级的结果={左1级*右边2级+左边2级*右边1级+左边2级*右边2级）的结果和

所以，我们先将1级和2级的结果得到：

TreeResult.Add("1,1,1", 1);
TreeResult.Add("2,2,1", 2);
TreeResult.Add("2,3,2", 1);

我们还是自定义数据结构，key表示：层级，节点个数，叶子个数，value表示这样的平衡树有几种情况

因此我们可以这样构造一个递归函数：

public static int cal(int n,int m,int level)
        {
            int result = 0;
            string key = "";
            key = level.ToString() + "," + n.ToString() + "," + m.ToString();
            string tmpkey="";
            if (TreeResult.ContainsKey(key))
            {
                return TreeResult[key];
            }
            if (level < 3)
            {
                TreeResult.Add(key, 0);
                return 0;
            }
            int left = 0;
            int right = 0;
            int rightnode = 0;
            int rightleaf = 0;
            int count =0;

            if (m > dic[level][3] || m < dic[level][1])
            {
                TreeResult.Add(key, 0);
                return 0;
            }
            for (int i = level - 2; i <= level - 1; i++)
            {
                for (int j = level - 2; j <= level - 1; j++)
                {
                    if (i != level - 1 && j != level - 1)
                    {
                        continue;
                    }
                    for (int leftnode = dic[i][0]; leftnode <= dic[i][2]; leftnode++)
                    {
                        if (leftnode > n - 1)
                        {
                            break;
                        }
                        rightnode = n - 1 - leftnode;
                        for (int leftleaf = dic[i][1]; leftleaf <= dic[i][3]; leftleaf++)
                        {
                            if (leftleaf > m)
                            {
                                break;
                            }
                            rightleaf = m - leftleaf;
                            if (rightleaf <= 0)
                            {
                                break;
                            }
                            tmpkey=i.ToString() + "," + leftnode.ToString() + "," + leftleaf.ToString();
                            if (!TreeResult.ContainsKey(tmpkey))
                            {
                               
                                left = cal(leftnode, leftleaf, i);
                                if (!TreeResult.ContainsKey(tmpkey))
                                {
                                    TreeResult.Add(tmpkey, left);
                                }
                            }
                            else
                            {
                                left = TreeResult[tmpkey];
                            }

                            tmpkey = j.ToString() + "," + rightnode.ToString() + "," + rightleaf.ToString();
                            if (!TreeResult.ContainsKey(tmpkey))
                            {
                                right = cal(rightnode, rightleaf, j);
                                if (!TreeResult.ContainsKey(tmpkey))
                                {
                                    TreeResult.Add(tmpkey, right);
                                }
                            }
                            else
                            {
                                right = TreeResult[tmpkey];
                            }
                            count += left * right;
                        }
                    }
                }
            }

            if (!TreeResult.ContainsKey(key))
            {
                TreeResult.Add(key, count );
            }
            result = count;
            return result;
        }

表示对于n个节点，m个叶子，在level层级下有多少种符合条件的平衡二叉树

在level层级降级过程，还需要考虑n，m如何分配给左右子树各多少个，由于有了前面的范围集合字典，我们可以遍历范围内的节点和叶子个数，超出范围的表示不可能出现，直接返回0

 

ok，大功告成，当输入n，我们首先判断有n个节点的平衡二叉树可能出现在哪些层级范围内，然后调用cal函数就可以了，累加得到结果。

由于题目说了n<=20，所以在前面，我们的字典只构造了6级

 

提交代码，通过。