8609 哈夫曼树

于 2021-06-14 10:04:46 发布
阅读量746 收藏 6
点赞数 2
分类专栏： # SCAU数据结构 文章标签： 哈弗曼树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Hunter_Kevin/article/details/117898351
版权
该程序实现了从用户输入的权值构建哈夫曼树，并计算得到每个权值对应的哈夫曼编码。通过选择最小权值的节点合并构建树，并逆向遍历从叶子到根节点得到编码。程序提供了简洁版和完整版两种实现，适用于数据结构和算法的学习与理解。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

Description 利用静态链表建立赫夫曼树，建树过程中要求左子树权值小于右子树权值，求各结点的编码。要求：叶子结点的个数n及结点值由键盘录入。本题给出程序代码,要求修改以满足测试要求.
#include “stdio.h”
#include “malloc.h”
#include “string.h”
typedef struct{
unsigned int weight;
unsigned int parent,lchild,rchild;
}HTNode,*HuffmanTree;
typedef char **HuffmanCode;
void Select(HuffmanTree &HT, int n, int &s1, int &s2)
//在HT[1…n]中选择parent为0且weight最小的两个结点，
// 其序号分别为s1和s2。
{
int i;
s1=-1;s2=-1;
for (i=1;i<=n;i++) {
if (HT[i].parent0)
if (s1-1) s1=i;
else
if (s2==-1 )
if (HT[i].weight0)，构造哈夫曼树HT，
// 并求出n个字符的哈夫曼编码HC
int i, j, m, s1, s2, start;
char *cd;
unsigned int c, f;
if (n<=1) return;
m = 2 * n - 1;
HT = (HuffmanTree)malloc((m+1) * sizeof(HTNode)); // 0号单元未用
for (i=1; i<=n; i++) { //初始化
HT[i].weight=w[i-1];
HT[i].parent=0;
HT[i].lchild=0;
HT[i].rchild=0;
}
for (i=n+1; i<=m; i++) { //初始化
HT[i].weight=0;
HT[i].parent=0;
HT[i].lchild=0;
HT[i].rchild=0;
}
printf("\n哈夫曼树的构造过程如下所示：\n");
printf(“HT初态:\n 结点 weight parent lchild rchild”);
for (i=1; i<=m; i++)
printf("\n%4d%8d%8d%8d%8d",i,HT[i].weight,
HT[i].parent,HT[i].lchild, HT[i].rchild);
printf(" 按任意键，继续 …");
getch();
for (i=n+1; i<=m; i++) { // 建哈夫曼树
// 在HT[1…i-1]中选择parent为0且weight最小的两个结点，
// 其序号分别为s1和s2。
Select(HT, i-1, s1, s2);
HT[s1].parent = i; HT[s2].parent = i;
HT[i].lchild = s1; HT[i].rchild = s2;
HT[i].weight = HT[s1].weight + HT[s2].weight;
printf("\nselect: s1=%d s2=%d\n", s1, s2);
printf(" 结点 weight parent lchild rchild");
for (j=1; j<=i; j++)
printf("\n%4d%8d%8d%8d%8d",j,HT[j].weight,HT[j].parent,HT[j].lchild, HT[j].rchild);
printf(" 按任意键，继续 …");
getch();
}
//— 从叶子到根逆向求每个字符的哈夫曼编码 —
cd = (char )malloc(nsizeof(char)); // 分配求编码的工作空间
cd[n-1] = ‘\0’; // 编码结束符。
for (i=1; i<=n; ++i) { // 逐个字符求哈夫曼编码
start = n-1; // 编码结束符位置
for (c=i, f=HT[i].parent; f!=0; c=f, f=HT[f].parent)
// 从叶子到根逆向求编码
if (HT[f].lchild==c) cd[–start] = ‘0’;
else cd[–start] = ‘1’;
HC[i] = (char *)malloc((n-start)*sizeof(char));
// 为第i个字符编码分配空间
strcpy(HC[i], &cd[start]); // 从cd复制编码(串)到HC

}
free(cd); //释放工作空间
} //HuffmanCoding

void main()
{
int i,n;
int *w;
HuffmanTree HT;
HuffmanCode HC;
printf(“Node Number:”);
scanf("%d",&n); //权值个数
w=(int )malloc(nsizeof(int));
printf(“Input weights:”);
for ( i=0;i<n;i++) //录入权值
scanf("%d",&w[i]);

HC=(char **)malloc((n+1)sizeof(char)); //0空间未用
HT=(HuffmanTree)malloc((2*n+1+1)*sizeof(HTNode));//0空间未用
HuffmanCoding(HT, HC, w, n);
printf("\n");
for (i = 1; i<n+1; i++){
puts(HC[i]); //输出哈夫曼编码
free(HC[i]); //释放空间
}
free(HC);
free(HT);
}//main

输入格式
第一行：权值个数
第二行：输入n个权值，用空格分隔

输出格式
输出n行
每行表示各权值对应的哈夫曼编码

输入样例
8
5 29 7 8 14 23 3 11

输出样例
0001
10
1110
1111
110
01
0000
001

oj代码：

#include "stdio.h"
#include "malloc.h"
#include "string.h"
typedef struct
{
    unsigned int weight;
    unsigned int parent,lchild,rchild;
} HTNode,*HuffmanTree;
typedef char **HuffmanCode;

void Select(HuffmanTree HT, int x, int& s1, int& s2)
{
    int i;
    HT[0].weight = 1e9;//初始化为大值
    s1 = s2 = 0;
    for (i = 1; i <= x; i++)
    {
        if (HT[i].parent == 0)
        {
            if (HT[s1].weight > HT[i].weight)//查找最小值，把下标赋值给s1
                s2 = s1, s1 = i;
            else if (HT[s2].weight > HT[i].weight)//更新第二小的下标，只需跟当前第二小的值进行比较即可
                s2 = i;
        }
    }
}

void HuffmanCoding(HuffmanTree &HT, char **HC, int *w, int n)
{
    int i, j, m, s1, s2, start;
    char *cd;
    unsigned int c, f;
    if (n<=1) return;
    m = 2 * n - 1;
    HT = (HuffmanTree)malloc((m+1) * sizeof(HTNode));  // 0号单元未用
    for (i=1; i<=n; i++)   //初始化
    {
        HT[i].weight=w[i-1];
        HT[i].parent=0;
        HT[i].lchild=0;
        HT[i].rchild=0;
    }
    for (i=n+1; i<=m; i++)   //初始化
    {
        HT[i].weight=0;
        HT[i].parent=0;
        HT[i].lchild=0;
        HT[i].rchild=0;
    }
//  printf("\n哈夫曼树的构造过程如下所示：\n");
//  printf("HT初态:\n  结点  weight  parent  lchild  rchild");
//  for (i=1; i<=m; i++)
//    printf("\n%4d%8d%8d%8d%8d",i,HT[i].weight,
//            HT[i].parent,HT[i].lchild, HT[i].rchild);
//    printf("    按任意键，继续 ...");
//  getch();

    for (i=n+1; i<=m; i++)    // 建哈夫曼树
    {
        // 在HT[1..i-1]中选择parent为0且weight最小的两个结点，
        // 其序号分别为s1和s2。
        Select(HT, i-1, s1, s2);
        HT[s1].parent = i;
        HT[s2].parent = i;
        HT[i].lchild = s1;
        HT[i].rchild = s2;
        HT[i].weight = HT[s1].weight + HT[s2].weight;
//    printf("\nselect: s1=%d   s2=%d\n", s1, s2);
//    printf("  结点  weight  parent  lchild  rchild");
//    for (j=1; j<=i; j++)
//      printf("\n%4d%8d%8d%8d%8d",j,HT[j].weight,HT[j].parent,HT[j].lchild, HT[j].rchild);
//    printf("    按任意键，继续 ...");
//    getch();
    }
//--- 从叶子到根逆向求每个字符的哈夫曼编码 ---
    cd = (char *)malloc(n*sizeof(char));    // 分配求编码的工作空间
    cd[n-1] = '\0';                         // 编码结束符。
    for (i=1; i<=n; ++i)                    // 逐个字符求哈夫曼编码
    {
        start = n-1;                          // 编码结束符位置
        for (c=i, f=HT[i].parent; f!=0; c=f, f=HT[f].parent)
            // 从叶子到根逆向求编码
            if (HT[f].lchild==c) cd[--start] = '0';
            else cd[--start] = '1';
        HC[i] = (char *)malloc((n-start)*sizeof(char));
        // 为第i个字符编码分配空间
        strcpy(HC[i], &cd[start]);    // 从cd复制编码(串)到HC

    }
    free(cd);   //释放工作空间
} //HuffmanCoding

int main()
{
    int i,n;
    int *w;
    HuffmanTree HT;
    HuffmanCode HC;
//   printf("Node Number:");
    scanf("%d",&n);  //权值个数
    w=(int *)malloc(n*sizeof(int));
//   printf("Input weights:");
    for ( i=0; i<n; i++) //录入权值
        scanf("%d",&w[i]);

    HC=(char **)malloc((n+1)*sizeof(char*)); //0空间未用
    HT=(HuffmanTree)malloc((2*n+1+1)*sizeof(HTNode));//0空间未用
    HuffmanCoding(HT, HC, w, n);
//    printf("\n");
    for (i = 1; i<n+1; i++)
    {
        puts(HC[i]);  //输出哈夫曼编码
        free(HC[i]);  //释放空间
    }
    free(HC);
    free(HT);
}//main

简洁版代码：

在这里插入代码片#include <stdio.h>
#include <malloc.h>
#include <iostream>
#include <cstring>
using namespace std;
typedef struct
{
    int weight;
    int parent, lchild, rchild;
}HTNode, * HuffmanTree;
typedef char** HuffmanCode;
void select(HuffmanTree HT, int x, int& s1, int& s2)
{
    int i;
    s1 = s2 = 0;
    for (i = 1; i <= x; i++)
    {
        if (HT[i].parent == 0)
        {
            if (HT[s1].weight > HT[i].weight)//查找最小值，把下标赋值给s1
                s2 = s1, s1 = i;
            else if (HT[s2].weight > HT[i].weight)//更新第二小的下标，只需跟当前第二小的值进行比较即可
                s2 = i;
        }
    }
}

void creatHuffmanTree(HuffmanTree& HT, int n)
{
    if (n <= 1)
        return;
    int i, m;
    m = 2 * n - 1;//哈弗曼树的根节点的下标
    HT = (HuffmanTree)malloc(sizeof(HTNode) * (m + 1));//动态分配2n个结点的内存，0号单元不使用
    for (i = 1; i <= 2 * n - 1; i++)//初始化2n-1个内存
    {
        HT[i].parent = 0;
        HT[i].lchild = 0;
        HT[i].rchild = 0;
    }

    for (i = 1; i <= n; i++)//输入n个叶子节点的权值
        cin >> HT[i].weight;

    HT[0].weight = 1e9;//初始化为大值
    for (i = n + 1; i <= 2 * n - 1; i++)
    {
        int s1, s2;
        select(HT, i - 1, s1, s2);//从1到i-1个节点中挑两个最小节点，返回下标s1,s2,而i作为新和成的结点
        HT[s1].parent = i, HT[s2].parent = i;//给最小的两个结点的父节点赋值
        HT[i].lchild = s1, HT[i].rchild = s2;//生成新结点
        HT[i].weight = HT[s1].weight + HT[s2].weight;
    }
    return;
}
//方案一
//void creatHuffmanCode(HuffmanTree HT, HuffmanCode& HC, int n)
//{
//    HC = (char**)malloc(sizeof(char*) * (n + 1));
//    char* cd = (char*)malloc(sizeof(char) * n);
//    cd[n - 1] = '\0';
//    int i;
//    for (i = 1; i <= n; i++)
//    {
//        int father_index = HT[i].parent, cur_index = i, start = n - 1;
//        while (father_index != 0)
//        {
//            if (HT[father_index].lchild == cur_index)
//                cd[--start] = '0';
//            else
//                cd[--start] = '1';
//            cur_index = father_index;
//            father_index = HT[father_index].parent;
//        }
//        HC[i] = (char*)malloc(sizeof(char) * (n - start));
//        strcpy(HC[i], cd + start);
//    }
//    free(cd);
//    return;
//}

//方案二
void creatHuffmanCode(HuffmanTree HT, HuffmanCode& HC, int n)
{
    HC = (char**)malloc(sizeof(char*) * (n + 1));
    int i, j;
    char* temp = (char*)malloc(sizeof(char) * n);
    for (i = 1; i <= n; i++)
    {
        int p = i, count = 0;;
        while (HT[p].parent != 0)
        {
            if (p == HT[HT[p].parent].lchild)
               temp[count++] = '0';
            else
                temp[count++] = '1';
            p = HT[p].parent;
        }
        temp[count] = '\0';
        int len = strlen(temp);
        HC[i] = (char*)malloc(sizeof(char) * len);
        HC[i][len] = '\0';
        for (j = 0; j < len; j++)
        {
            HC[i][j] = temp[len - 1 - j];
        }
    }
    free(temp);
    return;
}

int main()
{
    int n, i;
    cin >> n;//输入权值个数n
    HuffmanTree HT;
    HuffmanCode HC;
    creatHuffmanTree(HT, n);
    creatHuffmanCode(HT, HC, n);
    for (i = 1; i <= n; i++)
        printf("%s\n",HC[i]);

    return 0;
}
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值