C#最优二叉树----哈夫曼树

哈夫曼树定义：对一组带有确定权值的叶结点，构造的具有最小带权路径长度的二叉树。
权值：相当于在这个结点所需要待的时间，即到达这个结点所需要花费的代价。
带权路径长度：某一个结点权值为k。路径长度为w。带权路径长度就是k*w。
树的带权路径长度：从根结点到各个叶结点的路径长度与相应叶结点的权值相乘再进行相加得到树的带权路径长度。
哈夫曼树的构造算法和创建：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Tree
{
    
    class HNode
    {
    
        private int weight;
        private int leftChild;
        private int rightChild;
        private int parent;
        public int Weight
        {
    
            get
            {
    
                return weight;
            }
            set
            {
    
                weight = value;
            }
        }
        public int LeftChild
        {
    
            get
            {
    
                return leftChild;
            }
            set
            {
    
                leftChild = value;
            }
        }
        public int RightChild
        {
    
            get
            {
    
                return rightChild;
            }
            set
            {
    
                rightChild = value;
            }
        }
        public int Parent
        {
    
            get
            {
    
                return parent;
            }
            set
            {
    
                parent = value;
            }
        }
        public HNode()
        {
    
            parent = -1;
            weight = 0;
            leftChild = -1;
            rightChild = -1;
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Tree
{
    
    class HuffmanTree
    {
    
        private HNode[] data;
        private int leafNum;
        public HNode 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 HNode[2 * n - 1];
            for (int i = 0; i < 2*n-1; i++)
            {
    
                data[i] = new HNode();
            }
            leafNum = n;
        }
        public void Create()
        {
    
            int m1, m2, x1, x2;
            //输入n个叶子结点的权值
            for (int i = 0; i < this.leafNum; i++)
            {
    
                Console.WriteLine("请输入第{0}个叶子结点的权值：",i+1);
                data[i].Weight = Convert.ToInt32(Console.ReadLine());
            }
            //处理n个叶子结点，建立哈夫曼树
            for (int i = 0; i < this.leafNum-1; i++)
            {
    
                m1 = m2 = Int32.MaxValue;
                x1 = x2 = 0;
                //在全部结点中找权值最小的两个结点
                for (int j = 0; j < this.leafNum + i; j++)
                {
    
                    if (data[j].Weight < m1 && data[j].Parent == -1)
                    {
    
                        m2 = m1;
                        x2 = x1;
                        m1 = data[j].Weight;
                        x1 = j;
                    }
                    else if (data[j].Weight < m2 && data[j].Parent == -1)
                    {
    
                        m2 = data[j].Weight;
                        x2 = j;
                    }
                }
                data[x1].Parent = this.leafNum + i;
                data[x2].Parent = this.leafNum + i;
                data[this.leafNum + i].Weight = data[x1].Weight + data[x2].Weight;
                data[this.leafNum + i].LeftChild = x1;
                data[this.leafNum + i].RightChild = x2;
            }
        }
    }
}