【算法导论】第16章贪心算法

1. 算法描述

　　适用于最优化问题的算法往往包含一系列步骤，每一步都有一组选择，对许多最优化问题来说，采用动态规划方法来决定最佳选择有点繁琐了，只要采用另一些更简单有效的算法就行了。贪心算法是使所做的选择看起来都是当前最佳的，期望通过所做的局部最优选择来产生衣蛾全局最优解。

　　贪心算法是一种很有效的方法，适用于一大类问题。之后要讨论的许多都可以用贪心算法解决，比如赫夫曼树、最小生成树、地杰斯特拉的单元最短路径等。贪心算法是通过做一系列的选择来给出某一问题的最优解，一般开发一个贪心算法时，所遵循的过程比一般情况更复杂些。有如下步骤：

（1）决定问题的最优子结构

（2）设计出一个递归解

（3）证明在递归的任一阶段，最优选择之一总是贪心选择。那么，做贪心选择总是安全的

（4）证明通过做贪心选择，所有的子问题（除一个以外）都为空

（5）设计出一个实现贪心策略的递归算法

（6）将递归算法转化为迭代算法

2. 问题求解

2.1 赫夫曼编码与解码

　　赫夫曼编码是一种被广泛应用而且非常有效的数据压缩技术，赫夫曼贪心算法使用了一张字符出现频度表，根据它来构造一种将每个字符表示成二进制串的最优方式，这里编码方案中药提到一种前缀编码：即在编码方案中，没有一个编码是另一个编码的前缀，这样的编码称为前缀编码。解码过程也需要有一种关于前缀编码的方便表示，使得初始编码可以很容易的被识别出来。

2.1.1 赫夫曼编码算法

　　设C是一个包含n个字符的集合，且每个字符c都是一个出现频度为f[c]的对象,算法以自底向上的方式构造出最优编码所对应的树T，它从|C|个叶结点的集合开始，并依次执行|C|-1次“合并”操作来构造最终的树。Q是一个以f为关键字的最小优先级队列，用来识别出要合并的两个频度最低的对象。两个对象合并的结果是一个新对象，其频度为被合并的两个对象的频度之和。

具体算法如下：

huffman(C)
    n=|C|
    Q=C
    for i=1 to n-1
        do 构建一个新节点z
            left[z]=x=extractMin(Q)
            right[z]=y=extractMin(Q)
            f[z]=f[x]+f[y]
            INSERT(Q,z)
    return root of the tree

2.1.2 赫夫曼解码算法

void huffmanEncode(htNode *ht,char *hv,char vchar[])

    int len=strlen(vchar);
    for(i=0;i<=len;)
    {
        if(ht[m].rchild==0  && ht[m].lchild==0)//为叶子节点
        {
            hv[j++]=ht[m].value;
            m=2*n-1;
        }
        else
        {
            if(vchar[i]=='0')//为0则取左子树
            {
                m=ht[m].lchild;
                i++;
            }
            else            //为1则取右子树
            {
                m=ht[m].rchild;
                i++;
            }
        }
    }

2.1.3 赫夫曼编码与解码的实现代码：

/*-------------------------------------------------------------------
 *名称：赫夫曼算法的实现
 *作者：lp
 *时间：2012.6.28
 *环境：vc++6.0
 *实现描述：        
 *      编码过程：；
 *       解码过程：；
 *-------------------------------------------------------------------*/
#include<stdio.h>
#include<malloc.h>
#include<string.h>
#define en 100 //可以解码的字符串最长字符个数
#define n 6//出现的字符个数
typedef struct{
    unsigned int weight;//value字符出现的次数
    unsigned int parent,lchild,rchild;
    char value;//字符值
    int flag;//以后要用到的标记
}htNode;
/*--------------求最小值---------------------------------------------*/
int selectMin(htNode*ht)
{
    int i,k,m=2*n-1;
    for(i=1;i<=m;i++)
        if(ht[i].flag==0)
        {
            k=i;
            break;
        }
    for( i=2;i<=m;i++)
    {
        //ht[i].weight!=0 && ht[i].parent==0用于有区分的选择最小值节点
        if((ht[i].weight!=0) &&(ht[i].parent==0)&& (ht[i].flag==0)&&(ht[i].weight<ht[k].weight))
            k=i;
    }
    ht[k].flag=1;
    return(k);
}
/*-------建立赫夫曼树，并给出每个字符的编码----------------------*/
void huffmanCode(htNode*ht,char **hc,char wchar[],int w[])
{
    htNode *p=ht;
    int i,j,m,t1,t2;
    m=2*n-1;
    for(i=1;i<=n;i++)//叶子节点的初始化
    {
        p[i].weight=w[i-1];
        p[i].parent=0;
        p[i].lchild=0;
        p[i].rchild=0;
        p[i].value=wchar[i-1];
        p[i].flag=0;
    }
    for(i=n+1;i<=m;i++)//中间节点的初始化
    {
        p[i].weight=0;
        p[i].parent=0;
        p[i].lchild=0;
        p[i].rchild=0;
        p[i].value=0;
        p[i].flag=0;
    }
    for(i=n+1;i<=m;i++)//建立huffman树
    {
        t1=selectMin(ht);//得到最小值t1
        t2=selectMin(ht);//得到最小值t2
        ht[t1].parent=i;
        ht[t2].parent=i;
        ht[i].lchild=t1;
        ht[i].rchild=t2;
        ht[i].weight=ht[t1].weight+ht[t2].weight;
    }
    /*----从叶子节点到根逆向求每个字符的赫夫曼编码----*/
    unsigned int k,start;
    char *cd=(char *)malloc(sizeof(char)*n);
    for(i=1;i<=n;i++)//逐个字符求赫夫曼编码
    {

        start=n-1;//编码结束位置
        cd[n-1]='\0';//编码结束符
        k=i;
        for(j=ht[k].parent;j!=0;j=ht[k].parent)//
        {
            if(ht[j].lchild==k) cd[--start]='0';
            else cd[--start]='1';
            k=j;
        }
        strcpy(hc[i],&cd[start]);//从cd复制编码到ht
    }
    free(cd);
}
/*--------------------解码过程--------------------------------*/    
void huffmanEncode(htNode *ht,char *hv,char vchar[])
{
    int i,j=0,m=2*n-1;
    int len=strlen(vchar);
    for(i=0;i<=len;)
    {
        if(ht[m].rchild==0  && ht[m].lchild==0)//为叶子节点
        {
            hv[j++]=ht[m].value;
            m=2*n-1;
        }
        else
        {
            if(vchar[i]=='0')//为0则取左子树
            {
                m=ht[m].lchild;
                i++;
            }
            else            //为1则取右子树
            {
                m=ht[m].rchild;
                i++;
            }
        }
    }
    hv[j]='\0';//结束符
}

void main()
{
    //wchar[]表示出现的各个字符，
    //w[]表示各个字符出现的次数，
    int i;
    /*----------------构建赫夫曼编码--------------------*/
    char wchar[]="abcdef";
    int w[]={45,13,12,16,9,5};
    int m=2*n-1;//huffman树中的节点个数。
    htNode*ht=(htNode*)malloc(sizeof(htNode)*(m+1));//分配m+1个节点空间，0号单元未使用
    char **hc=(char **)malloc(sizeof(char*)*(n+1));
    for(i=1;i<=n;i++)
        hc[i]=(char *)malloc(sizeof(char)*n);
    huffmanCode(ht,hc,wchar,w);
    printf("每个字符的相应赫夫曼编码为：\n");
    for(i=1;i<=n;i++)
        printf("%c --> %s  \n",wchar[i-1],hc[i]);

    /*------用已经构建的赫夫曼编码进行01编码的解码------*/
    int k=0;
    char vchar[]="101010011111001101";//待解码的01编码
    char *hv=(char *)malloc(sizeof(char)*en);
    huffmanEncode(ht,hv,vchar);
    printf("\n编码%s 的解码结果为:\n%s\n",vchar,hv);
}




    

3. 参考资料：

（1）算法导论

（2）数据结构

（3）http://hi.baidu.com/justtheend/item/5f2ddaf2008bfa1ece9f3286

（4）http://www.cnblogs.com/Jezze/archive/2011/12/23/2299884.html