哈夫曼树类的构造 (C#实现)

       由哈夫曼树的构造算法可知，用一个数组存放原来的 n 个叶子结点和构造过程中临时生成的结点，数组的大小为 2n-1。所以，哈夫曼树类 HuffmanTree 中有两个成员字段： data数组用于存放结点， leafNum表示哈夫曼树叶子结点的数目。结点有四个域，一个域 weight，用于存放该结点的权值；一个域 lChild，用于存放该结点的左孩子结点在数组中的序号；一个域rChild，用于存放该结点的右孩
子结点在数组中的序号；一个域 parent， 用于判定该结点是否已加入哈夫曼树中。哈夫曼树结点的结构为。 

                                  | weight | Child |rChild |parent |
所以，结点类 Node 有 4 个成员字段，weight 表示该结点的权值，lChild 和
rChild 分别表示左、右孩子结点在数组中的序号，parent 表示该结点是否已加入
哈夫曼树中，如果 parent 的值为-1，表示该结点未加入到哈夫曼树中。当该结点
已加入到哈夫曼树中时，parent 的值为其双亲结点在数组中的序号。
weight     Child      rChild      parent

结点类 Node 的定义如下：
public class Node
{
    private int weight;    //结点权值
    private int lChild;    //左孩子结点
    private int rChild;    //右孩子结点
    private int parent;    //父结点
 
    //结点权值属性
    public int Weight
    {
         get
         {
             return weight;
}
set
{
    weight = value;
}
}
 
//左孩子结点属性
public int LChild
    {
         get
         {
             return lChild;
}
set
{
    lChild = value;
}
}
 
//右孩子结点属性
public int RChild
    {
         get
         {
             return rChild;
}
set
{
    rChild = value;
}
}
 
//父结点属性
public int Parent
    {
         get
         {
             return parent;
}
set
{
    parent = value;
}
}
 
//构造器
public Node()
{
    weight = 0;
    lChild = -1;
    rChild = -1;
    parent = -1;
}
 
//构造器
public Node(int w, int lc, int rc, int p)
{
    weight = w;
     lChild = lc;
     rChild = rc;
     parent = p;
}
}
哈夫曼树类 HuffmanTree中只有一个成员方法Create，它的功能是输入n 个
叶子结点的权值，创建一棵哈夫曼树。哈夫曼树类HuffmanTree 的实现如下。
public class HuffmanTree
{
    private Node[] data;    //结点数组
    private int leafNum;    //叶子结点数目
 
    //索引器
    public Node this[int index]
    { 
                                                                           

        get
         {
             return data[index];
}
set
{
    data[index] = value;
}
}
 
//叶子结点数目属性
public int LeafNum
    {
        get
         {
             return leafNum;
}
set
{
    leafNum = value;
}
}
 
//构造器
public HuffmanTree (int n)
{
    data = new Node[2*n-1];
leafNum = n;
}
 
//创建哈夫曼树
public void Create()
{
    int m1;
    int m2;
    int x1;
    int x2;
 
    //输入n 个叶子结点的权值
             for (int i = 0; i < this.leafNum; ++i)
            {
data[i].Weight = Console.Read();
    } 
                                                                             
    //处理n个叶子结点，建立哈夫曼树
            for (int i = 0; i < this.leafNum - 1; ++i)
            {
                max1 = max2 = Int32.MaxValue;
                tmp1 = tmp2 = 0;
 
                //在全部结点中找权值最小的两个结点
                for (int j = 0; j < this.leafNum + i; ++j)
                {
                    if ((data[i].Weight < max1) 
&& (data[i].Parent == -1))
                    {
                        max2 = max1;
                        tmp2 = tmp1;
                        tmp1 = j;
                        max1 = data[j].Weight;
                    }
                    else if ((data[i].Weight < max2) 
&& (data[i].Parent == -1))
                    {
                        max2 = data[j].Weight;
                        tmp2 = j;
                    }
                }
 
                data[tmp1].Parent = this.leafNum + i;
                data[this.leafNum + i].Weight = data[tmp1].Weight 
+ data[tmp2].Weight;
                data[this.leafNum + i].LChild = tmp1;
                data[this.leafNum + i].RChild = tmp2;
    }
}
}