Huffman树——数据结构

最新推荐文章于 2024-05-20 20:48:02 发布
最新推荐文章于 2024-05-20 20:48:02 发布
阅读量458 收藏 1
点赞数
分类专栏： 数据结构 文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_60104429/article/details/124619048
版权

Huffman树是一种最小带权二叉树，能够降低查找代价，压缩存储空间。

Huffman编码是一种前缀码，

我的工作是给定一组长度未知的 string，生成对应的Huffman表，Huffman树，和huffman加密，解码。

预定义部分

#include <iostream>
#include<cstdio>
#include<cstdlib>
#include<string>
#include<stack>

using namespace std;
typedef struct {
    int weight;
    int parent, lchild, rchild;
}HTNode, * HuffmanTree;

typedef char** HuffmanCode;

int Max = 100000;
HuffmanCode HC;
HuffmanTree HT;
char* Chars;
char* newchar;
int* weight;
int sumchar;
int* newweight;
char* HuffCode;
//HC，HT头节点为零；

实现函数

查找当前huffman树最小的两个节点，在HT[1..i-1]中选择parent为0，且weight最小的两个结点，
//S1<S2

void Select( int L, int* S1, int* S2) {
    HuffmanTree p = HT;
    int small1 = Max, small2 = Max;
    
    for (int i = 1; i <= L; i++) {
        if ((p + i)->parent == 0) {
            if ((p + i)->weight < small1) {
                small2 = small1;
                *S2 = *S1;
                small1 = (p + i)->weight;
                *S1 = i;
            }
            else if ((p + i)->weight < small2){
                small2= (p + i)->weight;
                *S2 = i;
            }
        }
    }
}

生成Huffman树，HuffmanCode，Huffman编码对照表

void HuffmanCoding( int* W, int n) {

    //*W为频率数组，从大到小。n为字符个数。
    if (n <= 1)
        return ;
    int* w = W;
    int m = 2 * n - 1;
    
    HT = (HuffmanTree)malloc((m + 1) * sizeof(HTNode));//构造huffmanTree
    HuffmanTree p;
    int i;
    for (p = HT + 1, i = 1; i <= n; i++, p++, w++) {
        (p)->weight = *(w);
        (p)->parent = 0;
        (p)->lchild = 0;
        (p)->rchild = 0;
    }
    for (; i <= m; i++, p++, w++) {
        (p)->weight = 0;
        (p)->parent = 0;
        (p)->lchild = 0;
        (p)->rchild = 0;
    }
    cout << "huffman初始化" << endl;
    for (i = n + 1; i <= m; i++) {
        int S1, S2;
        Select( 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;
    }

    HC = (HuffmanCode)malloc((n + 1) * sizeof(char*));
    char* cd;
    cd = (char*)malloc(n * sizeof(char));
    cd[n -1] = '\0';
    for (int i = 1,start,c,f; i <= n; ++i) {
         start = n - 1;
        for ( c = i, f = HT [i].parent; f != 0; c = f, f = (HT + f)->parent) {
            start=start-1;
            if ((HT + f)->lchild == c)
                cd[start] = '0';
            else
                cd[start] = '1';
        }
        
        HC[i] = (char*)malloc((n - start) * sizeof(char));
        
        for (int f = 0; start < n;  start++, f++) {
            HC[i][f] = cd[start];
            
        }
    }
    cout << "huffman初始化完成" << endl;
    free(cd);

    cout << "赫夫曼编码表" << endl;
    for (int i = 0; i < sumchar; i++) {
        cout << '\n' << *(newchar + i) << ":" << *(weight + i) << ":";
        for (int ij = 0; HC[i + 1][ij] != '\0'; ij++)
            cout << HC[i + 1][ij];
        cout << endl;
    }
    
}//

生成Huffman加密序列

//HUffmam编码，将字符串改成01010001100形式
void HuffmanCodingRoot(string Str) {
    HuffCode = (char*)malloc(sizeof(char));
    int sumcode = 0;
    for (int i = 0; i < Str.length(); i++) {
        for (int j = 0; j < sumchar; j++) {
            if (Str[i]==newchar[j]) {
                for (int k = 0; HC[j+1][k] != '\0'; k++) {
                    HuffCode[sumcode] = HC[j+1][k];
                    sumcode++;
                    HuffCode = (char*)realloc(HuffCode, (sumcode+1) * sizeof(char));
                }
                break;
            }
        }
    }
    HuffCode[sumcode] = '\0';

    cout << "赫夫曼编码字符串" << endl;
    for (int ij = 0; HuffCode[ij] != '\0'; ij++)
        cout << HuffCode[ij];
    cout << endl;

}

中序遍历打印Huffman树

//中序打印Huffman树


void InOrder(int n) {
    if (HT[n].lchild != 0) {
        InOrder(HT[n].lchild);
    }
    cout << "   节点：" << n << "  权重： " << HT[n].weight << "   左节点：" << HT[n].lchild;
    cout << "   右节点：" << HT[n].rchild << endl;
    if (HT[n].rchild != 0) {
        InOrder(HT[n].rchild);
    }
}
void HuffmanTraverse(HuffmanTree HT) {
    int root = 2 * sumchar - 1;
    InOrder(root);
}

根据Huffman树生成，反应节点深度的数组

//根据Huffman树生成，反应节点深度的数组
void HuffmanDecoding() {
    if (sumchar <= 0)
        return;
    int n = sumchar;
    newweight = (int*)malloc(n * sizeof(int));
    int r = 2 * n - 1;
    for (int i = 1; i <= n; i++) {
        char* s = *(HC + i);
        int k = r;
        for (int j = 0; j < strlen(s); j++) {
            if (s[j] == '0')
                k = (HT + k)->lchild;
            else if (s[j] == '1') {
                k = HT[k].rchild; // 向右
            }
            else {
                return;   //ERROR;
            }
        }
        newweight[i-1] = HT[k].weight;
                //保存在存储n个字符权值的数组中}}
     }
}

生成频度数组于字符组，并以从高到低排列

void getChars(string Str) {

    Chars = (char*)malloc((Str.length()) * sizeof(char));
    for (unsigned int i = 0; i < Str.length(); i++)
        *(Chars + i) = Str[i];

    //生成字符频度数组newchar存放字符，wight存放字符频率,sumchar存放字符个数。
    newchar = (char*)malloc(sizeof(char));
    weight = (int*)malloc(sizeof(int));
    sumchar = 0;

    for (int i = 0, j = 0; i < Str.length(); i++) {

        for (j = 0; (j < sumchar); j++) {
            if (*(newchar + j) == *(Chars + i)) {
                *(weight + j) = *(weight + j) + 1;
                break;
            }
        }
        if (j == sumchar) {
            *(newchar + sumchar) = *(Chars + i);
            *(weight + sumchar) = 1;
            sumchar++;
            newchar = (char*)realloc(newchar, (sumchar + 1) * sizeof(char));
            weight = (int*)realloc(weight, (sumchar + 1) * sizeof(int));
        }
    }

    for (int i = 0; i < sumchar; i++) {
        for (int j = i+1; j < sumchar; j++) {
            if (weight[i] < weight[j]) {
                int t;
                char tc;
                t = weight[i];
                weight[i] = weight[j];
                weight[j] = t;
                tc = newchar[i];
                newchar[i] = newchar[j];
                newchar[j] = tc;
            }
        }
    }

}

解码

int small(char* str, char* HC) {
    int i;
    for (i = 0; str[i] == HC[i]; i++)
        if (HC[i + 1] == '\0')
            break;
    if (HC[i] == str[i])
        return 1;
    else
        return 0;
}
void HuffSolve(char* HCode) {
    int i, j, k, m=0;
    int* p;
    p = (int*)malloc(sizeof(int));
    for (i = 0; HCode[i] != '\0'; i = j) {
        char str[100] = { '2' };
        for (j = i;HCode[j]!='\0'; j++) {
            str[j - i] = HCode[j];
            int flag = 0;
            for (k = 1; k <= sumchar; k++) {
                if (small(str, HC[k]) == 1) {
                    p[m] = k;
                    
                    m++;
                    p = (int*)realloc(p, (m + 1) * sizeof(int));
                    flag = 1;
                    break;
                }
            }
            if (flag == 1)
                break;

        }
        j++;
    }
    p[m] = -1;

    cout << endl;
    for (int i = 0; p[i] != -1; i++)
        cout << newchar[p[i]-1];
    free(p);
}

使用

int main()
{


    //生成字符数组；Chars
    string Str;
    cin >> Str;
    getChars(Str);
    

    HuffmanCoding( weight, sumchar);
    
    cout << "中序遍历赫夫曼编树" << endl;
    HuffmanTraverse(HT);

    cout << "\n赫夫曼编码字符串" << endl;
    HuffmanCodingRoot(Str);
    

    cout << "赫夫曼解码" << endl;
    HuffSolve( HuffCode);

    HuffmanDecoding();
    for (int i = 0; i < sumchar; i++) {
        cout << endl;
        for (int ij = 0; HC[i + 1][ij] != '\0'; ij++)
            cout << HC[i + 1][ij];
        cout << " weight"<<newweight[i]<<'\n';
    }

    free(Chars);
    free(newchar);
    free(weight);
    free(HC);
    free(HT);
 
    cout << "Hello World!\n";
    return 0;


}

测试

afaffwaffuwfaffhefuewfhkjfhayfgwahefbwhdfgayudfgabkwhfbehfgawyefgawehdfbvahdfgwyewfbcadfhbaeiufgadfhcvadjbaiufgewdfhv
huffman初始化
huffman初始化完成
赫夫曼编码表

f:26:01

a:16:101

h:12:000

w:11:1111

e:9:1110

g:8:1001

d:8:1100

b:7:0011

u:5:0010

y:4:10001

v:3:10000

j:2:110100

k:2:110101

c:2:110110

i:2:110111
中序遍历赫夫曼编树
   节点：3  权重： 12   左节点：0   右节点：0
   节点：24  权重： 24   左节点：3   右节点：20
   节点：9  权重： 5   左节点：0   右节点：0
   节点：20  权重： 12   左节点：9   右节点：8
   节点：8  权重： 7   左节点：0   右节点：0
   节点：27  权重： 50   左节点：24   右节点：1
   节点：1  权重： 26   左节点：0   右节点：0
   节点：29  权重： 117   左节点：27   右节点：28
   节点：11  权重： 3   左节点：0   右节点：0
   节点：18  权重： 7   左节点：11   右节点：10
   节点：10  权重： 4   左节点：0   右节点：0
   节点：21  权重： 15   左节点：18   右节点：6
   节点：6  权重： 8   左节点：0   右节点：0
   节点：25  权重： 31   左节点：21   右节点：2
   节点：2  权重： 16   左节点：0   右节点：0
   节点：28  权重： 67   左节点：25   右节点：26
   节点：7  权重： 8   左节点：0   右节点：0
   节点：22  权重： 16   左节点：7   右节点：19
   节点：12  权重： 2   左节点：0   右节点：0
   节点：16  权重： 4   左节点：12   右节点：13
   节点：13  权重： 2   左节点：0   右节点：0
   节点：19  权重： 8   左节点：16   右节点：17
   节点：14  权重： 2   左节点：0   右节点：0
   节点：17  权重： 4   左节点：14   右节点：15
   节点：15  权重： 2   左节点：0   右节点：0
   节点：26  权重： 36   左节点：22   右节点：23
   节点：5  权重： 9   左节点：0   右节点：0
   节点：23  权重： 20   左节点：5   右节点：4
   节点：4  权重： 11   左节点：0   右节点：0

赫夫曼编码字符串
赫夫曼编码字符串
101011010101111110101010010111101101010100011100100101110111101000110101110100010001011000101100111111010001110010011111100011000110011011000100101100011001101001111010111110000100111110000011001101111110001111001100110111111110000110001001110000101000110001100111111000111101111010011110110101110001000001110111101101110010011001101110001000110110100001011100110100001110111011100100110011110111111000100010000
赫夫曼解码

afaffwaffuwfaffhefuewfhkjfhayfgwahefbwhdfgayudfgabkwhfbehfgawyefgawehdfbvahdfgwyewfbcadfhbaeiufgadfhcvadjbaiufgewdfhv
01 weight26

101 weight16

000 weight12

1111 weight11

1110 weight9

1001 weight8

1100 weight8

0011 weight7

0010 weight5

10001 weight4

10000 weight3

110100 weight2

110101 weight2

110110 weight2

110111 weight2
Hello World!

C:\Users\86158\source\repos\HuffmanTree\Debug\HuffmanTree.exe (进程 18580)已退出，代码为 0。
按任意键关闭此窗口. . .

全部代码

#include <iostream>
#include<cstdlib>
#include<string>

using namespace std;
typedef struct {
    int weight;
    int parent, lchild, rchild;
}HTNode, * HuffmanTree;

typedef char** HuffmanCode;

int Max = 100000;
HuffmanCode HC;
HuffmanTree HT;
char* Chars;
char* newchar;
int* weight;
int sumchar;
int* newweight;
char* HuffCode;
//HC，HT头节点为零；



//查找当前huffman树最小的两个节点，在HT[1..i-1]中选择parent为0，且weight最小的两个结点，
//S1<S2

void Select( int L, int* S1, int* S2) {
    HuffmanTree p = HT;
    int small1 = Max, small2 = Max;
    
    for (int i = 1; i <= L; i++) {
        if ((p + i)->parent == 0) {
            if ((p + i)->weight < small1) {
                small2 = small1;
                *S2 = *S1;
                small1 = (p + i)->weight;
                *S1 = i;
            }
            else if ((p + i)->weight < small2){
                small2= (p + i)->weight;
                *S2 = i;
            }
        }
    }
}

//*W为频率数组，从大到小。n为字符个数。
void HuffmanCoding( int* W, int n) {
    if (n <= 1)
        return ;
    int* w = W;
    int m = 2 * n - 1;
    
    HT = (HuffmanTree)malloc((m + 1) * sizeof(HTNode));//构造huffmanTree
    HuffmanTree p;
    int i;
    for (p = HT + 1, i = 1; i <= n; i++, p++, w++) {
        (p)->weight = *(w);
        (p)->parent = 0;
        (p)->lchild = 0;
        (p)->rchild = 0;
    }
    for (; i <= m; i++, p++, w++) {
        (p)->weight = 0;
        (p)->parent = 0;
        (p)->lchild = 0;
        (p)->rchild = 0;
    }
    cout << "huffman初始化" << endl;
    for (i = n + 1; i <= m; i++) {
        int S1, S2;
        Select( 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;
    }

    HC = (HuffmanCode)malloc((n + 1) * sizeof(char*));
    char* cd;
    cd = (char*)malloc(n * sizeof(char));
    cd[n -1] = '\0';
    for (int i = 1,start,c,f; i <= n; ++i) {
         start = n - 1;
        for ( c = i, f = HT [i].parent; f != 0; c = f, f = (HT + f)->parent) {
            start=start-1;
            if ((HT + f)->lchild == c)
                cd[start] = '0';
            else
                cd[start] = '1';
        }
        
        HC[i] = (char*)malloc((n - start) * sizeof(char));
        
        for (int f = 0; start < n;  start++, f++) {
            HC[i][f] = cd[start];
            
        }
    }
    cout << "huffman初始化完成" << endl;
    free(cd);

    cout << "赫夫曼编码表" << endl;
    for (int i = 0; i < sumchar; i++) {
        cout << '\n' << *(newchar + i) << ":" << *(weight + i) << ":";
        for (int ij = 0; HC[i + 1][ij] != '\0'; ij++)
            cout << HC[i + 1][ij];
        cout << endl;
    }
    
}//

//HUffmam编码，将字符串改成01010001100形式
void HuffmanCodingRoot(string Str) {
    HuffCode = (char*)malloc(sizeof(char));
    int sumcode = 0;
    for (int i = 0; i < Str.length(); i++) {
        for (int j = 0; j < sumchar; j++) {
            if (Str[i]==newchar[j]) {
                for (int k = 0; HC[j+1][k] != '\0'; k++) {
                    HuffCode[sumcode] = HC[j+1][k];
                    sumcode++;
                    HuffCode = (char*)realloc(HuffCode, (sumcode+1) * sizeof(char));
                }
                break;
            }
        }
    }
    HuffCode[sumcode] = '\0';

    cout << "赫夫曼编码字符串" << endl;
    for (int ij = 0; HuffCode[ij] != '\0'; ij++)
        cout << HuffCode[ij];
    cout << endl;

}


//中序打印Huffman树


void InOrder(int n) {
    if (HT[n].lchild != 0) {
        InOrder(HT[n].lchild);
    }
    cout << "   节点：" << n << "  权重： " << HT[n].weight << "   左节点：" << HT[n].lchild;
    cout << "   右节点：" << HT[n].rchild << endl;
    if (HT[n].rchild != 0) {
        InOrder(HT[n].rchild);
    }
}
void HuffmanTraverse(HuffmanTree HT) {
    int root = 2 * sumchar - 1;
    InOrder(root);
}
//根据Huffman树生成，反应节点深度的数组
void HuffmanDecoding() {
    if (sumchar <= 0)
        return;
    int n = sumchar;
    newweight = (int*)malloc(n * sizeof(int));
    int r = 2 * n - 1;
    for (int i = 1; i <= n; i++) {
        char* s = *(HC + i);
        int k = r;
        for (int j = 0; j < strlen(s); j++) {
            if (s[j] == '0')
                k = (HT + k)->lchild;
            else if (s[j] == '1') {
                k = HT[k].rchild; // 向右
            }
            else {
                return;   //ERROR;
            }
        }
        newweight[i-1] = HT[k].weight;
                //保存在存储n个字符权值的数组中}}
     }
}
    

void getChars(string Str) {

    Chars = (char*)malloc((Str.length()) * sizeof(char));
    for (unsigned int i = 0; i < Str.length(); i++)
        *(Chars + i) = Str[i];

    //生成字符频度数组newchar存放字符，wight存放字符频率,sumchar存放字符个数。
    newchar = (char*)malloc(sizeof(char));
    weight = (int*)malloc(sizeof(int));
    sumchar = 0;

    for (int i = 0, j = 0; i < Str.length(); i++) {

        for (j = 0; (j < sumchar); j++) {
            if (*(newchar + j) == *(Chars + i)) {
                *(weight + j) = *(weight + j) + 1;
                break;
            }
        }
        if (j == sumchar) {
            *(newchar + sumchar) = *(Chars + i);
            *(weight + sumchar) = 1;
            sumchar++;
            newchar = (char*)realloc(newchar, (sumchar + 1) * sizeof(char));
            weight = (int*)realloc(weight, (sumchar + 1) * sizeof(int));
        }
    }

    for (int i = 0; i < sumchar; i++) {
        for (int j = i+1; j < sumchar; j++) {
            if (weight[i] < weight[j]) {
                int t;
                char tc;
                t = weight[i];
                weight[i] = weight[j];
                weight[j] = t;
                tc = newchar[i];
                newchar[i] = newchar[j];
                newchar[j] = tc;
            }
        }
    }

}


//根据HuffmanCode求原字符串。

int small(char* str, char* HC) {
    int i;
    for (i = 0; str[i] == HC[i]; i++)
        if (HC[i + 1] == '\0')
            break;
    if (HC[i] == str[i])
        return 1;
    else
        return 0;
}
void HuffSolve(char* HCode) {
    int i, j, k, m=0;
    int* p;
    p = (int*)malloc(sizeof(int));
    for (i = 0; HCode[i] != '\0'; i = j) {
        char str[100] = { '2' };
        for (j = i;HCode[j]!='\0'; j++) {
            str[j - i] = HCode[j];
            int flag = 0;
            for (k = 1; k <= sumchar; k++) {
                if (small(str, HC[k]) == 1) {
                    p[m] = k;
                    
                    m++;
                    p = (int*)realloc(p, (m + 1) * sizeof(int));
                    flag = 1;
                    break;
                }
            }
            if (flag == 1)
                break;

        }
        j++;
    }
    p[m] = -1;

    cout << endl;
    for (int i = 0; p[i] != -1; i++)
        cout << newchar[p[i]-1];
    free(p);
}


int main()
{


    //生成字符数组；Chars
    string Str;
    cin >> Str;
    getChars(Str);
    

    HuffmanCoding( weight, sumchar);
    
    cout << "中序遍历赫夫曼编树" << endl;
    HuffmanTraverse(HT);

    cout << "\n赫夫曼编码字符串" << endl;
    HuffmanCodingRoot(Str);
    

    cout << "赫夫曼解码" << endl;
    HuffSolve( HuffCode);

    HuffmanDecoding();
    for (int i = 0; i < sumchar; i++) {
        cout << endl;
        for (int ij = 0; HC[i + 1][ij] != '\0'; ij++)
            cout << HC[i + 1][ij];
        cout << " weight"<<newweight[i]<<'\n';
    }

    free(Chars);
    free(newchar);
    free(weight);
    free(HC);
    free(HT);
 
    cout << "Hello World!\n";
    return 0;


}

这是数据结构第一次写作欢迎提问，讨论。

本人现在是大二在校生

2022/5/6

学以致用业余编程艰难者
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构课程设计——Huffman（简单压缩）
01-10
基于Huffman Coding简单压缩（放大），瞎搞课设，代码较丑。 发现有注释错了，找不到如何修改，不过百度云里的注释修改了 下面是源码链接。 链接：https://pan.baidu.com/s/1vTpE7TMjM8pqvm11jna7mQ 提取码：0zbb
最优前缀编码
qq_49056623的博客
05-31 860
问题 代码（码字）：Q {001,00,010,01}表示字符 a, b, c, d 同一序列：0100001 产生两种译码（产生歧义）：01 00 001; 010 00 01 二元前缀码：任何字符的代码不能作为其他字符代码的前缀 利用二元前缀码译码：从第一个字符开始一次读入每个字符（0 或 1），如果发 现读到的子串与某个码字相等，就将这个子串译作对应的码字；然后从下一个字符开始继续这个过程，直到读完输入的字符串为止。 二元前缀编码存储：二叉树结构，每个字符作为树叶，对应这个字符的前缀码看作根到这片..
【数据结构与算法】-哈夫曼树(Huffman Tree)与哈夫曼编码
闪耀大叔的博客
07-25 3万+
超详细讲解哈夫曼树(Huffman Tree)以及哈夫曼编码的构造原理、方法，并用代码实现。
哈夫曼树原理解析，构造方法，意义和作用。
热门推荐
Anakki的博客
08-05 29万+
哈夫曼树（最优二叉树） 百度百科：https://baike.baidu.com/item/%E5%93%88%E5%A4%AB%E6%9B%BC%E6%A0%91/2305769?fr=aladdin 一. 目的： 找出存放一串字符所需的最少的二进制编码 二. 构造方法： 首先统计出每种字符出现的频率！（也可以是概率）//权值 ----------------------------...
树-哈夫曼树（Huffman Tree）
weixin_30635053的博客
08-09 163
概述 哈夫曼树：树的带权路径长度达到最小。 构造规则 1. 将w1、w2、…，wn看成是有n 棵树的森林(每棵树仅有一个结点)； 2. 在森林中选出根结点的权值最小的两棵树进行合并，作为一棵新树的左、右子树，且新树的根结点权值为其左、右子树根结点权值之和； 3. 从森林中删除选取的两棵树，并将新树加入森林； 4. 重复(02)、(03)步，直到森...
温习 数据结构之HuffmanTree
weixin_33797791的博客
01-08 159
一定要亲自试了，才会印象深刻呢！！！ //HuffmanTree #include&lt;stdio.h&gt; #include&lt;string.h&gt; #include&lt;malloc.h&gt; #define UNIT_MAX 10000 typedef struct { unsigned int weight; unsigned int ...
哈夫曼树的应用——数据结构课程设计
12-14
哈夫曼树的应用——数据结构课程设计
数据结构——哈夫曼编码
03-01
哈夫曼编码的演示程序 可以由用户指定每个字符的权值进行编码 也可以输入一段字符串，程序自动计算每个字符的权值。...建立哈夫曼树之后，可以对一段字符串进行相应的加密。结果输出到文本文件中。
武汉理工大学计算机数据结构与算法实验一——二叉树与哈夫曼图片压缩
06-03
(1)掌握树的存储结构 (2)掌握二叉树的三种遍历方法 (3)掌握并理解Huffman树、Huffman编码等知识和应用 (4)掌握文件的操作 (5)使用Huffman算法实现图像压缩程序 2.实验内容 使用Huffman压缩算法，对一幅BMP格式的...
数据结构实验——哈弗曼编码
02-28
哈夫曼编码演示程序，可以由用户输入各个叶子节点的权值，也可以输入一段字符串，自动计算各个字符的权值，然后对每个字符进行编码。 根据编码可以对目标字符串进行加密，输出两个文件分别为原文字符串和加密后的...
【Dev-c++】C语言数据结构实验——赫夫曼树的建立和应用
m0_52474147的博客
07-25 842
1、从键盘输入一串电文字符，统计字符种类及出现的频率建立赫夫曼树。1、认真阅读程序，将未完成的代码补全（红色部分）。3、保存和截图程序的运行结果，并结合程序进行分析。2、上机调试，并运行程序。......
Huffman树
susan040740108的专栏
12-21 568
/* 赫夫曼树和赫夫曼编码的存储表示 */typedef struct{    unsigned int weight;    unsigned int parent,lchild,rchild;}HTNode,*HuffmanTree; /* 动态分配数组存储赫夫曼树 */typedef char **HuffmanCode; /* 动态分配数组存储赫夫曼编码表 */
哈夫曼编码器——数据结构
P_c
07-28 4718
功能： （1）初始化N个字符及其权值，建立哈夫曼树； （2）编码：利用已经建立好的哈夫曼树对正文进行编码，将结果存入文件中； （3）译码：利用已建立好的哈夫曼树将文件中的代码进行译码，结果存入另一个文件中； （4）显示哈夫曼树； （5）显示正文的编码及译码结果； 文章目录1、建立哈夫曼树2、寻找最小的两个元素3、初始字符编码4、对正文编码5、译码6、显示哈夫曼树 1、建立哈夫曼树 （1）初始化：首...
【笔记】哈夫曼树
time-space的博客
11-01 7945
哈夫曼树的概念 哈夫曼树的构造算法 哈夫曼编码 哈夫曼编码算法的实现
哈(霍)夫曼树的基本操作 C语言
HISS的博客
02-12 138
#include<stdio.h> #include<stdlib.h> #include<string.h> //哈夫曼树结点结构 typedef struct { int weight; //结点权重 int parent, left, right; //父结点、左孩子、右孩子在数组中的位置下标 }HTNode, *HuffmanTree; //动态二维数组，存储哈夫曼编码 typedef char ** HuffmanCode; //HT
数据结构：哈夫曼树
weixin_45652283的博客
11-20 1795
哈夫曼树(Huffman)又称之为最优树，是一种带权路径长度最短的树。
数据结构 Huffman树（霍夫曼树、哈夫曼树）
oowadanoko的博客
01-29 1198
Huffman树 给定N个权值作为N个叶子结点，构造一棵二叉树，若该树的带权路径长度达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树(Huffman Tree)。哈夫曼树是带权路径长度最短的树，权值较大的结点离根较近。 结构定义： template<typename ElemType> struct HuffmanNode { ElemType data; int weight; int num; int parent, lchild, rchild; }; template&lt
[Collection与数据结构] Map与Set(二):哈希表
最新发布
2301_80050796的博客
05-20 383
🏵️热门专栏:🍕 Collection与数据结构 (91平均质量分)🧀Java EE(94平均质量分)🍭MySql数据库(93平均质量分)🍬算法(97平均质量分)
数据结构赫夫曼Huffman树算法
05-13
赫夫曼树（Huffman Tree）是一种带权路径长度最短的树，也称为最优二叉树。它是由美国计算机科学家David A. Huffman在1952年发明的，常用于数据压缩算法中。 赫夫曼树的构建过程是基于贪心算法的思想，即每次选取...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值