哈夫曼树（Java）

带权路径最小的树被称为哈夫曼树或者最优二叉树；

n个叶子节点的哈夫曼树总共有2*n-1个节点；

package com.answer.binaryTree;

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.List;
import java.util.Queue;

public class HuffmanTree {
    private static class Node<T>{
        private String data;
        private double weight;
        private Node left;
        private Node right;
        public Node(String data,double weight){
            this.data=data;
            this.weight=weight;
        }
        public String toString(){
            return "data:"+this.data+";weight:"+this.weight;
        }
    }
    private Node createTree(List<Node> nodes){
        while(nodes.size()>1){
            quickSort(nodes);
            Node left=nodes.get(nodes.size()-1);
            Node right=nodes.get(nodes.size()-2);
            Node parent=new Node(null,left.weight+right.weight);
            parent.left=left;
            parent.right=right;
            nodes.remove(left);
            nodes.remove(right);
            nodes.add(parent);
        }return nodes.get(0);
    }

    private void quickSort(List<Node> nodes) {
        subSort(nodes,0,nodes.size()-1);
    }

    private void subSort(List<Node> nodes, int start, int end) {
        if(start<end){
            Node base=nodes.get(start);
            int i=start;
            int j=end+1;
            while(true){
                while (i<end&&nodes.get(++i).weight>=base.weight);
                while(j>start&&nodes.get(--j).weight<=base.weight);
                if(i<j){
                    swap(nodes,i,j);
                }else {
                    break;
                }
            }
            swap(nodes,start,j);
            subSort(nodes,start,j-1);
            subSort(nodes,j+1,end);
        }

    }
    private void swap(List<Node> nodes,int i,int j){
        Node temp=nodes.get(i);
        nodes.set(i,nodes.get(j));
        nodes.set(j,temp);
    }
    public ArrayList<Node> level(Node root){
        ArrayList<Node> list=new ArrayList<>();
        Queue<Node> queue=new ArrayDeque<>();
        if(root!=null){
            queue.add(root);
        }
        while (queue.isEmpty()==false){
            Node node1=queue.remove();
            list.add(node1);
            if(node1.left!=null){
                queue.add(node1.left);
            }
            if(node1.right!=null){
                queue.add(node1.right);
            }
        }return list;
    }

    public static void main(String[] args) {
        List<Node> nodes = new ArrayList<>();
        nodes.add(new Node<String>("A" , 40.0));
        nodes.add(new Node<String>("B" , 7.0));
        nodes.add(new Node<String>("C" , 10.0));
        nodes.add(new Node<String>("D" , 30.0));
        nodes.add(new Node<String>("E" , 12.0));
        nodes.add(new Node<String>("F" , 2.0));
        HuffmanTree tree=new HuffmanTree();
        Node root=tree.createTree(nodes);
        /*ArrayList<Node> list=tree.level(root);
        list.forEach(node -> System.out.println(node.weight));*/
        System.out.println(tree.level(root));

    }
}