赫夫曼树相关概念

一.基本介绍

1.给定n个权值作为n个叶子节点，构造一棵二叉树，若该树的带权路径长度(wpl)达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树(Huffman Tree)，还有的书翻译为霍夫曼树

2.赫夫曼树是带权路径长度最短的树，权值较大的节点离根较近

---

二.相关概念

1.路径：在一棵树中，从一个节点往下可以达到孩子或孙子节点之间的通路，称为路径。

2.路径长度：通路中分支的数目称为路径长度。若规定根节点的层数为1，则从根节点到第L层节点的路径长度为L-1，即减去根节点的层数

3.节点的权：若将树种的节点赋给一个有着某种含义的数字，则这个数值称为该节点的权

4.带权路径长度：从根节点到该节点之间的路径长度与该节点的权的乘积

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-m0M3prmC-1638013425728)(./img/concept/带权路径长度实例.png)]

以该树为例：13为左子树的最左子节点，该节点的权为13，从根节点到13的通道称为到该节点的路径，假设根节点的层数为0，则根节点到该节点的路径长度为2-0即为2，则它的带权路径长度为2*13=26

---

5.树的带权路径长度：树的带权路径长度规定为所有叶子节点的带权路径长度之和，记为WPL(Weighted Path Length)，权值越大的节点离根节点越近的二叉树才是最优二叉树(根据权值判断，权值越小，越优，如果权值越大的值离根节点越近，那么它的带权路径长度就会小)

举例图示：()

①.1

由图可知，所有的叶子节点都在第二层，则该树的带权路径长度为：13*2+7*2+8*2+3*2=62

---

②.

由图可知：该树共有4层，第一层13，第二层8，第三层7，3，则该树的带权路径长度为：13*1+8*2+7*3+3*3=59

---

③.

由图可知：该树共有4层，第一层7，第二层3，第三层8、13，则该树的带权路径长度为：7*1+3*2+8*3+13*3=76

---

总上所述，第二课树的权值大的叶子节点离根节点近，所以它的权值最小，最优，为赫夫曼树

---

6.WPL最小的就是赫夫曼树

三.赫夫曼树的构建

(一).思路

1.从小到大进行排序，将每一个数据，每个数据都是一个节点，每个节点可以看成是一棵最简单的二叉树

2.取出根节点权值最小的两颗二叉树

3.组成一棵新的二叉树，该新的二叉树的根节点的权值是前面的两颗二叉树根节点权值的和

4，再将这颗新的二叉树，以根节点的权值大小再次排序，不断重复1-2-3-4的步骤，直到数列中，等到所有的数据都被处理完，就得到一棵赫夫曼树

---

(二).思路图解：

注：原有序列：{13，7，8，3，29，6，1}

1.排序

2.取出权重最小的两颗二叉树

3.组成一个新的节点，其值为两个权值最小的二叉树根节点的值的和

4.将组成后的二叉树，根据根节点的值进行排序

5.重复第1个步骤，取出权值最小的两颗二叉树

6.重复第2个步骤，组成新的节点

7.再次排序

8.再次重复以上操作

9.

10.

11.

12.

四.代码展示

package com.cdc.datastructure.tree.binarytree.huffmantree;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * @author cdc
 * @email c925638766@163.com
 * @date 2021/11/27 18:12
 */
public class CreateHuffmanTreeDemo {
    public static void main(String[] args) {
        int[] arr = {13, 7, 8, 3, 29, 6, 1};
        HuffmanTreeNode root = createHuffmanTree(arr);
        preOrder(root);
    }

    /**
     * 构建赫夫曼树
     * @param arr   要构建赫夫曼树的序列
     * @return  赫夫曼树的根节点
     */
    public static HuffmanTreeNode createHuffmanTree(int[] arr){
        System.out.println("处理前的二叉树");
        //为了方便，将数组种的元素全都构建出节点对象，并且放入到ArrayList种
        List<HuffmanTreeNode> nodes=new ArrayList<>();
        for (int i : arr) {
            HuffmanTreeNode node=new HuffmanTreeNode(i);
            nodes.add(node);
        }

        System.out.println(nodes.toString());
        System.out.println("处理后：");
        while (nodes.size() > 1){
            //将原有的列表进行排序，方便取值操作
            Collections.sort(nodes);
//            System.out.println(nodes.toString());

            //1.取出根节点权值最小的两棵二叉树(一个节点也可以算是一棵二叉树)
            //①.取出权值最小的二叉树，由于已经对列表做了排序操作，所以第一个值就是权值最小的节点
            HuffmanTreeNode leftNode = nodes.get(0);
            //②.取出权值次小的值
            HuffmanTreeNode rightNode = nodes.get(1);

            //2.组成一颗新的二叉树，该二叉树的根节点的权值是前面两个二叉树根节点权值的和
            HuffmanTreeNode parent = new HuffmanTreeNode(leftNode.getValue() + rightNode.getValue());
            parent.setLeft(leftNode);
            parent.setRight(rightNode);

            //3.将新构建出来的二叉树放入到列表当中，且删除之前的两棵二叉树
            nodes.add(parent);
            nodes.remove(leftNode);
            nodes.remove(rightNode);
        }
//        System.out.println("第一次处理后，二叉树的结构为："+ nodes.toString());
        return nodes.get(0);
    }

    public static void preOrder(HuffmanTreeNode root){
        if (root != null){
            root.preOrder();
        }else {
            System.out.println("树结构为空，无法构建成赫夫曼树");
        }
    }
}

//由于赫夫曼树需要对节点值进行比较运算并且排序，所以在这里直接使Node节点实现Comparable接口
class HuffmanTreeNode implements Comparable<HuffmanTreeNode> {
    private int value;
    private HuffmanTreeNode left;
    private HuffmanTreeNode right;

    public void preOrder(){
        System.out.println(this);
        if (this.left != null){
            this.left.preOrder();
        }
        if (this.right != null){
            this.right.preOrder();
        }
    }

    public int getValue() {
        return value;
    }

    public HuffmanTreeNode(int value) {
        this.value = value;
    }

    public HuffmanTreeNode getLeft() {
        return left;
    }

    public void setLeft(HuffmanTreeNode left) {
        this.left = left;
    }

    public HuffmanTreeNode getRight() {
        return right;
    }

    public void setRight(HuffmanTreeNode right) {
        this.right = right;
    }

    @Override
    public int compareTo(HuffmanTreeNode o) {
        return this.value - o.value;
    }

    @Override
    public String toString() {
        return "HuffmanTreeNode{" +
                "value=" + value +
                '}';
    }
}