霍夫曼树（带权路径长度最短树）的解析和实现

思路分析

package com.ran;


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

public class hello {
     

    public static void main(String[] args) {
     
        int arr[]={
     13,7,8,3,29,6,1};
        HeroNode heroNode=huofuman(arr);

        qianxu(heroNode);


    }

    public static void qianxu(HeroNode root){
     
        if(root!=null){
     
            root.qianxu();
        }else {
     
            System.out.println("空树");
        }
    }







    public static HeroNode huofuman(int arr[]){
     
        //第一步
        //1. 遍历arr数组
        //2， 将arr的每个元素构成一个node
        //3. 将node放入到arrlist中
        List<HeroNode> nodes=new ArrayList<HeroNode>();
        for (int value : arr) {
     
            nodes.add(new HeroNode(value));
        }

        while (nodes.size()>1){
     
        //排序从小到大
        Collections.sort(nodes);

        System.out.println("nodes="+nodes);


        //取出根节点权值最小的两颗二叉树
        HeroNode left=nodes.get(0);
        //取出根节点权值第二小的两颗二叉树
        HeroNode right=nodes.get(1);
        //构建一颗新的二叉树
        HeroNode parent=new HeroNode(left.value+right.value);
        parent.zuo=left;
        parent.you=right;

        //从arraylist中删除处理过的二叉树
        nodes.remove(left);
        nodes.remove(right);
        //将parent加入
        nodes.add(parent);
    }

        //还剩最后一个节点
        return nodes.get(0);
    }



}



//创建双向链表
//为了让node对象支持排序，
//让Node实现Comparable接口
class HeroNode implements  Comparable<HeroNode>{
     
   int value;
   HeroNode zuo;
   HeroNode you;

   //前序遍历
    public void qianxu(){
     
        System.out.println(this);
        if(this.zuo!=null){
     
            this.zuo.qianxu();
        }
        if(this.you!=null){
     
            this.you.qianxu();
        }
    }

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

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

    @Override
    public int compareTo(HeroNode o) {
     
        //表示从小到大排序
        return this.value-o.value;
    }
}

代码实现效果如下：