闲来无事写写-Huffman树的生成过程

前言：最近项目上一直没事干，感觉无聊到了极点，给自己找点事做，补一下大学没有完成的事情，写一个huffman算法Java版的，学校里面写过c语言的。

因为很久没搞数据结构和算法这方面了(现在搞Java web，真心感觉没什么挑战啊)，代码写的一般，边听歌边写，3小时，不知道为什么现在效率这么低，写习惯了

xml配置，感觉纯写算法代码手生的紧，悲呼唉哉！

1、哈夫曼树：

        给定n个权值作为n个叶子结点，构造一棵二叉树，若带权路径长度达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树(Huffman tree)

2、生成过程：

       1. 在n个权值里面首先寻找最小的两个权值作为子节点，开始生成第一棵子树；

       2.将新子树的父节点作为一个新的权值与剩余的权值继续做比较，选出最小的两个权值继续构造新子树；

       3.依次进行，直到最后一棵子树生成；

       4.这时候，最后一棵子树的根节点就是整个哈夫曼树的根节点，从此根节点开始遍历，就能遍历完整个哈夫曼树。

3、图形表示：

        假设有6个权值：1、2、3、4、5、6，生成哈夫曼树的过程如下：

       

      

依次下去...

这样，最终得到的父节点21就是哈夫曼树的根节点，遍历树的话，

c/c++就是：root->left  root->right就可以通过递归的方式从root节点访问到最后一个子节点。

Java就是：   root.left   root.right通过递归从root访问到最后一个子节点。

当然，二叉树的遍历不止递归一种方法，递归是最有效率的一种，还可以通过数据结构里面堆/栈的方式进行遍历。

下面是我写的实现哈夫曼树的Java代码(为了完成功能，绝壁不是优秀的，但可以方便看懂)

注：储存权值使用了List列表，随时增或者删方便一点。

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

class Node
{
    int weight;
    Node left,right,parent;
    public Node(int weight)
    {
        this.weight=weight;
    }
}
public class Huffman {
    private static List<Node> list=new ArrayList<Node>();
    public  static Node root;
    public void insert(Node node)
    {
        //按照插入排序的方式将节点有序插入list
        if(list.size()==0){
            list.add(node);
            return;
        }
        int size=list.size();
        for(int i=0;i<size;)
        {
            if(list.get(i).weight<node.weight){
                i++;
                if(i>=list.size())
                    list.add(node);
            }
            else
            {
                //交换位置
                list.add(list.get(list.size()-1));
                for(int j=list.size()-1;j>i;j--)
                {                    
                    list.set(j, list.get(j-1));
                }
                list.set(i, node);//插入新数据
                return;
            }
            
        }
        
    }
    public Node createTree(Node n1,Node n2)
    {
        //返回新子树的父节点
        Node parentNode=new Node(0);
        parentNode.weight=n1.weight+n2.weight;
        parentNode.left=n1;
        parentNode.right=n2;
        n1.parent=parentNode;
        n2.parent=parentNode;      
        return parentNode;
    }
    public void run(List<Node> list)
    {
        int length=list.size();        
        while(length!=0)
        {
            if(length==1){
                root=list.get(0);
                return;
            }
            if(length==2){
                root=createTree(list.get(0),list.get(1));
                return;
            }  
            Node n1=list.get(0);
            Node n2=list.get(1);
            Node newNode=createTree(n1,n2);
            for(int i=0;i<length-2;i++)
            {
                //转移数据
                list.set(i, list.get(i+2));
            }
            list.remove(length-1);
            list.remove(length-2);
            insert(newNode);
            length=list.size();
        }
        
    }
    public void display(Node node)
    {
        if(node!=null)
        {
            display(node.left);
            System.out.print(node.weight+"	");
            display(node.right);
        }
    }
    public void drawTree(Node node)
    {
        if(node!=null)
        {
            //中序遍历，打算打印树形状，有些麻烦，后面改进
//            if(node.parent!=null&&node.parent.left==node)
//                System.out.print("/");
//            if(node.parent!=null&&node.parent.right==node)
//                System.out.print("\");
            System.out.print(node.weight+"	");
            drawTree(node.left);
            drawTree(node.right);
        }
    }
    public static void main(String[] args)
    {
        Huffman hf=new Huffman();
        hf.insert(new Node(1));
        hf.insert(new Node(2));
        hf.insert(new Node(3));
        hf.insert(new Node(4));
        hf.insert(new Node(5));
        hf.insert(new Node(6));
        hf.run(list);
        System.out.println("前序遍历");
        hf.display(root);
        System.out.println("
中序遍历");
        hf.drawTree(root);
    }
}

执行结果：

后面，将写通过哈夫曼解析具体报文。