闲来无事写写-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+"\t");
             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+"\t");
             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("\n中序遍历");
         hf.drawTree(root);
     }
 }

执行结果：

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