那些经典算法:贪心算法

贪心算法和分治算法、动态规划算法、回溯算法都是一种编程思想,深入理解这些编程思想,我们也可以根据实际情况设计自己的算法。

一 贪心算法原理

贪心算法的原理比较简单,就是对问题求解的时候,每步都选择当前的最优解,然后已期望得到全局最优解。
贪心算法的适用场景是每次选择是没有状态的,也就是不会对后面的步骤产生影响。

二 贪心算法举例

同样用老师课件中的两个例子:
背包问题:
假如我们有一个可以装100kg物品的背包,我们有5种豆子,每种豆子的总量和总价值各不相同。为了让背包中所装的物品的总价值最大,我们如何选择装哪些豆子,每种装多少?
豆子
分析
直观来想,我们的总重是100kg是限制的,要求装的物品总价值最大,那么我们可以把各种豆子的单价计算下每种豆子的单价,然后按照从高到低排序,每次装完最有价值的豆子后,再继续装稍次价值的豆子,直到装满整个背包。

分糖果:
我们有m个糖果和n个孩子,现在要把糖果分给这些孩子吃,但是糖果少m<n,所以只有一部分孩子能够得到糖果,每个糖果的大小不一样,m个糖果大小分别为s1,s2,s3….sm.除此之外,每个孩子对糖果大小需求不一样,假设这些孩子对糖果的需求大小分别为g1,g2…gn,只有糖果大小大于孩子对糖果需求的时候,他们才会满足,求我们如何分糖果才能够满足最多数量的孩子。

分析:
这个问题是我们选择一部分小孩分给他们糖果,要满足一共最多只能分给m个孩子,还要让满意的孩子最多。和上一个问题类似,就是我们按照孩子对糖果满足从小到大排序,然后依次选能够满足孩子需求的最小糖果,这样依次分下去就可以达到满足最多孩子的目的。

这类题目的特点:
1) 都是有限制的请求下求解
背包问题限制是100kg,分糖果问题限制问题是最多有m个糖果。
2)都是求限制条件下的最优解,背包问题是求最大价值,分糖果是为了求满足最多孩子。
3)每步都是局部最优的,比如背包问题的时候,因为要求最大价值,所以先装最贵的,这样质量不变的情况下,增加的价值最大;分糖果也一样,是在最小糖果的情况下满足一个孩子,满足孩子的都是一个,那么我们需要减少分出去的糖果。

三 霍夫曼编码

霍夫曼编码是一种广泛用于数据文件压缩的编码方法,压缩率通常在20%到90%之间,霍夫曼编码算法根据字符出现频率,用不同的0,1串来标识字符,从而达到缩短字符串,达到压缩的目的。
还是拿课程中的算法举例:
假设有一个包含1000字符的文件,每个字符占1byte,一共需要8000bits来存储。
如果这1000个字符只包括6种字符,分别是a,b,c,d,e,f那么我们通过3个bit(最多可以标识8个字符)来表示这6个字符,那么总共需要3000bits就可以表示这个字符串了。

用这种三个bit标识一个字符,编码和解码比较简单,但是没有充分考虑每个字符在文件中出现的频率。而霍夫曼编码是结合字符在文件中的频率来进行对字符编码的,出现字符多的编码更短,由于霍夫曼编码的长短是不一样的,所以如何不让两种不同的编码之间产生混淆?那就需要保证每种编码不能为另一种编码的前缀。

假设这些字符在文件中出现的频率如下:
文件中的字符频率
总bits = 1*450 +2*350+3*90+4*60+5*30+5*20 = 2100

2100bits比原来3000bits又压缩了近1/3, 下面问题就是如何进行霍夫曼编码了。
王争老师的算法很巧妙也简单:
1)把所有涉及到的字符按照出现频率的高低放入到优先级队列中区。
2)我们从队列中取出频率最小的两个字符上图中为f和e,然后新建个字符比如X,频率为f和e的频率之和,然后X作为f和e的父亲节点。
3)再把X节点放入到优先级队列中。
4)转到2继续指向,直到队列为空。
霍夫曼编码求解过程

构造完一颗二叉树之后,我们给每条边都做个编码,比如左边的边为0,右边的为1,得到如下:
霍夫曼编码树
这样每个节点的编码可以用从根节点到此节点的边来表示:
1)比如a这个节点编码为1
2)c这个编码为001。

四 代码实现

在网上找一段求霍夫曼编码的C++代码,可以对照理解下:

#include <iostream>
using namespace std;

//最大字符编码数组长度
#define MAXCODELEN 100
//最大哈夫曼节点结构体数组个数
#define MAXHAFF 100
//最大哈夫曼编码结构体数组的个数
#define MAXCODE 100
#define MAXWEIGHT  10000;


typedef struct Haffman
{
    //权重
    int weight;
    //字符
    char ch;
    //父节点
    int parent;
    //左儿子节点
    int leftChild;
    //右儿子节点
    int rightChild;
}HaffmaNode;

typedef struct Code
{
    //字符的哈夫曼编码的存储
    int code[MAXCODELEN];
    //从哪个位置开始
    int start;
}HaffmaCode;

HaffmaNode haffman[MAXHAFF];
HaffmaCode code[MAXCODE];

void buildHaffman(int all)
{
    //哈夫曼节点的初始化之前的工作, weight为0,parent,leftChile,rightChile都为-1
    for (int i = 0; i < all * 2 - 1; ++i)
    {
        haffman[i].weight = 0;
        haffman[i].parent = -1;
        haffman[i].leftChild = -1;
        haffman[i].rightChild = -1;
    }
    std::cout << "请输入需要哈夫曼编码的字符和权重大小" << std::endl;
    for (int i = 0; i < all; i++)
    {
        std::cout << "请分别输入第个" << i << "哈夫曼字符和权重" << std::endl;
        std::cin >> haffman[i].ch;
        std::cin >> haffman[i].weight;
    }
    //每次找出最小的权重的节点,生成新的节点,需要all - 1 次合并
    int x1, x2, w1, w2;
    for (int i = 0; i < all - 1; ++i)
    {
        x1 = x2 = -1;
        w1 = w2 = MAXWEIGHT;
        //注意这里每次是all + i次里面便利
        for (int j = 0; j < all + i; ++j)
        {
            //得到最小权重的节点
            if (haffman[j].parent == -1 && haffman[j].weight < w1)
            {
                //如果每次最小的更新了,那么需要把上次最小的给第二个最小的
                w2 = w1;
                x2 = x1;

                x1 = j;
                w1 = haffman[j].weight;
            }
            //这里用else if而不是if,是因为它们每次只选1个就可以了。
            else if(haffman[j].parent == -1 && haffman[j].weight < w2)
            {
                x2 = j;
                w2 = haffman[j].weight;
            }
        }
        //么次找到最小的两个节点后要记得合并成一个新的节点
        haffman[all + i].leftChild = x1;
        haffman[all + i].rightChild = x2;
        haffman[all + i].weight = w1 + w2;
        haffman[x1].parent = all + i;
        haffman[x2].parent = all + i;
        std::cout << "x1 is" << x1 <<" x1 parent is"<<haffman[x1].parent<< " x2 is" << x2 <<" x2 parent is "<< haffman[x2].parent<< " new Node is " << all + i << "new weight is" << haffman[all + i].weight << std::endl;
    }
}

//打印每个字符的哈夫曼编码
void printCode(int all)
{
    //保存当前叶子节点的字符编码
    HaffmaCode hCode;
    //当前父节点
    int curParent;
    //下标和叶子节点的编号
    int c;
    //遍历的总次数
    for (int i = 0; i < all; ++i)
    {
        hCode.start = all - 1;
        c = i;
        curParent = haffman[i].parent;
        //遍历的条件是父节点不等于-1
        while (curParent != -1)
        {
            //我们先拿到父节点,然后判断左节点是否为当前值,如果是取节点0
            //否则取节点1,这里的c会变动,所以不要用i表示,我们用c保存当前变量i
            if (haffman[curParent].leftChild == c)
            {
                hCode.code[hCode.start] = 0;
                std::cout << "hCode.code[" << hCode.start << "] = 0" << std::endl;
            }
            else
            {
                hCode.code[hCode.start] = 1;
                std::cout << "hCode.code[" << hCode.start << "] = 1" << std::endl;
            }
            hCode.start--;
            c = curParent;
            curParent = haffman[c].parent;
        }
        //把当前的叶子节点信息保存到编码结构体里面
        for (int j = hCode.start + 1; j < all; ++j)
        {
            code[i].code[j] = hCode.code[j];
        }
        code[i].start = hCode.start;
    }

}

int main()
{
    std::cout << "请输入有多少个哈夫曼字符" << std::endl;
    int all = 0;
    std::cin >> all;
    if (all <= 0)
    {
        std::cout << "您输入的个数有误" << std::endl;
        return -1;
    }
    buildHaffman(all);
    printCode(all);
    for (int i = 0; i < all; ++i)
    {
        std::cout << haffman[i].ch << ": Haffman Code is:";
        for (int j = code[i].start + 1; j < all; ++j)
        {
            std::cout << code[i].code[j];
        }
        std::cout << std::endl;
    }
    return 0;
posted @ 2019-09-21 12:09  XGogo  阅读(2011)  评论(0编辑  收藏