04-3. Huffman Codes (30)

04-3. Huffman Codes (30)

时间限制
200 ms
内存限制
65536 kB
代码长度限制
8000 B
判题程序
Standard
作者
CHEN, Yue
In 1953, David A. Huffman published his paper "A Method for the Construction of Minimum-Redundancy Codes", and hence printed his name in the history of computer science. As a professor who gives the final exam problem on Huffman codes, I am encountering a big problem: the Huffman codes are NOT unique. For example, given a string "aaaxuaxz", we can observe that the frequencies of the characters 'a', 'x', 'u' and 'z' are 4, 2, 1 and 1, respectively. We may either encode the symbols as {'a'=0, 'x'=10, 'u'=110, 'z'=111}, or in another way as {'a'=1, 'x'=01, 'u'=001, 'z'=000}, both compress the string into 14 bits. Another set of code can be given as {'a'=0, 'x'=11, 'u'=100, 'z'=101}, but {'a'=0, 'x'=01, 'u'=011, 'z'=001} is NOT correct since "aaaxuaxz" and "aazuaxax" can both be decoded from the code 00001011001001. The students are submitting all kinds of codes, and I need a computer program to help me determine which ones are correct and which ones are not.

Input Specification:

Each input file contains one test case. For each case, the first line gives an integer N (2 <= N <= 63), then followed by a line that contains all the N distinct characters and their frequencies in the following format:

c[1] f[1] c[2] f[2] ... c[N] f[N]
where c[i] is a character chosen from {'0' - '9', 'a' - 'z', 'A' - 'Z', '_'}, and f[i] is the frequency of c[i] and is an integer no more than 1000. The next line gives a positive integer M (<=1000), then followed by M student submissions. Each student submission consists of N lines, each in the format:

c[i] code[i]
where c[i] is the i-th character and code[i] is a string of '0's and '1's.

Output Specification:

For each test case, print in each line either “Yes” if the student’s submission is correct, or “No” if not.

Sample Input:
7
A 1 B 1 C 1 D 3 E 3 F 6 G 6
4
A 00000
B 00001
C 0001
D 001
E 01
F 10
G 11
A 01010
B 01011
C 0100
D 011
E 10
F 11
G 00
A 000
B 001
C 010
D 011
E 100
F 101
G 110
A 00000
B 00001
C 0001
D 001
E 00
F 10
G 11
Sample Output:
Yes
Yes
No

No



代码:

#include <stdio.h>
#include <malloc.h>
#include <string.h>
int count=0;


typedef struct HeapStruct *minheap;
typedef struct input1 *input;
struct input1
{
char a;
int weight;
input left,right;
};

struct HeapStruct
{
input element;
int size;
int Capacity;
};
//建立最小树
minheap Create(int n)
{
minheap H=malloc(sizeof(struct HeapStruct));
H->element=malloc( (n+1) * sizeof(struct input1) );
H->size = 0;
H->Capacity = n;
H->element[0].weight=0;
H->element[0].a='#';
return H;
}
//将输入元素插入
void Insert(minheap s,input p)
{

if(s->size < s->Capacity)
{
s->size++;
int parent=s->size;
int child;
int item=p->weight;
for(;;parent=child)
{
child=parent/2;
if(s->element[child].weight < item)
break;
else
s->element[parent]=s->element[child];
}
s->element[parent].weight=p->weight;
s->element[parent].a=p->a;


}
}

//now s is a minimum heap


//删除并返回最小元素
struct input1 deleteHeap(minheap s)
{
struct input1 Min,tem;
int parent,child;
if(s->size >=1)
{
Min=s->element[1];
tem=s->element[s->size--];
for(parent=1;parent*2<=s->size;parent=child)
{
child=parent*2;
if((child != s->size) && (s->element[child].weight>s->element[child+1].weight))
child++;
if(tem.weight < s->element[child].weight)
break;
else
s->element[parent]=s->element[child];
}
s->element[parent]=tem;
}
return Min;
}

//建立哈夫曼树
void HFM(minheap s)
{
int i;
struct input1 T;
int n=s->size;
for(i=1;i < n;i++)
{
struct input1 p2,p3;

p2=deleteHeap(s);
T.left=&p2;
p3=deleteHeap(s);
T.right=&p3;
T.weight=T.left->weight + T.right->weight;
printf("HFM:count previous=%d\n",count);
count=count+T.weight;
printf("HFM right and left:%d %d\n",T.left->weight,T.right->weight);
printf("HFM:count left=%d\n",count);
input p1=&T;
Insert(s,p1);
}
}
//检测一个字符串是否是另一个字符串的前缀
int equalOrElse(char *a,char *b)
{
int i=0;
while(a[i] && b[i])
{
if(a[i]==b[i])
i++;
else
break;
}
if(i==strlen(a) || i==strlen(b))
return 1;
else
return 0;
}


int main()
{
int N;
int i=0;


char q[100];
int q1[100];
printf("准备输入数据的个数:\n");
scanf("%d",&N);
getchar();
minheap s=Create(N);

printf("输入字符和权值:\n");
while(i<N)
{
scanf("%c",&q[i]);
printf("q=%c\n",q[i]);
scanf("%d",&q1[i]);
printf("q1=%d\n",q1[i]);
input p;
p=malloc(sizeof(struct input1));
p->weight=q1[i];
p->a=q[i];
p->left=NULL;
p->right=NULL;
Insert(s,p);
i++;
getchar();
}

HFM(s);
printf("wql=%d\n",count);




int M;                 //有几组需要检测的数据
scanf("%d",&M);
getchar();
char l[100];
char *(l1[100])[100];
int j=0,sum,z,k=0;
while(k<M)
{
sum=0;
while(j<N)
{

scanf("%c",&l[j]);
printf("l=%c\n",l[j]);
printf("j1=%d\n",j);
scanf("%s",l1[j]);
printf("l1=%s\n",l1[j]);
for(z=0;z<N;z++)
{
printf("z=%d q[]=%c\n",z,q[z]);
if(q[z]==l[j])
{
sum=sum+q1[z]*(strlen(l1[j]));
printf("sum=%d strlen=%d\n",sum,strlen(l1[j]));
break;
}
}

j++;
printf("j2=%d\n",j);
getchar();
}

if(sum==count)
{
for(i=0;i<N;i++)
{
for(j=i+1;j<N;j++)
{
if(equalOrElse(l1[i],l1[j]) == 1)
{
printf("No\n");
goto l1;
}
}
}

printf("Yes\n");
}
else
printf("No\n");
l1: k++;
j=0;
i=0;
}


return 0;

}

  • 1
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: Huffman编码是一种用于数据压缩的算法,它通过将出现频率较高的字符用较短的编码表示,从而减少数据的存储空间。该算法的基本思想是构建一棵哈夫曼树,将字符的出现频率作为权值,然后从叶子节点开始向上遍历,将左子树标记为,右子树标记为1,最终得到每个字符的编码。哈夫曼编码具有唯一性,即每个字符都有唯一的编码,且任何一个编码都不是另一个编码的前缀。 ### 回答2: Huffman编码是一种压缩数据的方式。它使用的基本原理是将数据中频繁出现的字符使用较短的编码,而不常用的字符使用较长的编码,以达到压缩数据的目的。在Huffman编码中,我们使用二叉树来表示每个字符的编码。左孩子被标记为0,右孩子被标记为1。当我们从根节点到叶子节点的路径上移动时,我们收集的所有0和1的序列将编码作为该字符的压缩表示。 具体来说,生成Huffman编码的过程包括以下步骤: 1. 统计给定数据集中每个字符出现的次数。 2. 将字符作为叶子节点构建二叉树,每个叶子节点包含一个字符和该字符的频率。 3. 选择频率最小的两个节点,将它们作为左右子树合并成一个新节点,其频率等于两个节点频率之和。 4. 将新节点插入二叉树,并在每个节点添加一个标记为0或1的位。 5. 重复步骤3和步骤4,直到只剩下一个节点。 6. 通过树遍历收集每个字符的Huffman编码。递归树,并在每个节点处添加0或1,直到我们到达一个叶子节点。 Huffman编码的优点在于它可以使数据更紧凑,占用更少的存储空间。它也是在许多压缩和编码算法中广泛应用的基础。Huffman编码的缺点是在压缩小数据时,压缩效果可能不明显。这是因为压缩率受到输入数据的分布和大小的影响。在Huffman编码中,来自数据集的所有字符的比特序列可能具有不同的长度。因此,我们需要在压缩和解压缩时花费一些额外的时间来恢复原始数据。 总之,Huffman编码是一种有效的数据压缩算法,可以通过使用二叉树来表示每个字符的编码来实现。它的主要优点是可以更紧凑地存储数据,但它仍然受到输入数据大小和分布的影响,并且在进行压缩和解压缩时需要花费额外的时间。 ### 回答3: 题目描述 Huffman code是一种贪心算法,用于编码数据,每个字符都对应一种可辨识的前缀二进制码,使得所有字符的编码总长度最短。给定n个权值作为n个叶子结点,构造一棵二叉树,若该树的带权路径长度达到最小,则称这样的二叉树为最优二叉树,也称为赫夫曼树。 在赫夫曼树中,每个叶子节点的权值就是原始数据中的权值,而非叶子节点不存储权值,比较特别的一种二叉树。 输入格式 第1行: 一个整数n(<=1000) 接下来n行: 每行一个整数weight[i](weight[i]<=100000) 输出格式 共n-1行,为赫夫曼编码表,每个字符的赫夫曼编码占据一行。 样例输入1 5 1 3 2 10 5 样例输出1 0 110 111 10 11 样例输入2 5 23 3 6 16 8 样例输出2 100 0 101 1101 1100 解题思路 首先,将所有节点的权值从小到大排序。 接着构造一棵二叉树: 每次从节点集合中选出最小的两个节点(即最小的两个权值) 将这两个点组成一棵新的二叉树,其权值为这两个节点权值之和,这棵新树的左右子树即为这两个节点。 把这棵新树加入到权值序列中,其位置按照新树的权值插入,继续循环,直到权值序列只含有一个节点为止,这个节点就是赫夫曼树的根。 最后,根据赫夫曼树将每个叶子节点的编码求出来,一般情况下,将左子树编码置“0”,右子树编码置“1”,然后做前缀无歧义编码,按照这种编码方式,我们得到了每个节点的Huffman编码。 代码实现

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值