树--哈夫曼树

哈夫曼树（Huffman Tree）是一种常用于数据压缩的二叉树，其主要思想是用较短的编码表示频率较高的字符，从而达到压缩数据的目的。哈夫曼树在信息编码、数据压缩等领域有广泛的应用。本文将通过一个完整的C语言代码示例，展示如何实现哈夫曼树及其编码。

哈夫曼树的基本原理

哈夫曼树是一种带权路径长度最短的二叉树，主要特点是：

• 每个叶子节点代表一个字符及其出现的频率（权重）。
• 非叶子节点不代表具体字符，其权重为其子节点权重之和。
• 权重较大的节点离根较近，权重较小的节点离根较远。

构建哈夫曼树的步骤如下：

1. 初始化：每个字符对应一个节点，将所有节点放入一个优先队列（最小堆）。
2. 构建树：从最小堆中取出两个权重最小的节点，创建一个新节点，其权重为两个节点权重之和，并将两个节点作为新节点的左右子树。将新节点加入最小堆。
3. 重复步骤2，直到最小堆中只剩下一个节点，该节点即为哈夫曼树的根节点。

   #include <stdio.h>
   #include <stdlib.h>
   
   // 哈夫曼树的节点
   typedef struct HuffmanNode {
       char data; // 数据域
       int weight; // 权重
       struct HuffmanNode *left, *right; // 左右子树
   } HuffmanNode;
   
   // 小顶堆结构
   typedef struct MinHeap {
       int size; // 堆的大小
       int capacity; // 堆的容量
       HuffmanNode **array; // 指向节点数组的指针
   } MinHeap;
   
   // 创建一个新节点
   HuffmanNode* newNode(char data, int weight) {
       HuffmanNode* temp = (HuffmanNode*)malloc(sizeof(HuffmanNode));
       temp->left = temp->right = NULL;
       temp->data = data;
       temp->weight = weight;
       return temp;
   }
   
   // 创建一个最小堆
   MinHeap* createMinHeap(int capacity) {
       MinHeap* minHeap = (MinHeap*)malloc(sizeof(MinHeap));
       minHeap->size = 0;
       minHeap->capacity = capacity;
       minHeap->array = (HuffmanNode**)malloc(minHeap->capacity * sizeof(HuffmanNode*));
       return minHeap;
   }
   
   // 交换两个最小堆的节点
   void swapMinHeapNode(HuffmanNode** a, HuffmanNode** b) {
       HuffmanNode* t = *a;
       *a = *b;
       *b = t;
   }
   
   // 最小堆化
   void minHeapify(MinHeap* minHeap, int idx) {
       int smallest = idx;
       int left = 2 * idx + 1;
       int right = 2 * idx + 2;
   
       if (left < minHeap->size && minHeap->array[left]->weight < minHeap->array[smallest]->weight)
           smallest = left;
   
       if (right < minHeap->size && minHeap->array[right]->weight < minHeap->array[smallest]->weight)
           smallest = right;
   
       if (smallest != idx) {
           swapMinHeapNode(&minHeap->array[smallest], &minHeap->array[idx]);
           minHeapify(minHeap, smallest);
       }
   }
   
   // 检查最小堆的大小是否为1
   int isSizeOne(MinHeap* minHeap) {
       return (minHeap->size == 1);
   }
   
   // 提取最小值节点
   HuffmanNode* extractMin(MinHeap* minHeap) {
       HuffmanNode* temp = minHeap->array[0];
       minHeap->array[0] = minHeap->array[minHeap->size - 1];
       --minHeap->size;
       minHeapify(minHeap, 0);
       return temp;
   }
   
   // 插入一个节点到最小堆
   void insertMinHeap(MinHeap* minHeap, HuffmanNode* minHeapNode) {
       ++minHeap->size;
       int i = minHeap->size - 1;
       while (i && minHeapNode->weight < minHeap->array[(i - 1) / 2]->weight) {
           minHeap->array[i] = minHeap->array[(i - 1) / 2];
           i = (i - 1) / 2;
       }
       minHeap->array[i] = minHeapNode;
   }
   
   // 建立并初始化最小堆
   void buildMinHeap(MinHeap* minHeap) {
       int n = minHeap->size - 1;
       int i;
       for (i = (n - 1) / 2; i >= 0; --i)
           minHeapify(minHeap, i);
   }
   
   // 创建并构建最小堆
   MinHeap* createAndBuildMinHeap(char data[], int weight[], int size) {
       MinHeap* minHeap = createMinHeap(size);
       for (int i = 0; i < size; ++i)
           minHeap->array[i] = newNode(data[i], weight[i]);
       minHeap->size = size;
       buildMinHeap(minHeap);
       return minHeap;
   }
   
   // 构建哈夫曼树
   HuffmanNode* buildHuffmanTree(char data[], int weight[], int size) {
       HuffmanNode *left, *right, *top;
       MinHeap* minHeap = createAndBuildMinHeap(data, weight, size);
   
       while (!isSizeOne(minHeap)) {
           left = extractMin(minHeap);
           right = extractMin(minHeap);
   
           top = newNode('$', left->weight + right->weight);
           top->left = left;
           top->right = right;
   
           insertMinHeap(minHeap, top);
       }
       return extractMin(minHeap);
   }
   
   // 打印哈夫曼编码
   void printCodes(HuffmanNode* 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 (!root->left && !root->right) {
           printf("%c: ", root->data);
           for (int i = 0; i < top; ++i)
               printf("%d", arr[i]);
           printf("\n");
       }
   }
   
   // 构建并打印哈夫曼编码
   void HuffmanCodes(char data[], int weight[], int size) {
       HuffmanNode* root = buildHuffmanTree(data, weight, size);
       int arr[100], top = 0;
       printCodes(root, arr, top);
   }
   
   // 测试函数
   int main() {
       char data[] = {'a', 'b', 'c', 'd', 'e', 'f'};
       int weight[] = {5, 9, 12, 13, 16, 45};
       int size = sizeof(data) / sizeof(data[0]);
   
       printf("字符的哈夫曼编码:\n");
       HuffmanCodes(data, weight, size);
   
       return 0;
   }
   

1. HuffmanNode：定义哈夫曼树的节点结构，包含字符数据、权重以及左右子树的指针。
2. MinHeap：定义最小堆结构，包含堆的大小、容量以及指向节点数组的指针。
3. newNode：创建一个新哈夫曼树节点。
4. createMinHeap：创建一个空的最小堆。
5. swapMinHeapNode：交换两个最小堆节点。
6. minHeapify：对最小堆进行堆化操作，保持最小堆性质。
7. isSizeOne：检查最小堆的大小是否为1。
8. extractMin：提取最小堆中的最小值节点。
9. insertMinHeap：插入一个节点到最小堆中。
10. buildMinHeap：建立并初始化最小堆。
11. createAndBuildMinHeap：创建并构建最小堆，将数据和权重初始化为最小堆节点。
12. buildHuffmanTree：构建哈夫曼树，利用最小堆迭代构建哈夫曼树。
13. printCodes：递归打印哈夫曼树的编码。
14. HuffmanCodes：构建哈夫曼树并打印哈夫曼编码。
15. main：测试函数，初始化字符和权重数组，并调用 HuffmanCodes 函数打印哈夫曼编码。

运行结果：