哈夫曼树（JAVA版本）

package com.数据结构.树;

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

/**构建哈夫曼树
 * 1.使用排序数组
 * 2.选出最小的两个权重，构建新的权重，把新权重加紧数组，删除已使用的两个权重
 * 3.重复1和2，直到只剩最后一个元素
 */
public class Lesson16 {
    static List<HuffmanTree> list=new ArrayList<>();
    public static void main(String[] args) {
        HuffmanTree<Character> huffmanTree33=new HuffmanTree<>('F',33);
        list.add(huffmanTree33);
        HuffmanTree<Character> huffmanTree45D=new HuffmanTree<>('D',45);
        list.add(huffmanTree45D);
        HuffmanTree<Character> huffmanTree145=new HuffmanTree<>('A',145);
        list.add(huffmanTree145);
        HuffmanTree<Character> huffmanTree25=new HuffmanTree<>('G',25);
        list.add(huffmanTree25);
        HuffmanTree<Character> huffmanTree8=new HuffmanTree<>('P',8);
        list.add(huffmanTree8);
        HuffmanTree<Character> huffmanTree45E=new HuffmanTree<>('E',45);
        list.add(huffmanTree45E);
        HuffmanTree<Character> huffmanTree38=new HuffmanTree<>('B',38);
        list.add(huffmanTree38);
        HuffmanTree<Character> huffmanTree1=new HuffmanTree<>('Z',1);
        list.add(huffmanTree1);
        //构建
        HuffmanTree<Character> tree=creatHuffmanTree();
        System.out.println(tree.toString());
    }

    //构建哈夫曼树
    public static HuffmanTree<Character> creatHuffmanTree(){
        while(list.size()>1){
            //升序-->Compareable接口后是降序
            Collections.sort(list);
            //倒数第一个数肯定是最小的，此之倒数第二个数
            HuffmanTree<String> left = list.get(list.size()-1);
            HuffmanTree<String> right = list.get(list.size()-2);
            //构造一颗新树，权重是最小两个树权重之和
            HuffmanTree<Character> parent = new HuffmanTree<>(null, left.weight+right.weight);
            parent.left=left;
            parent.right=right;
            //删除倒数后两个树
            list.remove(list.size()-1);
            list.remove(list.size()-1);
            //把新树加进集合
            list.add(parent);
        }
        return list.get(0);
    }
}


//哈夫曼树-数据结构
class HuffmanTree<E> implements Comparable<HuffmanTree>{
    E root;
    double weight;
    HuffmanTree<String> left;
    HuffmanTree<String> right;

    public HuffmanTree(E root, double weight) {
        this.root = root;
        this.weight = weight;
    }

    @Override
    public String toString() {
        return "HuffmanTree{" +
                "root=" + root +
                ", weight=" + weight +
                ", left=" + left +
                ", right=" + right +
                '}';
    }

    //compareTo重写，进行了降序排列

    /**
     * a.compareTo(b)
     * 本来是 a > b? return 1 : return -1; 升序
     */
    @Override//this.compareTo(huffmanTree)
    public int compareTo(HuffmanTree huffmanTree) {
        if(this.weight < huffmanTree.weight){
            return 1;
        }else if(this.weight > huffmanTree.weight){
            return -1;
        }
        return 0;
    }
}