閑來無事寫寫-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);
    }
}

執行結果：

后面，將寫通過哈夫曼解析具體報文。