哈夫曼树外加编码

最新推荐文章于 2024-09-06 10:38:06 发布
最新推荐文章于 2024-09-06 10:38:06 发布
阅读量50 收藏
点赞数
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hexinchaode/article/details/132886184
版权 

```c
#include <conio.h>
#include <stdio.h>
#include <process.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>
#include <fstream>
#define max 100
#include <iostream>
using namespace std;
#define supermax  100000

struct BiTNode
{                  // 二叉树结点类型
   char symbol;
   int data;      // 数据
   int tem1, tem2; // 辅助数据（实习题不用）
   BiTNode *left;  // 左子树指针
   BiTNode *right; // 右子树指针
};

struct HuffmanCode {
    char character;
    char* code;
} ;


void getWidth1(BiTNode *Tree, int depth, int shift, char map[max*2][max*2])
{
	int i;

	if (Tree->left != NULL)
	{
		getWidth1(Tree->left, depth+1, shift, map);
		Tree->tem1 = Tree->left->tem1 + Tree->left->tem2 + 1;
		for (i=(Tree->left->tem1+shift)*2; i<shift*2; i=i+2)
		{
			map[depth*2+1][i]='-';
			map[depth*2+1][i+1]='-';
		}
	}
	else Tree->tem1 = 0;
	if (Tree->right != NULL)
	{
		getWidth1(Tree->right, depth+1, shift+Tree->tem1+1, map);
		Tree->tem2 = Tree->right->tem1 + Tree->right->tem2 + 1;
	}
	else Tree->tem2 = 0;

	for (i=shift*2; i<(Tree->tem1+shift)*2; i++)
		map[depth*2][i]=' ';
	
	map[depth*2][(Tree->tem1+shift)*2]=(char)(Tree->data / 1000 +48);
	map[depth*2][(Tree->tem1+shift)*2+1]=(char)(Tree->data / 100 % 10 +48);
	map[depth*2][(Tree->tem1+shift)*2+2]=(char)(Tree->data / 10 % 10 +48);
	map[depth*2][(Tree->tem1+shift)*2+3]=(char)(Tree->data %10 +48);
	if (Tree->data<1000)
	{
		map[depth*2][(Tree->tem1+shift)*2]=' ';
		if (Tree->data<100)
		{
			map[depth*2][(Tree->tem1+shift)*2+1]=map[depth*2][(Tree->tem1+shift)*2+2];
			map[depth*2][(Tree->tem1+shift)*2+2]=map[depth*2][(Tree->tem1+shift)*2+3];
			map[depth*2][(Tree->tem1+shift)*2+3]=' ';
			if (Tree->data<10)
				map[depth*2][(Tree->tem1+shift)*2+1]=' ';
		}
	}

	if (Tree->left != NULL)
	{
		map[depth*2+1][(Tree->left->tem1+shift)*2+1]=(char)0xa9;
		map[depth*2+1][(Tree->left->tem1+shift)*2+2]=(char)0xb0;
		map[depth*2+1][(Tree->tem1+shift)*2+1]=(char)0xa9;
		map[depth*2+1][(Tree->tem1+shift)*2+2]=(char)0xbc;
		for (i=(Tree->left->tem1+shift)*2+3; i<(Tree->tem1+shift)*2; i=i+2)
		{
			map[depth*2+1][i]=(char)0xa9;
			map[depth*2+1][i+1]=(char)0xa4;
		}
	}
	if (Tree->right != NULL)
	{
		map[depth*2+1][(Tree->tem1+shift)*2+1]=(char)0xa9;
		map[depth*2+1][(Tree->tem1+shift)*2+2]=(char)0xb8;
		map[depth*2+1][(Tree->tem1+Tree->right->tem1+shift)*2+3]=(char)0xa9;
		map[depth*2+1][(Tree->tem1+Tree->right->tem1+shift)*2+4]=(char)0xb4;
		for (i=(Tree->tem1+shift)*2+3; i<(Tree->tem1+Tree->right->tem1+shift)*2+2; i=i+2)
		{
			map[depth*2+1][i]=(char)0xa9;
			map[depth*2+1][i+1]=(char)0xa4;
		}
	}
	if (Tree->left != NULL && Tree->right != NULL)
	{
		map[depth*2+1][(Tree->tem1+shift)*2+1]=(char)0xa9;
		map[depth*2+1][(Tree->tem1+shift)*2+2]=(char)0xd8;
	}

}

//生成文件Map.txt，显示以Tree为根指针的二叉树
void showBinTree1(BiTNode *Tree)
{
	
	char map[max*2][max*2];
	ofstream out;
	int i,j,k;

	out.open("Map.txt");
	if (Tree == NULL)
	{
		out<<"空树";
		out.close();
		return;
	}
	for (i=0; i<max*2; i++)
		for (j=0; j<max*2; j++)
			map[i][j]=' ';
	getWidth1(Tree,0,0,map);
	for (i=0; i<max*2; i++)
	{
		k=max*2-1; 
		while (k>=0 && map[i][k]==' ')
			k--;

		for (j=0; j<=k; j++)
		    out<<map[i][j];	
		out<<"\n";
	}
	out.close();
}

BiTNode *createNode(int data, char symbol) {
    BiTNode* newNode = (BiTNode *)malloc(sizeof(BiTNode));
    newNode->data = data;
    newNode->symbol = symbol;
    newNode->left = NULL;
    newNode->right = NULL;
    return newNode;
}

//构建哈夫曼树
BiTNode *buildHuffmanTree(char symbols[], int frequencies[], int size) {
    // 创建叶子节点
    BiTNode** nodes = (BiTNode**)malloc(size * sizeof(BiTNode*));
    for (int i = 0; i < size; i++) {
        nodes[i] = createNode(frequencies[i], symbols[i]);
    }//这里要考，理论上有2n-1个节点

    // 构建哈夫曼树
    while (size > 1) {
        BiTNode *leftChild = NULL;
        BiTNode *rightChild = NULL;
        int minIndex1 = -1;
        int minIndex2 = -1;

        // 找到频率最小的两个节点
        for (int i = 0; i < size; i++) {
            if (minIndex1 == -1 || nodes[i]->data < nodes[minIndex1]->data) {
                minIndex2 = minIndex1;
                minIndex1 = i;
            }
            else if (minIndex2 == -1 || nodes[i]->data < nodes[minIndex2]->data) {
                minIndex2 = i;
            }
        }

        // 创建新节点作为它们的父节点
        leftChild = nodes[minIndex1];
        rightChild = nodes[minIndex2];
        BiTNode *parentNode = createNode(leftChild->data + rightChild->data, '\0');
        parentNode->left = leftChild;
        parentNode->right = rightChild;

		// 删除两个子节点
		

        //错误写法
        /*
            if (minIndex1 < minIndex2) {
                nodes[minIndex1] = parentNode;
                for (int i = minIndex2; i < size - 1; i++) {
                    nodes[i] = nodes[i + 1];
                }
            }
            
            else if(minIndex2 < minIndex1){
                
                nodes[minIndex2] = parentNode;
                int i = minIndex1;
                for (int i  = minIndex1; i < size-1; i++) {//在这里如果没有int i  = minIndex1或者int k = size，就会出现赋值错误
                    nodes[i] = nodes[i + 1];
                }
                
            }
        */
        int k = size;
        // 更新节点数组
        if (minIndex1 < minIndex2) {
            nodes[minIndex1] = parentNode;
            for (int i = minIndex2; i < k - 1; i++) {
                nodes[i] = nodes[i + 1];
            }
        }
        
        else if(minIndex2 < minIndex1){//交换nodes里边的位置从大到小，并将parent存入
            
            nodes[minIndex2] = parentNode;
            int i = minIndex1;
            for (i ; i < k-1; i++) {//在这里如果没有int i  = minIndex1或者int k = size，就会出现赋值错误
                nodes[i] = nodes[i + 1];
            }
            
        }

        size--;
        
    }

    // 返回根节点
    return nodes[0];
}



void sortNodes(struct BiTNode** nodes, int size) {
    for (int i = 0; i < size - 1; i++) {
        for (int j = 0; j < size - i - 1; j++) {
            if (nodes[j]->data < nodes[j + 1]->data) {
                struct BiTNode* temp = nodes[j];
                nodes[j] = nodes[j + 1];
                nodes[j + 1] = temp;
            }
        }
    }
}

// 构建哈夫曼树
// BiTNode* buildHuffmanTree(char symbols[], int frequencies[], int size) {
//     // 创建叶子节点
//     BiTNode** nodes = (BiTNode**)malloc(size * sizeof(BiTNode*));
//     for (int i = 0; i < size; i++) {
//         nodes[i] = createNode(frequencies[i], symbols[i]);
//     }

//     // 对节点按照频率从大到小排序（可以使用冒泡、插入或快速排序等算法）
//     for (int i = 0; i < size - 1; i++) {
//         for (int j = 0; j < size - i - 1; j++) {
//             if (nodes[j]->data < nodes[j + 1]->data) {
//                 // 交换节点
//                 BiTNode* temp = nodes[j];
//                 nodes[j] = nodes[j + 1];
//                 nodes[j + 1] = temp;
//             }
//         }
//     }

//     // 构建哈夫曼树
//     while (size > 1) {
//         BiTNode *leftChild = nodes[size - 1]; // 取最后两个节点（频率最小的）
//         BiTNode *rightChild = nodes[size - 2];
//         BiTNode *parentNode = createNode(leftChild->data + rightChild->data, '\0');
//         parentNode->left = leftChild;
//         parentNode->right = rightChild;

//         // 删除已经合并的两个子节点
//         free(leftChild);
//         free(rightChild);

//         // 更新节点数组，保持有序
//         int insertIndex = size - 2;
//         while (insertIndex > 0 && parentNode->data < nodes[insertIndex - 1]->data) {
//             nodes[insertIndex] = nodes[insertIndex - 1];
//             insertIndex--;
//         }
//         nodes[insertIndex] = parentNode;

//         size--;
//     }

//     // 返回根节点
//     return nodes[0];
// }

// 释放哈夫曼树内存
void freeHuffmanTree(struct BiTNode* root) {
    if (root) {
        freeHuffmanTree(root->left);
        freeHuffmanTree(root->right);
        free(root);
    }
}


// 打印哈夫曼编码
void printHuffmanCodes(BiTNode *root, int code[], int top) {
    if (root->left) {
        code[top] = 0;
        printHuffmanCodes(root->left, code, top + 1);
    }

    if (root->right) {
        code[top] = 1;
        printHuffmanCodes(root->right, code, top + 1);
    }

    if (root->symbol != '\0') {
        printf("%c: ", root->symbol);
        for (int i = 0; i < top; i++) {
            printf("%d", code[i]);
        }
        printf("\n");
    }
}

void writeHuffmanCodesToFile(BiTNode *root, int code[], int top, FILE *file) {
    if (root->left) {
        code[top] = 0;
        writeHuffmanCodesToFile(root->left, code, top + 1, file);
    }
    if (root->right) {
        code[top] = 1;
        writeHuffmanCodesToFile(root->right, code, top + 1, file);
    }
    if (!(root->left) && !(root->right)) {
        // 叶子节点，表示字符和编码
        fprintf(file, "%c: ", root->symbol);
        for (int i = 0; i < top; i++) {
            fprintf(file, "%d", code[i]);
        }
        fprintf(file, "\n");
    }
}



// 读取哈夫曼编码文件并创建结构体数组
HuffmanCode* readHuffmanCodesFromFile(const char* filename, int* numCodes) {
    FILE* file = fopen(filename, "r");
    if (file == NULL) {
        perror("无法打开文件");
        exit(1);
    }

    // 假设哈夫曼编码文件的行数不超过 1000 行，你可以根据实际情况调整这个大小
    const int maxLines = 1000;
    HuffmanCode* huffmanCodes = (HuffmanCode*)malloc(maxLines * sizeof(HuffmanCode));

    char line[100]; // 假设每行不超过 100 个字符
    *numCodes = 0;

    while (fgets(line, sizeof(line), file) != NULL) {
        if (*numCodes >= maxLines) {
            fprintf(stderr, "哈夫曼编码文件中的行数超过了预期的最大行数。\n");
            fclose(file);
            free(huffmanCodes);
            exit(1);
        }

        // 解析每一行，假设格式为 "字符: 编码"
        char character;
        char code[100];
        if (sscanf(line, "%c: %s", &character, code) == 2) {
            huffmanCodes[*numCodes].character = character;
            huffmanCodes[*numCodes].code = strdup(code);
            (*numCodes)++;
        }
    }

    fclose(file);
    return huffmanCodes;
}

// 编码文本
char* encodeText(const char* text,HuffmanCode* nodes) {
    int textLength = strlen(text);
    char* encodedText = (char*)malloc(2 * sizeof(char)); // 预估编码后的长度
    int encodedIndex = 0;

    for (int i = 0; i < textLength; i++) {
        char currentChar = text[i];
        for (int j = 0; j < 27; j++) {
            if (currentChar == nodes[j].character) {
                strcat(encodedText, nodes[j].code);
                encodedIndex += strlen(nodes[j].code);
                break;
            }
        }
    }

    // encodedText[encodedIndex] = '\0';
    return encodedText;
}

// 解码文本
char* decodeText(const char* encodedText, struct BiTNode* root) {
    int encodedLength = strlen(encodedText);
    char* decodedText = (char*)malloc(encodedLength * sizeof(char));
    int decodedIndex = 0;
    struct BiTNode* currentNode = root;

    for (int i = 0; i < encodedLength; i++) {
        if (encodedText[i] == '0') {
            currentNode = currentNode->left;
        } else if (encodedText[i] == '1') {
            currentNode = currentNode->right;
        }

        if (currentNode->left == NULL && currentNode->right == NULL) {
            decodedText[decodedIndex++] = currentNode->symbol;
            currentNode = root;
        }
    }

    decodedText[decodedIndex] = '\0';
    return decodedText;
}


int main() {
    char symbols[] = {' ','A', 'B', 'C', 'D',
                        'E','F','G','H','I',
                        'J','K','L','M','N',
                        'O','P','Q','R','S',
                        'T','U','V','W','X',
                        'Y','Z'};
    int frequencies[] = {186,64, 23, 22, 32,
                        103,21,15,47,57,
                        1,5,32,20,20,
                        56,19,2,50,51,
                        55,30,10,11,2,
                        21,2};

    int size = sizeof(symbols) / sizeof(symbols[0]);

    BiTNode *root = buildHuffmanTree(symbols, frequencies, size);

    int code[supermax];
    int top = 0;

    printHuffmanCodes(root, code, top);
    showBinTree1(root);
	FILE *codeFile = fopen("codefile.txt", "w");
    if (codeFile == NULL) {
        perror("无法打开文件");
        return 1;
    }

    // int code[10000];
    // top = 0;

    // 将Huffman编码写入文件
    writeHuffmanCodesToFile(root, code, top, codeFile);

    // 关闭文件
    fclose(codeFile);

    //读取哈夫曼编码文件
    int codeCount;
    HuffmanCode *huffmanCodes = readHuffmanCodesFromFile("codefile.txt", &codeCount);

    if (huffmanCodes == NULL) {
        return 1;
    }

    const char* originalText = " MY FAVORITE   "  ;
    char* encodedText = encodeText(originalText, huffmanCodes);
    printf("Encoded Text: %s\n", encodedText);

    char* decodedText = decodeText(encodedText, root);
    printf("Decoded Text: %s\n", decodedText);
    return 0;
}

问题

在创建哈夫曼树时对于剩余数组的覆盖与比较处理那里比较关键

思想

创建树的时候需要更新节点，更新方法是父节点覆盖一个，还有一个前一个往后覆盖然后减小size

由此引申出来一个问题:C语言的这个哈夫曼树要严格规定覆盖后的遍历次数，所以如果在for循环里边定义变量最好就只在这个for循环使用不然两个分号的变量都需要在for循环外边计算完再在其中使用

反人君子三十三
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
简单的哈夫曼树程序实现
m0_51710349的博客
12-02 3181
//因时间原因程序较混乱，有些结构还可优化，有些函数借鉴其他大佬居多，算半原创吧/ /* 题目要求 ：：：：： 哈夫曼树 (10分) 编写一个哈夫曼编码译码程序。针对一段文本，根据文本中字符出现频率构造哈夫曼树，给出每个字符的哈夫曼编码， 并进行译码，计算编码前后文本大小。 为确保构建的哈夫曼树唯一，本题做如下限定： 选择根结点权值最小的两棵二叉树时，选取权值较小者作为左子树。若多棵二叉树根结点权值相等，则先生成的作为左子树， 后生成的作为右子树，具体来说：i) 对于单结点二叉树，优先选择根结点对应字母
哈夫曼树的构造以及编码实现
初来乍到
03-24 3万+
哈夫曼树的介绍 Huffman Tree，中文名是哈夫曼树或霍夫曼树或者赫夫曼树，它是最优二叉树。 定义：给定n个权值作为n个叶子结点，构造一棵二叉树，若树的带权路径长度达到最小，则这棵树被称为哈夫曼树。  (01) 路径和路径长度 定义：在一棵树中，从一个结点往下可以达到的孩子或孙子结点之间的通路，称为路径。通路中分支的数目称为路径长度。若规定根结点的层数为1，则从根结点到第L层结点的路
哈夫曼树及哈夫曼编码详解【完整版代码】
热门推荐
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
数据结构——哈夫曼树及其哈夫曼编码
wardseptember的博客
12-27 1585
/************************ The arithmetic is quoted from "http://blog.csdn.net/ns_code/article/details/19174553". This code is made up of me. my email:wardseptember@gmail.com ************************/
哈夫曼树建立，编码，解码完整代码
yjh12355的博客
05-12 1140
这里我用的实例为: a-z以及空格的权值为：64 13 22 32 103 21 15 47 57 1 5 32 20 57 63 15 1 48 51 80 23 8 18 1 16 1 168 哈夫曼树的结构定义 typedef struct { int weight; int parent, left, right; }Htnode, * Huffmantree; typedef char** Huffmancode; 建立哈夫曼树 void select(Huffmantree a
哈夫曼树及哈夫曼编码具体代码
xyy_ywqs的博客
05-30 848
#include<iostream> using namespace std; #pragma warning (disable:4996) #define maxSize 100 /*赫夫曼树的存储结构，它也是一种二叉树结构，这种存储结构既适合表示树，也适合表示森林。*/ typedef struct Node { int weight; //权值 int parent; //父节点的序号，为-1的是根节点 int lc
哈夫曼编码，HuffMan Tree，实现文件压缩_java压缩软件小项目_01
cyming_的博客
08-24 783
1、能够选择任一文本文件，压缩，保存在本地。保存的压缩文件可自己命名。2、能够解压压缩文件3、压缩算法使用哈夫曼编码。
哈夫曼树与并查集
qq_46440190的博客
07-19 356
哈夫曼树 并查集
数据结构-树（堆、哈夫曼树、哈夫曼编码）
m0_68406857的博客
09-11 504
数据结构-树之堆、哈夫曼树和哈夫曼编码。最优二叉树
头歌数据结构构建哈夫曼树及编码
05-18
哈夫曼树是一种特殊的二叉树，用于解决数据压缩中的编码问题。它的构造原则是使得树中所有叶子节点（代表需要编码的字符）到根节点的路径长度之和最小，也就是构建一个带权路径最短的最优二叉树。这种树的每个内部...
哈夫曼树解码编码.zip
07-12
该哈夫曼树解码编码基于数据结构（清华大学出版社）一书，读取要编码的文件data，然后再编码到code文件，最后再用code文件来解码，解码到result文件。（注意要把cpp文件和data放到同一个文件夹下运行，每运行完一次...
java哈夫曼树的编码解码.zip
11-10
在Java中实现哈夫曼树的编码和解码过程涉及以下几个主要步骤和概念： 1. **哈夫曼树构建**： - **哈夫曼节点**：每个节点代表一个字符，包含字符及其频率信息。 - **最小堆**：用于存储哈夫曼节点，每次取出频率...
C++实现哈夫曼树编码解码
08-19
C++实现哈夫曼树编码解码 哈夫曼树是一种特殊的二叉树，它的每个叶节点都带有一个权值，用于表示该节点的重要性或频率。哈夫曼树编码解码是指使用哈夫曼树来对数据进行编码和解码，以达到数据压缩和解压缩的目的。...
算法练习题13——除自身以外数组的乘积（动态规划）
hello77的blogggg 祝你得偿所愿
09-04 512
给你一个整数数组nums，返回 数组answer，其中answer[i]等于nums中除nums[i]之外其余各元素的乘积。
【算法】C++贪心算法解题（单调递增数字、坏了的计算器、合并区间）
卜及中的博客
09-03 588
【算法】贪心算法解析：基本概念、策略证明与代码例题演示。
LeetCode LCR088.使用最小花费爬楼梯
m0_63816268的博客
09-03 1041
动态规划
树状数组记录
最新发布
volcan的博客
09-06 436
树状数组（Fenwick Tree）是一种用于维护数组前缀和的数据结构，支持高效的单点更新和区间查询操作。它的查询和更新时间复杂度为Ologn，适用于需要频繁更新和查询的场景。
Python实现哈夫曼树及其编码详解
本篇文章主要探讨Python中的哈夫曼树及其编码算法，这是数据结构学习中一个重要的概念。哈夫曼树，也被称为最优二叉树，其特点是带权路径长度最小，即树中每个节点的路径长度与其权值的乘积之和最小。在哈夫曼树中，...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值