数据结构之哈夫曼树（C语言）

已于 2022-05-29 15:46:08 修改
阅读量4.6k 收藏 129
点赞数 10
文章标签： 数据结构 c语言 霍夫曼树
于 2022-05-29 15:41:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/C2395850595/article/details/125030617
版权

一、哈夫曼树的概念

给定N个权值作为N个叶子结点，构造一棵二叉树，若该树的带权路径长度达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树(Huffman Tree)。哈夫曼树是带权路径长度最短的树，权值较大的结点离根较近。

该代码的核心在于弄懂如何构建哈夫曼树和生成哈夫曼树编码。主要通过找出两个最小值开始作为最底端叶节点，由下到上构建出哈夫曼树。

二、代码步骤

1、定义二叉树和字符指针数组

2、二叉树的初始化

3、查找最小两个值的下标（min1<min2)

4、构建哈夫曼树

5、生成哈夫曼树编码

6、测试代码

7、程序入口

8、运行结果

三、代码功能

1、定义二叉树和字符指针数组

typedef struct HTNode
{
	double weight;
	int parent;
	int lc, rc; 
}*HuffmanTree;

typedef char **HuffmanCode;

2、二叉树的初始化

HuffmanTree initHuffmanTree(HuffmanTree& HT,int n)
{
	int i;
	int m = 2 * n - 1;
	HT = (HuffmanTree)malloc(sizeof(HTNode)*(m + 1));
	for(i = 0; i <= m; i++)
	{
		HT[i].lc = 0;
		HT[i].parent = 0;
		HT[i].rc = 0;
		HT[i].weight = 0;
	}
	return HT;
}

3、查找最小两个值的下标（min1<min2)

void Select(HuffmanTree& HT, int n, int& min1, int& min2)
{
	int min;
	for (int i = 1; i <= n; i++)
	{
		if (HT[i].parent == 0)
		{
			min = i;
			break;
		}
	}
	for (int i = min + 1; i <= n; i++)
	{
		if (HT[i].parent == 0 && HT[i].weight < HT[min].weight)
			min = i;
	}
	min1 = min;
	for (int i = 1; i <= n; i++)
	{
		if (HT[i].parent == 0 && i != min1)
		{
			min = i;
			break;
		}
	}
	for (int i = min + 1; i <= n; i++)
	{
		if (HT[i].parent == 0 && HT[i].weight < HT[min].weight&&i != min1)
			min = i;
	}
	min2 = min;
}

4、构建哈夫曼树

void CreateHuff(HuffmanTree& HT,double* w, int n)
{
	int m = 2 * n - 1; 
	for (int i = 1; i <= n; i++)
	{
		HT[i].weight = w[i - 1];
	}
	for (int i = n + 1; i <= m; i++)
	{
		int min1, min2;
		Select(HT, i - 1, min1, min2);
		HT[i].weight = HT[min1].weight + HT[min2].weight; 
		HT[min1].parent = i; 
		HT[min2].parent = i;
		HT[i].lc = min1; 
		HT[i].rc = min2;
	}
	printf("Huffman is: \n");
	printf("subscript    weight     parent   lchild   rchild\n");
	printf("0                                  \n");
	for (int i = 1; i <= m; i++)
	{
	    printf("%-4d         %-6.2lf      %-6d     %-6d   %-6d\n", i, HT[i].weight, HT[i].parent, HT[i].lc, HT[i].rc);
	}
	printf("\n");
}

5、生成哈夫曼树编码

void HuffCoding(HuffmanTree& HT, HuffmanCode& HC, int n)
{
	HC = (HuffmanCode)malloc(sizeof(char*)*(n + 1));
	char* code = (char*)malloc(sizeof(char)*n);
	code[n - 1] = '\0';
	for (int i = 1; i <= n; i++)
	{
		int start = n - 1; 
		int c = i; 
		int p = HT[c].parent; 
		while (p)
		{
			if (HT[p].lc == c) 
				code[--start] = '0';
			else
				code[--start] = '1';
			c = p;
			p = HT[c].parent; 
		}
		HC[i] = (char*)malloc(sizeof(char)*(n - start));
		strcpy(HC[i], &code[start]); 
	}
	free(code);
}

6、测试代码

void test()
{
	int n = 0;
	printf("input the number of data: ");
	scanf("%d", &n);
	double* w = (double*)malloc(sizeof(double)*n);
	if (n >= 0)
	{
		printf("input the data: ");
	    for (int i = 0; i < n; i++)
	    {
	    	scanf("%lf", &w[i]);
	    }
    	HuffmanTree HT;
    	HT = initHuffmanTree(HT,n);
    	CreateHuff(HT, w, n); 

    	HuffmanCode HC;
    	HuffCoding(HT, HC, n); 

    	for (int i = 1; i <= n; i++)
    	{
    		printf("The data %.2lf code is:  %s\n", HT[i].weight, HC[i]);
    	}
    	free(w);	
	}
	else
	{
		printf("malloc fail\n");
		return;
	}
}

7、程序入口

int main()
{
	test();
	return 1;
}

8、运行结果

input the number of data: 5
input the data: 0.1 0.2 0.3 0.25 0.15
Huffman is:
subscript    weight     parent   lchild   rchild
0
1            0.10        6          0        0
2            0.20        7          0        0
3            0.30        8          0        0
4            0.25        7          0        0
5            0.15        6          0        0
6            0.25        8          1        5
7            0.45        9          2        4
8            0.55        9          6        3
9            1.00        0          7        8

The data 0.10 code is:  100
The data 0.20 code is:  00
The data 0.30 code is:  11
The data 0.25 code is:  01
The data 0.15 code is:  101

四、整体代码

#include <stdio.h>
#include <malloc.h>
#include <string.h>

typedef struct HTNode
{
	double weight;
	int parent;
	int lc, rc; 
}*HuffmanTree;

typedef char **HuffmanCode;

HuffmanTree initHuffmanTree(HuffmanTree& HT,int n)
{
	int i;
	int m = 2 * n - 1;
	HT = (HuffmanTree)malloc(sizeof(HTNode)*(m + 1));
	for(i = 0; i <= m; i++)
	{
		HT[i].lc = 0;
		HT[i].parent = 0;
		HT[i].rc = 0;
		HT[i].weight = 0;
	}
	return HT;
}

void Select(HuffmanTree& HT, int n, int& min1, int& min2)
{
	int min;
	for (int i = 1; i <= n; i++)
	{
		if (HT[i].parent == 0)
		{
			min = i;
			break;
		}
	}
	for (int i = min + 1; i <= n; i++)
	{
		if (HT[i].parent == 0 && HT[i].weight < HT[min].weight)
			min = i;
	}
	min1 = min;
	for (int i = 1; i <= n; i++)
	{
		if (HT[i].parent == 0 && i != min1)
		{
			min = i;
			break;
		}
	}
	for (int i = min + 1; i <= n; i++)
	{
		if (HT[i].parent == 0 && HT[i].weight < HT[min].weight&&i != min1)
			min = i;
	}
	min2 = min;
}

void CreateHuff(HuffmanTree& HT,double* w, int n)
{
	int m = 2 * n - 1; 
	for (int i = 1; i <= n; i++)
	{
		HT[i].weight = w[i - 1];
	}
	for (int i = n + 1; i <= m; i++)
	{
		int min1, min2;
		Select(HT, i - 1, min1, min2);
		HT[i].weight = HT[min1].weight + HT[min2].weight; 
		HT[min1].parent = i; 
		HT[min2].parent = i;
		HT[i].lc = min1; 
		HT[i].rc = min2;
	}
	printf("Huffman is: \n");
	printf("subscript    weight     parent   lchild   rchild\n");
	printf("0                                  \n");
	for (int i = 1; i <= m; i++)
	{
	    printf("%-4d         %-6.2lf      %-6d     %-6d   %-6d\n", i, HT[i].weight, HT[i].parent, HT[i].lc, HT[i].rc);
	}
	printf("\n");
}

void HuffCoding(HuffmanTree& HT, HuffmanCode& HC, int n)
{
	HC = (HuffmanCode)malloc(sizeof(char*)*(n + 1));
	char* code = (char*)malloc(sizeof(char)*n);
	code[n - 1] = '\0';
	for (int i = 1; i <= n; i++)
	{
		int start = n - 1; 
		int c = i; 
		int p = HT[c].parent; 
		while (p)
		{
			if (HT[p].lc == c) 
				code[--start] = '0';
			else
				code[--start] = '1';
			c = p;
			p = HT[c].parent; 
		}
		HC[i] = (char*)malloc(sizeof(char)*(n - start));
		strcpy(HC[i], &code[start]); 
	}
	free(code);
}

void test()
{
	int n = 0;
	printf("input the number of data: ");
	scanf("%d", &n);
	double* w = (double*)malloc(sizeof(double)*n);
	if (n >= 0)
	{
		printf("input the data: ");
	    for (int i = 0; i < n; i++)
	    {
	    	scanf("%lf", &w[i]);
	    }
    	HuffmanTree HT;
    	HT = initHuffmanTree(HT,n);
    	CreateHuff(HT, w, n); 

    	HuffmanCode HC;
    	HuffCoding(HT, HC, n); 

    	for (int i = 1; i <= n; i++)
    	{
    		printf("The data %.2lf code is:  %s\n", HT[i].weight, HC[i]);
    	}
    	free(w);	
	}
	else
	{
		printf("malloc fail\n");
		return;
	}
}

int main()
{
	test();
	return 1;
}

C2395850595
关注
  • 10
    点赞
  • 踩
  • 129
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
哈夫曼树的C语言实现
qq_59978514的博客
08-12 4745
什么是哈夫曼树 当用 n 个结点（都做叶子结点且都有各自的权值）试图构建一棵树时，如果构建的这棵树的带权路径长度最小，称这棵树为“最优二叉树”，有时也叫“赫夫曼树”或者“哈夫曼树”。 在构建哈弗曼树时，要使树的带权路径长度最小，只需要遵循一个原则，那就是：权重越大的结点离树根越近。在图 1 中，因为结点 a 的权值最大，所以理应直接作为根结点的孩子结点。 哈夫曼树相关的几个名词 路径：在一棵树中，一个结点到另一个结点之间的通路，称为路径。图1 中，从根结点到结点 a 之间的通路就是一条路径。 路径长.
  数据结构-C语言-哈夫曼树
05-04
C语言实现的哈夫曼树
【数据结构】【哈夫曼树】哈夫曼树、赫夫曼树（Huffman Tree）C语言实现
crr411422的博客
04-03 3117
1.哈夫曼树又称最优二叉树，是一种带权路径长度最短的二叉树。2.WPL=（W1*L1+W2*L2+W3*L3+...+Wn*Ln）3.构建哈夫曼树方法如下： 在 n 个权值中选出两个最小的权值，对应的两个结点组成一个新的二叉树，且新二叉树的根结点的权值为左右孩子权值的和； 在原有的 n 个权值中删除那两个最小的权值，同时将新的权值加入到n–2 个权值的行列中，以此类推； 重复 1 和 2 ，直到所以的结点构建成了一棵二叉树为止，这棵树就是哈夫曼树。
哈夫曼树
最新发布
m0_55661792的博客
04-26 808
哈夫曼树又称最优二叉树，是一种作用于哈夫曼编码的工具，哈夫曼编码是一种无损压缩编码方式，此种压缩方式可以让原始编码长度更短，从而更节省存储空间和传输带宽。
【哈夫曼树】基本概念、构建过程及C++代码
z135733的博客
06-01 1318
由于普通的C语言实现的代码在大多数地方都能找到，这里就只展示C++改进的代码。给定n个权值分别为w1,w2,…根据树的带权路径长度的计算规则，
（数据结构）哈夫曼树
weixin_51927215的博客
03-31 1415
哈夫曼树相关的几个名词 图1 哈夫曼树 路径：在一棵树中，一个结点到另一个结点之间的通路，称为路径 图 1 中，从根结点到结点 a 之间的通路就是一条路径 路径长度：在一条路径中，每经过一个结点，路径长度都要加 1 图 1 中，从根结点到结点 c 的路径长度为结点的权：给每一个结点赋予一个新的数值，被称为这个结点的权 图 1 中，结点 a 的权为 ，结点 b 的权为结点的带权路径长度：指的是从根结点到该结点之间的路径长度与该结点的权的乘积 ...
哈夫曼树及哈夫曼编码详解【完整版代码】
热门推荐
wardseptember的博客
06-17 11万+
Huffman Tree简介&amp;amp;amp;amp;amp;nbsp; &amp;amp;amp;amp;amp;nbsp; 赫夫曼树（Huffman Tree），又称最优二叉树，是一类带权路径长度最短的树。假设有n个权值{w1,w2,…,wn}，如果构造一棵有n个叶子节点的二叉树，而这n个叶子节点的权值是{w1,w2,…,wn}，则所构造出的带权路径长度最小的二叉树就被称为赫夫曼树。&amp;amp;amp;amp;amp;nbsp; &amp;amp;amp;a
数据结构 哈夫曼树C语言源代码
04-28
数据结构哈夫曼树C语言源代码，很经典，备有详细注释，简单易懂，代码规范，学习数据结构的必看。
数据结构哈夫曼编码译码C语言
03-08
数据结构哈夫曼编码译码C语言 本资源为数据结构哈夫曼编码译码C语言的课程设计报告，报告中详细介绍了哈夫曼编码和译码的实现过程，包括需求分析、总体设计、详细设计和测试结果等部分。 需求分析 本系统的主要...
数据结构课程设计哈夫曼树.doc
12-18
数据结构课程设计哈夫曼树 数据结构课程设计哈夫曼树是计算机科学中的一门重要课程，它涵盖了数据结构的基本概念、设计和实现。本文将详细介绍数据结构课程设计哈夫曼树的知识点，并对其进行深入分析和讨论。 一、...
数据结构哈夫曼树知识点.cpp
03-08
数据结构哈夫曼树知识点.cpp
数据结构哈夫曼树实验代码
02-18
数据结构基于C++的书实验的代码,有需要的可以下载参考
哈夫曼树(c语言)
05-15
用C语言实现哈夫曼树，给定n个权值作为n个叶子结点，构造一棵二叉树，若带权路径长度达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树(Huffman tree)。哈夫曼树是带权路径长度最短的树，权值较大的结点离根较近。
赫夫曼树C语言代码实现（最小二叉树）
05-19
该部分有两个不同的程序，程序根据用户输入的结点值和权重建立哈夫曼树，然后输出哈夫曼编码
哈夫曼树c语言编写
08-30
哈夫曼树构造 输出
哈夫曼树的c语言实现
02-03
哈夫曼树c语言
哈夫曼树的简单实现（C语言）
Lucky Home
04-08 7918
书上二叉树后面就到哈夫曼树了，过一阵就要整这个的实验课了，趁着这次机会赶快自学下，不知道写的如何，希望大家多多指正吧。 哈夫曼树 给定N个权值作为N个叶子结点，构造一棵二叉树，若该树的带权路径长度达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树(Huffman Tree)。哈夫曼树是带权路径长度最短的树，权值较大的结点离根较近。 基本术语 哈夫曼树又称为最优树. 1、路径和路径长度 在一棵树中，从一个结点往下可以达到的孩子或孙子结点之间的通路，称为路径。通路中分支的数目称为路径长度。若规定根结点的层数为
哈夫曼树与哈夫曼编码
Y_23k_bug的专栏
07-26 5853
在一般的数据结构的书中，树的那章后面，著者一般都会介绍一下哈夫曼(HUFFMAN) 树和哈夫曼编码。哈夫曼编码是哈夫曼树的一个应用。哈夫曼编码应用广泛，如 JPEG中就应用了哈夫曼编码。 首先介绍什么是哈夫曼树。哈夫曼树又称最优二叉树， 是一种带权路径长度最短的二叉树。所谓树的带权路径长度，就是树中所有的叶结点 的权值乘上其到根结点的 路径长度（若根结点为0层，叶结点到根结
数据结构（C语言）-哈夫曼（Huffman）树编码译码操作
qq_44025638的博客
11-17 1万+
huffman树的编码和译码操作
哈夫曼树C语言
05-25
以下是哈夫曼树的C语言实现代码： ```c #include <stdio.h> #include <stdlib.h> #include <string.h> #define MAX_TREE_HT 100 struct MinHeapNode { char data; unsigned freq; struct MinHeapNode *left, *right; }; struct MinHeap { unsigned size; unsigned capacity; struct MinHeapNode **array; }; struct MinHeapNode* newNode(char data, unsigned freq) { struct MinHeapNode* node = (struct MinHeapNode*) malloc(sizeof(struct MinHeapNode)); node->left = node->right = NULL; node->data = data; node->freq = freq; return node; } struct MinHeap* createMinHeap(unsigned capacity) { struct MinHeap* minHeap = (struct MinHeap*) malloc(sizeof(struct MinHeap)); minHeap->size = 0; minHeap->capacity = capacity; minHeap->array = (struct MinHeapNode**) malloc(minHeap->capacity * sizeof(struct MinHeapNode*)); return minHeap; } void swapMinHeapNode(struct MinHeapNode** a, struct MinHeapNode** b) { struct MinHeapNode* t = *a; *a = *b; *b = t; } void minHeapify(struct MinHeap* minHeap, int idx) { int smallest = idx; int left = 2 * idx + 1; int right = 2 * idx + 2; if (left < minHeap->size && minHeap->array[left]->freq < minHeap->array[smallest]->freq) smallest = left; if (right < minHeap->size && minHeap->array[right]->freq < minHeap->array[smallest]->freq) smallest = right; if (smallest != idx) { swapMinHeapNode(&minHeap->array[smallest], &minHeap->array[idx]); minHeapify(minHeap, smallest); } } int isSizeOne(struct MinHeap* minHeap) { return (minHeap->size == 1); } struct MinHeapNode* extractMin(struct MinHeap* minHeap) { struct MinHeapNode* temp = minHeap->array[0]; minHeap->array[0] = minHeap->array[minHeap->size - 1]; --minHeap->size; minHeapify(minHeap, 0); return temp; } void insertMinHeap(struct MinHeap* minHeap, struct MinHeapNode* minHeapNode) { ++minHeap->size; int i = minHeap->size - 1; while (i && minHeapNode->freq < minHeap->array[(i - 1) / 2]->freq) { minHeap->array[i] = minHeap->array[(i - 1) / 2]; i = (i - 1) / 2; } minHeap->array[i] = minHeapNode; } void buildMinHeap(struct MinHeap* minHeap) { int n = minHeap->size - 1; int i; for (i = (n - 1) / 2; i >= 0; --i) minHeapify(minHeap, i); } void printArr(int arr[], int n) { int i; for (i = 0; i < n; ++i) printf("%d", arr[i]); printf("\n"); } int isLeaf(struct MinHeapNode* root) { return !(root->left) && !(root->right); } struct MinHeap* createAndBuildMinHeap(char data[], int freq[], int size) { struct MinHeap* minHeap = createMinHeap(size); for (int i = 0; i < size; ++i) minHeap->array[i] = newNode(data[i], freq[i]); minHeap->size = size; buildMinHeap(minHeap); return minHeap; } struct MinHeapNode* buildHuffmanTree(char data[], int freq[], int size) { struct MinHeapNode *left, *right, *top; struct MinHeap* minHeap = createAndBuildMinHeap(data, freq, size); while (!isSizeOne(minHeap)) { left = extractMin(minHeap); right = extractMin(minHeap); top = newNode('$', left->freq + right->freq); top->left = left; top->right = right; insertMinHeap(minHeap, top); } return extractMin(minHeap); } void printCodes(struct MinHeapNode* root, int arr[], int top) { if (root->left) { arr[top] = 0; printCodes(root->left, arr, top + 1); } if (root->right) { arr[top] = 1; printCodes(root->right, arr, top + 1); } if (isLeaf(root)) { printf("%c: ", root->data); printArr(arr, top); } } void HuffmanCodes(char data[], int freq[], int size) { struct MinHeapNode* root = buildHuffmanTree(data, freq, size); int arr[MAX_TREE_HT], top = 0; printCodes(root, arr, top); } int main() { char arr[] = {'a', 'b', 'c', 'd', 'e', 'f'}; int freq[] = {5, 9, 12, 13, 16, 45}; int size = sizeof(arr) / sizeof(arr[0]); HuffmanCodes(arr, freq, size); return 0; } ``` 该代码实现了哈夫曼树的构建和编码过程。其中，创建和构建最小堆的代码已经实现了，因此主要实现了哈夫曼树的构建和编码的函数。在HuffmanCodes函数中调用buildHuffmanTree函数构建哈夫曼树，然后调用printCodes函数打印每个字符的编码。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值