二叉树应用之哈夫曼树

  哈夫曼树又叫最优二叉树，指具有一组特定权值的叶子节点的具有最小带权路径长度的二叉树。

  实现代码如下：

 

  1using System;
  2using System.Collections.Generic;
  3using System.Text;
  4
  5namespace 哈夫曼树
  6{
  7    class Program
  8    {
  9        public class Node
 10        { 
 11            //节点权值
 12            private int weight;
 13            //左孩子
 14            private int lChild;
 15            //右孩子
 16            private int rChild;
 17            //父结点
 18            private int parent;
 19            //节点权值属性
 20            public int Weight
 21            {
 22                get
 23                {
 24                    return weight;
 25                }
 26                set
 27                {
 28                    weight = value;
 29                }
 30            }
 31            //左孩子节点属性
 32            public int LChild
 33            {
 34                get
 35                {
 36                    return lChild;
 37                }
 38                set
 39                {
 40                    lChild = value;
 41                }
 42            }
 43            //右孩子节点属性
 44            public int RChild
 45            {
 46                get
 47                {
 48                    return rChild;
 49                }
 50                set
 51                {
 52                    rChild = value;
 53                }
 54            }
 55            //父节点属性
 56            public int Parent
 57            {
 58                get
 59                {
 60                    return parent;
 61                }
 62                set
 63                {
 64                    parent = value;
 65                }
 66            }
 67
 68            //构造函数
 69            public Node()
 70            {
 71                weight = 0;
 72                lChild = -1;
 73                rChild = -1;
 74                parent = -1;
 75            }
 76            //构造函数
 77            public Node(int w, int l, int r, int p)
 78            {
 79                weight = w;
 80                lChild = l;
 81                rChild = r;
 82                parent = p;
 83            }
 84            
 85        }
 86        //哈夫曼树类
 87        public class HaffmanTree
 88        {
 89            //节点数目
 90            private Node[] data;
 91            //叶子节点数目
 92            private int leafNum;
 93            //索引器
 94            public Node this[int index]
 95            {
 96                get
 97                {
 98                    return data[index];
 99                }
                set
                {
                    data[index] = value;
                }
            }
            //叶子节点数目属性
            public int LeafNum
            {
                get
                {
                    return leafNum;
                }
                set
                {
                    leafNum = value;
                }
            }
            //构造函数
            public HaffmanTree(int n)
            {
                data = new Node[2 * n - 1];
                leafNum = n;
            }
            //创建哈夫曼树
            public void CreateTree()
            {
                int max1, max2, tmp1, tmp2;
                //输入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[j].Weight < max1) && (data[i].Parent == -1))
                        {
                            max2 = max1;
                            tmp2 = tmp1;
                            tmp1 = j;
                            max1 = data[j].Weight;
                        }
                        else if ((data[j].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;
                    Console.WriteLine(data[this.leafNum + i].LChild);
                    data[this.leafNum + i].RChild = tmp2;
                    Console.WriteLine(data[this.leafNum + i].RChild);

                }
            }
        }
        static void Main(string[] args)
        {

            HaffmanTree haffman = new HaffmanTree(5);
            haffman.CreateTree();
        }
    }
}