平衡二叉树--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级

   

  提交代码，通过。