C#数据结构-赫夫曼树

什么是赫夫曼树？

赫夫曼树(Huffman Tree)是指给定N个权值作为N个叶子结点，构造一棵二叉树，若该树的带权路径长度达到最小。哈夫曼树（也称为最优二叉树）是带权路径长度最短的树，权值较大的结点离根较近。

　　 public class HNode<T>
    {
        public HNode()
        {
            data = default(T);
            weight = 0;
            leftNode = null;
            rightNode = null;
        }

        public HNode(T val)
        {
            data = val;
            weight = 0;
            leftNode = null;
            rightNode = null;
        }

        /// <summary>
        /// 权重
        /// </summary>
        public int weight { get; set; }

        /// <summary>
        /// 内容
        /// </summary>
        public T data { get; set; }

        /// <summary>
        /// 左树
        /// </summary>
        public HNode<T> leftNode { get; set; }

        /// <summary>
        /// 右树
        /// </summary>
        public HNode<T> rightNode { get; set; }
    }

　　 /// <summary>
    /// 赫夫曼树
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class HTree<T>
    {
        /// <summary>
        /// 树的头结点
        /// </summary>
        public HNode<T> head { get; set; }

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="val"></param>
        public HTree(T val)
        {
            head = new HNode<T>(val);
        }

        public HTree()
        {
            head = new HNode<T>();
        }
        /// <summary>
        /// 构建树结构
        /// </summary>
        /// <param name="list"></param>
        public void build(List<T> list)
        {
            //判断是否能构建树结构
            if (list == null || list.Count <2)
                throw new ArgumentOutOfRangeException("params error");
            //分组统计
            List<HNode<T>> nodes = new List<HNode<T>>();
            nodes.AddRange(from m in list group m by m into g 
                           select new HNode<T> { data = g.Key,weight = g.Count()});
            //排序
            nodes = nodes.OrderBy(i => i.weight).ToList();

            for (int i =1; i< nodes.Count; i++)
            {
                HNode<T> parentNode = new HNode<T>();
                if (i == 1)
                {
                    //先取最小的两个节点
                    parentNode.leftNode = nodes[0];
                    parentNode.rightNode = nodes[1];
                    parentNode.weight = nodes[0].weight + nodes[1].weight;
                }
                else
                {
                    //依次取节点构建树
                    if (head.weight >= nodes[i].weight)
                    {
                        parentNode.leftNode = head;
                        parentNode.rightNode = nodes[i];
                    }
                    else
                    {
                        parentNode.rightNode = head;
                        parentNode.leftNode = nodes[i];
                    }
                    parentNode.weight = head.weight + nodes[i].weight;
                }
                head = parentNode;
            }
        }

        /// <summary>
        /// 先序遍历
        /// </summary>
        /// <param name="index"></param>
        public void PreorderTraversal(HNode<T> node)
        {
            //递归的终止条件
            if (head == null)
            {
                Console.WriteLine("当前树为空");
                return;
            }
            if (node != null)
            {
                if(node.data != null)
                Console.WriteLine($"{node.data} {node.weight}");
                PreorderTraversal(node.leftNode);
                PreorderTraversal(node.rightNode);
            }
        }
    }

测试代码：

List<string> list = new List<string>() { "A","B", "B", "C", "C", "C", "D", "D", "D", "D", "E", "E", "E", "E", "E" };
HTree<string> tree = new HTree<string>();
tree.build(list);
tree.PreorderTraversal(tree.head);

打印结果：

A 1
B 2
C 3
D 4
E 5

用这个例子现在我们看下构建的二叉树结构：

---