腳本之家服務(wù)器常用軟件

快捷導(dǎo)航

算法系列15天速成——第十三天樹操作【下】

更新時(shí)間：2013年11月15日 16:58:38 作者：

今天說下最后一種樹，大家可否知道，文件壓縮程序里面的核心結(jié)構(gòu)，核心算法是什么？或許你知道，他就運(yùn)用了赫夫曼樹

聽說赫夫曼勝過了他的導(dǎo)師，被認(rèn)為”青出于藍(lán)而勝于藍(lán)“，這句話也是我比較欣賞的，嘻嘻。

一概念

了解”赫夫曼樹“之前，幾個(gè)必須要知道的專業(yè)名詞可要熟練記住啊。

1：結(jié)點(diǎn)的權(quán)

“權(quán)”就相當(dāng)于“重要度”，我們形象的用一個(gè)具體的數(shù)字來表示，然后通過數(shù)字的大小來決定誰重要，誰不重要。

2：路徑

樹中從“一個(gè)結(jié)點(diǎn)"到“另一個(gè)結(jié)點(diǎn)“之間的分支。

3：路徑長度

一個(gè)路徑上的分支數(shù)量。

4：樹的路徑長度

從樹的根節(jié)點(diǎn)到每個(gè)節(jié)點(diǎn)的路徑長度之和。

5：節(jié)點(diǎn)的帶權(quán)路徑路勁長度

其實(shí)也就是該節(jié)點(diǎn)到根結(jié)點(diǎn)的路徑長度*該節(jié)點(diǎn)的權(quán)。

6: 樹的帶權(quán)路徑長度

樹中各個(gè)葉節(jié)點(diǎn)的路徑長度*該葉節(jié)點(diǎn)的權(quán)的和，常用WPL(Weight Path Length)表示。

二：構(gòu)建赫夫曼樹

上面說了那么多，肯定是為下面做鋪墊，這里說赫夫曼樹，肯定是要說赫夫曼樹咋好咋好，赫夫曼樹是一種最優(yōu)二叉樹,

因?yàn)樗腤PL是最短的，何以見得？我們可以上圖說話。

現(xiàn)在我們做一個(gè)WPL的對比：

圖A: WPL= 5*2 + 7*2 +2*2+13*2=54

圖B：WPL=5*3+2*3+7*2+13*1=48

我們對比一下，圖B的WPL最短的，地球人已不能阻止WPL還能比“圖B”的小，所以，“圖B"就是一顆赫夫曼樹，那么大家肯定

要問，如何構(gòu)建一顆赫夫曼樹，還是上圖說話。

第一步：我們將所有的節(jié)點(diǎn)都作為獨(dú)根結(jié)點(diǎn)。

第二步: 我們將最小的C和A組建為一個(gè)新的二叉樹，權(quán)值為左右結(jié)點(diǎn)之和。

第三步：將上一步組建的新節(jié)點(diǎn)加入到剩下的節(jié)點(diǎn)中，排除上一步組建過的左右子樹，我們選中B組建新的二叉樹，然后取權(quán)值。

第四步：同上。

三：赫夫曼編碼

大家都知道，字符，漢字，數(shù)字在計(jì)算機(jī)中都是以0，1來表示的，相應(yīng)的存儲都是有一套編碼方案來支撐的，比如ASC碼。

這樣才能在"編碼“和”解碼“的過程中不會成為亂碼，但是ASC碼不理想的地方就是等長的，其實(shí)我們都想用較少的空間來存儲

更多的東西，那么我們就要采用”不等長”的編碼方案來存儲，那么“何為不等長呢“？其實(shí)也就是出現(xiàn)次數(shù)比較多的字符我們采用短編碼，

出現(xiàn)次數(shù)較少的字符我們采用長編碼，恰好，“赫夫曼編碼“就是不等長的編碼。

這里大家只要掌握赫夫曼樹的編碼規(guī)則：左子樹為0，右子樹為1，對應(yīng)的編碼后的規(guī)則是：從根節(jié)點(diǎn)到子節(jié)點(diǎn)

A: 111

B: 10

C: 110

D: 0

四：實(shí)現(xiàn)

不知道大家懂了沒有，不懂的話多看幾篇，下面說下赫夫曼的具體實(shí)現(xiàn)。

第一步：構(gòu)建赫夫曼樹。

第二步：對赫夫曼樹進(jìn)行編碼。

第三步：壓縮操作。

第四步：解壓操作。

1：首先看下赫夫曼樹的結(jié)構(gòu)，這里字段的含義就不解釋了。

復(fù)制代碼代碼如下:

#region 赫夫曼樹結(jié)構(gòu)
    /// <summary>
/// 赫夫曼樹結(jié)構(gòu)
/// </summary>
    public class HuffmanTree
    {
        public int weight { get; set; }

public int parent { get; set; }

public int left { get; set; }

        public int right { get; set; }
    }
    #endregion

2：創(chuàng)建赫夫曼樹，原理在上面已經(jīng)解釋過了，就是一步一步的向上搭建，這里要注意的二個(gè)性質(zhì)定理：

當(dāng)葉子節(jié)點(diǎn)為N個(gè)，則需要N-1步就能搭建赫夫曼樹。

當(dāng)葉子節(jié)點(diǎn)為N個(gè)，則赫夫曼樹的節(jié)點(diǎn)總數(shù)為:(2*N)-1個(gè)。

復(fù)制代碼代碼如下:

#region 赫夫曼樹的創(chuàng)建
        /// <summary>
/// 赫夫曼樹的創(chuàng)建
/// </summary>
/// <param name="huffman">赫夫曼樹</param>
/// <param name="leafNum">葉子節(jié)點(diǎn)</param>
/// <param name="weight">節(jié)點(diǎn)權(quán)重</param>
        public HuffmanTree[] CreateTree(HuffmanTree[] huffman, int leafNum, int[] weight)
        {
            //赫夫曼樹的節(jié)點(diǎn)總數(shù)
            int huffmanNode = 2 * leafNum - 1;

            //初始化節(jié)點(diǎn)，賦予葉子節(jié)點(diǎn)值
            for (int i = 0; i < huffmanNode; i++)
            {
                if (i < leafNum)
                {
                    huffman[i].weight = weight[i];
                }
            }

            //這里面也要注意，4個(gè)節(jié)點(diǎn)，其實(shí)只要3步就可以構(gòu)造赫夫曼樹
            for (int i = leafNum; i < huffmanNode; i++)
            {
                int minIndex1;
                int minIndex2;
                SelectNode(huffman, i, out minIndex1, out minIndex2);

                //最后得出minIndex1和minindex2中實(shí)體的weight最小
                huffman[minIndex1].parent = i;
                huffman[minIndex2].parent = i;

huffman[i].left = minIndex1;
huffman[i].right = minIndex2;

huffman[i].weight = huffman[minIndex1].weight + huffman[minIndex2].weight;
}

            return huffman;
        }
        #endregion

        #region 選出葉子節(jié)點(diǎn)中最小的二個(gè)節(jié)點(diǎn)
        /// <summary>
/// 選出葉子節(jié)點(diǎn)中最小的二個(gè)節(jié)點(diǎn)
/// </summary>
/// <param name="huffman"></param>
/// <param name="searchNodes">要查找的結(jié)點(diǎn)數(shù)</param>
/// <param name="minIndex1"></param>
/// <param name="minIndex2"></param>
        public void SelectNode(HuffmanTree[] huffman, int searchNodes, out int minIndex1, out int minIndex2)
        {
            HuffmanTree minNode1 = null;

HuffmanTree minNode2 = null;

//最小節(jié)點(diǎn)在赫夫曼樹中的下標(biāo)
minIndex1 = minIndex2 = 0;

            //查找范圍
            for (int i = 0; i < searchNodes; i++)
            {
                ///只有獨(dú)根樹才能進(jìn)入查找范圍
                if (huffman[i].parent == 0)
                {
                    //如果為null，則認(rèn)為當(dāng)前實(shí)體為最小
                    if (minNode1 == null)
                    {
                        minIndex1 = i;

minNode1 = huffman[i];

continue;
}

                    //如果為null，則認(rèn)為當(dāng)前實(shí)體為最小
                    if (minNode2 == null)
                    {
                        minIndex2 = i;

minNode2 = huffman[i];

                        //交換一個(gè)位置，保證minIndex1為最小，為后面判斷做準(zhǔn)備
                        if (minNode1.weight > minNode2.weight)
                        {
                            //節(jié)點(diǎn)交換
                            var temp = minNode1;
                            minNode1 = minNode2;
                            minNode2 = temp;

                            //下標(biāo)交換
                            var tempIndex = minIndex1;
                            minIndex1 = minIndex2;
                            minIndex2 = tempIndex;

                            continue;
                        }
                    }
                    if (minNode1 != null && minNode2 != null)
                    {
                        if (huffman[i].weight <= minNode1.weight)
                        {
                            //將min1臨時(shí)轉(zhuǎn)存給min2
                            minNode2 = minNode1;
                            minNode1 = huffman[i];

                            //記錄在數(shù)組中的下標(biāo)
                            minIndex2 = minIndex1;
                            minIndex1 = i;
                        }
                        else
                        {
                            if (huffman[i].weight < minNode2.weight)
                            {
                                minNode2 = huffman[i];

                                minIndex2 = i;
                            }
                        }
                    }
                }
            }
        }
        #endregion

3:對哈夫曼樹進(jìn)行編碼操作，形成一套“模板”，效果跟ASC模板一樣，不過一個(gè)是不等長，一個(gè)是等長。

復(fù)制代碼代碼如下:

#region 赫夫曼編碼
        /// <summary>
/// 赫夫曼編碼
/// </summary>
/// <param name="huffman"></param>
/// <param name="leafNum"></param>
/// <param name="huffmanCode"></param>
        public string[] HuffmanCoding(HuffmanTree[] huffman, int leafNum)
        {
            int current = 0;

int parent = 0;

string[] huffmanCode = new string[leafNum];

            //四個(gè)葉子節(jié)點(diǎn)的循環(huán)
            for (int i = 0; i < leafNum; i++)
            {
                //單個(gè)字符的編碼串
                string codeTemp = string.Empty;

current = i;

//第一次獲取最左節(jié)點(diǎn)
parent = huffman[current].parent;

                while (parent != 0)
                {
                    //如果父節(jié)點(diǎn)的左子樹等于當(dāng)前節(jié)點(diǎn)就標(biāo)記為0
                    if (current == huffman[parent].left)
                        codeTemp += "0";
                    else
                        codeTemp += "1";

                    current = parent;
                    parent = huffman[parent].parent;
                }

                huffmanCode[i] = new string(codeTemp.Reverse().ToArray());
            }
            return huffmanCode;
        }
        #endregion

4：模板生成好了，我們就要對指定的測試數(shù)據(jù)進(jìn)行壓縮處理

復(fù)制代碼代碼如下:

#region 對指定字符進(jìn)行壓縮
        /// <summary>
/// 對指定字符進(jìn)行壓縮
/// </summary>
/// <param name="huffmanCode"></param>
/// <param name="alphabet"></param>
/// <param name="test"></param>
        public string Encode(string[] huffmanCode, string[] alphabet, string test)
        {
            //返回的0,1代碼
            string encodeStr = string.Empty;

            //對每個(gè)字符進(jìn)行編碼
            for (int i = 0; i < test.Length; i++)
            {
                //在模版里面查找
                for (int j = 0; j < alphabet.Length; j++)
                {
                    if (test[i].ToString() == alphabet[j])
                    {
                        encodeStr += huffmanCode[j];
                    }
                }
            }

            return encodeStr;
        }
        #endregion

5：最后也就是對壓縮的數(shù)據(jù)進(jìn)行還原操作。

復(fù)制代碼代碼如下:

#region 對指定的二進(jìn)制進(jìn)行解壓
        /// <summary>
/// 對指定的二進(jìn)制進(jìn)行解壓
/// </summary>
/// <param name="huffman"></param>
/// <param name="leafNum"></param>
/// <param name="alphabet"></param>
/// <param name="test"></param>
/// <returns></returns>
        public string Decode(HuffmanTree[] huffman, int huffmanNodes, string[] alphabet, string test)
        {
            string decodeStr = string.Empty;

            //所有要解碼的字符
            for (int i = 0; i < test.Length; )
            {
                int j = 0;
                //赫夫曼樹結(jié)構(gòu)模板(用于循環(huán)的解碼單個(gè)字符)
                for (j = huffmanNodes - 1; (huffman[j].left != 0 || huffman[j].right != 0); )
                {
                    if (test[i].ToString() == "0")
                    {
                        j = huffman[j].left;
                    }
                    if (test[i].ToString() == "1")
                    {
                        j = huffman[j].right;
                    }
                    i++;
                }
                decodeStr += alphabet[j];
            }
            return decodeStr;
        }

#endregion

最后上一下總的運(yùn)行代碼

復(fù)制代碼代碼如下:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace HuffmanTree
{
    class Program
    {
        static void Main(string[] args)
        {
            //有四個(gè)葉節(jié)點(diǎn)
            int leafNum = 4;

//赫夫曼樹中的節(jié)點(diǎn)總數(shù)
int huffmanNodes = 2 * leafNum - 1;

//各節(jié)點(diǎn)的權(quán)值
int[] weight = { 5, 7, 2, 13 };

string[] alphabet = { "A", "B", "C", "D" };

string testCode = "DBDBDABDCDADBDADBDADACDBDBD";

//赫夫曼樹用數(shù)組來保存，每個(gè)赫夫曼都作為一個(gè)實(shí)體存在
HuffmanTree[] huffman = new HuffmanTree[huffmanNodes].Select(i => new HuffmanTree() { }).ToArray();

HuffmanTreeManager manager = new HuffmanTreeManager();

manager.CreateTree(huffman, leafNum, weight);

string[] huffmanCode = manager.HuffmanCoding(huffman, leafNum);

            for (int i = 0; i < leafNum; i++)
            {
                Console.WriteLine("字符：{0}，權(quán)重:{1},編碼為:{2}", alphabet[i], huffman[i].weight, huffmanCode[i]);
            }

Console.WriteLine("原始的字符串為：" + testCode);

string encode = manager.Encode(huffmanCode, alphabet, testCode);

Console.WriteLine("被編碼的字符串為：" + encode);

string decode = manager.Decode(huffman, huffmanNodes, alphabet, encode);

            Console.WriteLine("解碼后的字符串為：" + decode);
        }
    }

    #region 赫夫曼樹結(jié)構(gòu)
    /// <summary>
/// 赫夫曼樹結(jié)構(gòu)
/// </summary>
    public class HuffmanTree
    {
        public int weight { get; set; }

public int parent { get; set; }

public int left { get; set; }

        public int right { get; set; }
    }
    #endregion

    /// <summary>
/// 赫夫曼樹的操作類
/// </summary>
    public class HuffmanTreeManager
    {
        #region 赫夫曼樹的創(chuàng)建
        /// <summary>
/// 赫夫曼樹的創(chuàng)建
/// </summary>
/// <param name="huffman">赫夫曼樹</param>
/// <param name="leafNum">葉子節(jié)點(diǎn)</param>
/// <param name="weight">節(jié)點(diǎn)權(quán)重</param>
        public HuffmanTree[] CreateTree(HuffmanTree[] huffman, int leafNum, int[] weight)
        {
            //赫夫曼樹的節(jié)點(diǎn)總數(shù)
            int huffmanNode = 2 * leafNum - 1;

            //初始化節(jié)點(diǎn)，賦予葉子節(jié)點(diǎn)值
            for (int i = 0; i < huffmanNode; i++)
            {
                if (i < leafNum)
                {
                    huffman[i].weight = weight[i];
                }
            }

            //這里面也要注意，4個(gè)節(jié)點(diǎn)，其實(shí)只要3步就可以構(gòu)造赫夫曼樹
            for (int i = leafNum; i < huffmanNode; i++)
            {
                int minIndex1;
                int minIndex2;
                SelectNode(huffman, i, out minIndex1, out minIndex2);

                //最后得出minIndex1和minindex2中實(shí)體的weight最小
                huffman[minIndex1].parent = i;
                huffman[minIndex2].parent = i;

huffman[i].left = minIndex1;
huffman[i].right = minIndex2;

huffman[i].weight = huffman[minIndex1].weight + huffman[minIndex2].weight;
}

            return huffman;
        }
        #endregion

        #region 選出葉子節(jié)點(diǎn)中最小的二個(gè)節(jié)點(diǎn)
        /// <summary>
/// 選出葉子節(jié)點(diǎn)中最小的二個(gè)節(jié)點(diǎn)
/// </summary>
/// <param name="huffman"></param>
/// <param name="searchNodes">要查找的結(jié)點(diǎn)數(shù)</param>
/// <param name="minIndex1"></param>
/// <param name="minIndex2"></param>
        public void SelectNode(HuffmanTree[] huffman, int searchNodes, out int minIndex1, out int minIndex2)
        {
            HuffmanTree minNode1 = null;

HuffmanTree minNode2 = null;

//最小節(jié)點(diǎn)在赫夫曼樹中的下標(biāo)
minIndex1 = minIndex2 = 0;

            //查找范圍
            for (int i = 0; i < searchNodes; i++)
            {
                ///只有獨(dú)根樹才能進(jìn)入查找范圍
                if (huffman[i].parent == 0)
                {
                    //如果為null，則認(rèn)為當(dāng)前實(shí)體為最小
                    if (minNode1 == null)
                    {
                        minIndex1 = i;

minNode1 = huffman[i];

continue;
}

                    //如果為null，則認(rèn)為當(dāng)前實(shí)體為最小
                    if (minNode2 == null)
                    {
                        minIndex2 = i;

minNode2 = huffman[i];

                        //交換一個(gè)位置，保證minIndex1為最小，為后面判斷做準(zhǔn)備
                        if (minNode1.weight > minNode2.weight)
                        {
                            //節(jié)點(diǎn)交換
                            var temp = minNode1;
                            minNode1 = minNode2;
                            minNode2 = temp;

                            //下標(biāo)交換
                            var tempIndex = minIndex1;
                            minIndex1 = minIndex2;
                            minIndex2 = tempIndex;

                            continue;
                        }
                    }
                    if (minNode1 != null && minNode2 != null)
                    {
                        if (huffman[i].weight <= minNode1.weight)
                        {
                            //將min1臨時(shí)轉(zhuǎn)存給min2
                            minNode2 = minNode1;
                            minNode1 = huffman[i];

                            //記錄在數(shù)組中的下標(biāo)
                            minIndex2 = minIndex1;
                            minIndex1 = i;
                        }
                        else
                        {
                            if (huffman[i].weight < minNode2.weight)
                            {
                                minNode2 = huffman[i];

                                minIndex2 = i;
                            }
                        }
                    }
                }
            }
        }
        #endregion

        #region 赫夫曼編碼
        /// <summary>
/// 赫夫曼編碼
/// </summary>
/// <param name="huffman"></param>
/// <param name="leafNum"></param>
/// <param name="huffmanCode"></param>
        public string[] HuffmanCoding(HuffmanTree[] huffman, int leafNum)
        {
            int current = 0;

int parent = 0;

string[] huffmanCode = new string[leafNum];

            //四個(gè)葉子節(jié)點(diǎn)的循環(huán)
            for (int i = 0; i < leafNum; i++)
            {
                //單個(gè)字符的編碼串
                string codeTemp = string.Empty;

current = i;

//第一次獲取最左節(jié)點(diǎn)
parent = huffman[current].parent;

                while (parent != 0)
                {
                    //如果父節(jié)點(diǎn)的左子樹等于當(dāng)前節(jié)點(diǎn)就標(biāo)記為0
                    if (current == huffman[parent].left)
                        codeTemp += "0";
                    else
                        codeTemp += "1";

                    current = parent;
                    parent = huffman[parent].parent;
                }

                huffmanCode[i] = new string(codeTemp.Reverse().ToArray());
            }
            return huffmanCode;
        }
        #endregion

        #region 對指定字符進(jìn)行壓縮
        /// <summary>
/// 對指定字符進(jìn)行壓縮
/// </summary>
/// <param name="huffmanCode"></param>
/// <param name="alphabet"></param>
/// <param name="test"></param>
        public string Encode(string[] huffmanCode, string[] alphabet, string test)
        {
            //返回的0,1代碼
            string encodeStr = string.Empty;

            //對每個(gè)字符進(jìn)行編碼
            for (int i = 0; i < test.Length; i++)
            {
                //在模版里面查找
                for (int j = 0; j < alphabet.Length; j++)
                {
                    if (test[i].ToString() == alphabet[j])
                    {
                        encodeStr += huffmanCode[j];
                    }
                }
            }

            return encodeStr;
        }
        #endregion

        #region 對指定的二進(jìn)制進(jìn)行解壓
        /// <summary>
/// 對指定的二進(jìn)制進(jìn)行解壓
/// </summary>
/// <param name="huffman"></param>
/// <param name="leafNum"></param>
/// <param name="alphabet"></param>
/// <param name="test"></param>
/// <returns></returns>
        public string Decode(HuffmanTree[] huffman, int huffmanNodes, string[] alphabet, string test)
        {
            string decodeStr = string.Empty;

            //所有要解碼的字符
            for (int i = 0; i < test.Length; )
            {
                int j = 0;
                //赫夫曼樹結(jié)構(gòu)模板(用于循環(huán)的解碼單個(gè)字符)
                for (j = huffmanNodes - 1; (huffman[j].left != 0 || huffman[j].right != 0); )
                {
                    if (test[i].ToString() == "0")
                    {
                        j = huffman[j].left;
                    }
                    if (test[i].ToString() == "1")
                    {
                        j = huffman[j].right;
                    }
                    i++;
                }
                decodeStr += alphabet[j];
            }
            return decodeStr;
        }