数据结构之赫夫曼树

1.赫夫曼树基本介绍

(1)给定n个权值作为n个叶子结点,构造一颗二叉树,若该树的带权路径长度(wpl)达到最小,称这样的二叉树为最优二叉树,也称为哈夫曼树(HuffmanTree)
(2)赫夫曼树是带权路径长度最短的树,权值较大的结点离根较近

概念介绍
(1)路径和路径长度:在一棵树中,从一个结点往下可以达到的孩子或者孙子结点之间的通路,称为路径,若规定根节点的层数为1,则从根节点到第L层的路径长度为L-1
(2)结点的权及带权路径长度:若将树中结点赋值给一个有着某种含义的数值,则这个数值称为该结点的权,结点的带权路径长度为:从根结点到该结点之间的路径长度与该结点的权的乘积
(3)树的带权路径长度:树的带权路径长度规定为所有叶子结点的带权路径长度之和,记为WPL(weighted path length),权值越大的结点离根结点越近的二叉树是最优二叉树
(4)WPL最小的就是赫夫曼树.
下图是不同的树,树的带权路径

2.构建赫夫曼树步骤

(1)从小到大进行排序,每个数据都是一个结点,每个结点可以看成是一颗最简单的二叉树.
(2)取出根结点权值最小的两颗二叉树
(3)组成一颗新的二叉树,该新的二叉树的根结点的权值是前面两颗二叉树根结点的权值之和
(4)再将这颗新的二叉树,以根结点的权值大小再次排序,不断重读1,2,3,4步骤,直到数列中,所有的数据都被处理,就得到一颗赫夫曼树.
图解分析:
(1)原始数组为13,7,8,3,29,6,1

(2)

(3)

(4)

(5)

(6)

图解分析看得明白么?看不明白没有关系,代码实现一下

package com.self.dataStructure.huffmanTree;

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

public class HuffmanTreedemo {
    public static void main(String[] args) {
        int[] arr = {13,7,8,3,29,6,1};
        Node root = createHuffmanTree(arr);

        preOrderMethod(root);
    }
    //编写一个前序遍历的方法
    public static void preOrderMethod(Node root){
        if(root != null){
            root.preOrder();
        }else {
            System.out.println("current huffmanTree is null");
        }
    }
    //创建赫夫曼树
    public static Node createHuffmanTree(int[] arr){
        //遍历数组,将数组的每一个值构建成node,将node放入到ArrayList
        List<Node> nodes = new ArrayList<>();
        for (int node : arr) {
            nodes.add(new Node(node));
        }
        while (nodes.size() > 1) {
            //排序,将数组从小到大排序
            Collections.sort(nodes);
            //取出最小的两个值,构建一颗新的二叉树
            Node leftNode = nodes.get(0);
            Node rightNode = nodes.get(1);
            Node parent = new Node(leftNode.value + rightNode.value);
            parent.left = leftNode;
            parent.right = rightNode;
            //删除list集合中的前两个数
            nodes.remove(leftNode);
            nodes.remove(rightNode);
            //将parent添加到集合
            nodes.add(parent);
        }
        return nodes.get(0);
    }

}
class Node implements Comparable<Node>{
    int value;
    Node left;
    Node right;
    public Node(int value) {
        this.value = value;
    }
    //前序遍历
    public void preOrder(){
        System.out.println(this);
        if(this.left != null){
            this.left.preOrder();
        }
        if(this.right != null){
            this.right.preOrder();
        }
    }
    @Override
    public String toString() {
        return "Node{" +
                "value=" + value +
                '}';
    }
    @Override
    public int compareTo(Node o) {
        //表示从小到大排序
        return this.value - o.value;
    }
}