【数据结构】二叉树和哈夫曼编码

最新推荐文章于 2024-08-05 11:35:37 发布
最新推荐文章于 2024-08-05 11:35:37 发布
阅读量1.5k 收藏 16
点赞数 2
分类专栏： 数据结构 文章标签： 数据结构 二叉树 哈夫曼编码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45972928/article/details/124334883
版权

1、二叉树的基本操作

内容：
1）采用二叉链表结构建立二叉树
2）编程实现二叉树的先序、中序、后序和层序遍历
3）编程实现非递归中序遍历
4）编程实现：求二叉树的高度和叶子结点个数

实现思路
① 设置存储空间的初始分量
② 定义结构体类型的二叉树数据类型，并引入堆栈
③ 实现先序建立二叉树、前序遍历二叉树、中序遍历二叉树、后序遍历二叉树、层序遍历二叉树、先序非递归遍历二叉树、求二叉树深度、求叶子结点个数等函数
④ 先序建立二叉树、前序遍历二叉树、中序遍历二叉树、后序遍历二叉树、求二叉树深度、求叶子结点个数使用递归实现
⑤ 层序遍历二叉树使用数组或者队列实现
⑥ 先序非递归遍历二叉树使用堆栈和循环实现
⑦ 在主函数里面调用各个方法进行检验

二叉树基本操作程序代码：

#include <iostream>

using namespace std;

#define MAXSIZE 100  //顺序栈存储空间的初始配量
#define OK 1
#define ERROR 0

typedef char TElemType;

typedef struct BiTNode //二叉树
{
    TElemType data;
    struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;

typedef BiTree ElemType;
typedef struct StackNode  //链栈的存储结构
{
    ElemType data;
    struct StackNode *next;
}StackNode,*LinkStack;

void InitStack(LinkStack &S)  //链栈的初始化
{
    S=NULL;
}

void Push(LinkStack &S,ElemType e)
{
    StackNode *p=new StackNode;
    p->data=e;
    p->next=S;
    S=p;
}

void Pop(LinkStack &S,ElemType &e)
{
    if(S==NULL)
        return;
    e=S->data;
    StackNode *p=S;
    S=S->next;
    delete p;
}

bool StackEmpty(LinkStack S)
{
    if(S==NULL)
        return true;
    return false;
}


void CreateBiTree(BiTree &T) //先序建立二叉树
{
    char ch;
    cin>>ch;
    if(ch=='#')
        T=NULL;
    else
    {
        T=new BiTNode;
        T->data=ch;
        CreateBiTree(T->lchild);
        CreateBiTree(T->rchild);
    }
}

void PreOrderTraverse(BiTree T)  //前序遍历
{
    if(T)
    {
        cout<<T->data;
        PreOrderTraverse(T->lchild);
        PreOrderTraverse(T->rchild);
    }
}

void InOrderTraverse(BiTree T)  //中序遍历
{
    if(T)
    {
        InOrderTraverse(T->lchild);
        cout<<T->data;
        InOrderTraverse(T->rchild);
    }
}

void PostOrderTraverse(BiTree T) //后续遍历
{
    if(T)
    {
        PostOrderTraverse(T->lchild);
        PostOrderTraverse(T->rchild);
        cout<<T->data;
    }
}

void LevelOrderTraverse(BiTree T) //层次遍历
{
    BiTree temp[100];
    int in=0;
    int out=0;
    temp[in++]=T;
    while(in>out)
    {
        if(temp[out])
        {
            cout<<temp[out]->data;
            temp[in++]=temp[out]->lchild;
            temp[in++]=temp[out]->rchild;
        }
        out++;
    }
}

int Depth(BiTree T)  //二叉树深度
{
    if(T==NULL)
        return 0;
    else
    {
        int m=Depth(T->lchild);
        int n=Depth(T->rchild);
        if(m>n)
            return m+1;
        else
            return n+1;
    }
}

void InOrderTraverse_1(BiTree T) //中序非递归遍历
{
    LinkStack S;
    InitStack(S);
    BiTree p=T;
    BiTree q=new BiTNode;
    while(p || !StackEmpty(S))
    {
        if(p)
        {
            Push(S,p);
            p=p->lchild;
        }
        else
        {
            Pop(S,q);
            cout<<q->data;
            p=q->rchild;
        }
    }
}

int leave_number(BiTree T) //叶子结点的个数
{
    if(T==NULL)
        return 0;
    if(T->lchild==NULL && T->rchild==NULL)
        return 1;
    return leave_number(T->lchild)+leave_number(T->rchild);
}

int main()
{
    BiTree T;
    //InitBiTNode(&T);
    cout<<"请输入二叉树："<<endl;
    CreateBiTree(T);
    cout<<"先序遍历：";
    PreOrderTraverse(T); cout<<endl;
    cout<<"后序遍历：";
    PostOrderTraverse(T); cout<<endl;
    cout<<"中序遍历：";
    InOrderTraverse(T); cout<<endl;
    cout<<"层序遍历：";
    LevelOrderTraverse(T); cout<<endl;
    cout<<"深度为："<<Depth(T)<<endl;
    cout<<"中序非递归遍历：";
    InOrderTraverse_1(T); cout<<endl;
    cout<<"叶子结点个数：";
    cout<<leave_number(T);
    return 0;
}

2、哈夫曼编码

内容：
1） 给定报文中26个字母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}，构建哈夫曼树并为这27个字符编制哈夫曼编码，并输出
2）模拟发送端，从键盘输入字符串，以%为结束标记，在屏幕上输出输入串的编码
3）模拟接收端，从键盘上输入0-1哈夫曼编码串，翻译出对应的原文。

实现思路：
① 定义结构体类型的哈夫曼树数据类型
② 实现哈夫曼树的初始化，父结点、子结点都赋值为0
③ 实现Select函数搜索哈夫曼树里面最小的两个结点并返回
④ 实现创建二叉树，不断搜索最小的两个结点加入树中
⑤ 实现创建哈夫曼编码函数，左子树为0，右子树为1，从叶子结点向上寻找直到根节点
⑥ 实现转码函数和翻译函数（从根向下0向左1向右）
⑦ 主函数进行函数调用，实现程序

哈夫曼编码程序代码：

#include <iostream>
#include <string>
#include <map>
#include <algorithm>
using namespace std;

typedef map<int,string> HuffmanCode;
int a[27];

//哈夫曼树的存储结构
typedef struct
{
    int weight;
    char c;
    int parent,lchild,rchild;
}HTNode,*HuffmanTree;

void Select(HuffmanTree HT,int n,int &s1,int &s2)
{
    for(int i=1;i<=n;i++)
    {
        if(HT[i].parent == 0)
        {
            if(s1 == 0)
                s1=i;
            else
            {
                s2=i;
                break;
            }
        }
    }
    if(HT[s1].weight > HT[s2].weight)
    {
        int t=s1;
        s1=s2;
        s2=t;
    }
    for(int i=1;i<=n;i++)
    {
        if(HT[i].parent == 0)
        {
            if(HT[i].weight < HT[s1].weight)
            {
                s2=s1;
                s1=i;
            }
            else if(HT[i].weight < HT[s2].weight && i!=s1)
            {
                s2=i;
            }
        }
    }
}

//初始化哈夫曼树
void initHuffmanTree(HuffmanTree &HT)
{
    int n=27;
    int m = 2 * n - 1;
    HT = new HTNode[m+1];
    for(int i = 0; i <= m; i++) //将m个元素的双亲、左孩子、右孩子的小标都初始化为0
    {
        HT[i].parent=0;
        HT[i].lchild=0;
        HT[i].rchild=0;
    }
    for(int i=1;i<=n;i++)  //输入前n个单元中叶子结点的权值
    {
        HT[i].weight=a[i-1];
        HT[i].c='a'+i-1;
    }
    HT[27].c=' ';
}

//创建哈夫曼树
void CreatHuffmanTree(HuffmanTree &HT)
{
    int n=27;
    int m = 2 * n - 1;
    for(int i=n+1;i<=m;i++)
    {
        int s1=0;
        int s2=0;
        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;
    }
}

void CreateHuffmanCode(HuffmanTree HT,HuffmanCode &HC)
{
    int n=27;
    for(int i=1;i<=n;i++)
    {
        string str="";
        int c=i;
        int f=HT[i].parent;
        while(f!=0)
        {
            if(HT[f].lchild==c)
                str += "0";
            else
                str += "1";
            c=f;
            f=HT[f].parent;
        }
        reverse(str.begin(),str.end());
        HC[i] = str;
    }
}

//字符串转码
string zhuanma(HuffmanCode HC,string str)
{
    string s="";
    for(int i=0;i<str.length();i++)
    {
        if(str[i]>='A'&&str[i]<='Z')
            str[i]=str[i]+32;
        if(str[i]==' ')
        {
            s+=HC[27];
        }
        else
        {
            s+=HC[str[i]-'a'+1];
        }
    }
    return s;
}

//译码
void translation(HuffmanTree HT,string str)
{
    HTNode ht=HT[53];
    cout<<"翻译结果为："<<endl;
    for(int i=0;i<str.length();i++)
    {
        if(str[i]=='0')
            ht=HT[ht.lchild];
        else
            ht=HT[ht.rchild];
        if(ht.lchild==0&&ht.rchild==0)
        {
            cout<<ht.c;
            ht=HT[53];
        }
    }
}

int main()
{
    string str="abcdefghijklmnopqrstuvwxyz ";
    int flag=1;
    HuffmanTree HT;
    HuffmanCode HC;
    int n=27;
    while(flag)
    {
        cout<<"****************************************************************************************"<<endl;
        cout<<"*******************  1.输入HuffmanTree的参数。                       *******************"<<endl;
        cout<<"*******************  2.初始化HuffmanTree的参数。（含有26字母及空格） *******************"<<endl;
        cout<<"*******************  3.创建HuffmanTree和编码表。                     *******************"<<endl;
        cout<<"*******************  4.输出编码表。                                  *******************"<<endl;
        cout<<"*******************  5.输入编码，并翻译为字符。                      *******************"<<endl;
        cout<<"*******************  6.输入字符，并实现转码。                        *******************"<<endl;
        cout<<"*******************  7.退出。                                        *******************"<<endl;
        cout<<"****************************************************************************************"<<endl;
        int ip;
        cout<<"请输入指令：";
        cin>>ip;

        switch(ip)
        {
        case 1:
            {
                cout<<"请按顺序输入HuffmanTree的27个参数："<<endl;
                for(int i=0;i<27;i++)
                    cin>>a[i];
                break;
            }
        case 2:
            {
                initHuffmanTree(HT);
                cout<<"参数初始化成功"<<endl;
                cout<<"结点i\tweight\tparent\tlchild\trchild\n";
                for(int i=1;i<2*n;i++)
                    cout<<i<<"\t"<<HT[i].weight<<"\t"<<HT[i].parent<<"\t"<<HT[i].lchild<<"\t"<<HT[i].rchild<<endl;
                system("pause");
                break;
            }
        case 3:
            {
                CreatHuffmanTree(HT);
                CreateHuffmanCode(HT,HC);
                cout<<"创建成功"<<endl;
                for(int i=1;i<2*n;i++)
                    cout<<i<<"\t"<<HT[i].weight<<"\t"<<HT[i].parent<<"\t"<<HT[i].lchild<<"\t"<<HT[i].rchild<<endl;
                system("pause");
                break;
            }
        case 4:
            {
                cout<<"字符编号\t哈夫曼编码"<<endl;
                for(map<int,string>::iterator iter=HC.begin();iter!=HC.end();iter++)
                {
                    cout<<"'"<<str[iter->first-1]<<"'"<<"\t\t"<<iter->second<<endl;
                }
                system("pause");
                break;
            }
        case 5:
            {
                string s;
                cout<<"请输入需要翻译的编码："<<endl;
                cin>>s;
                translation(HT,s);
                cout<<endl;
                system("pause");
                break;
            }
        case 6:
            {
                string s;
                cout<<"请输入需要转码的字符串："<<endl;
                cin.ignore();
                getline(cin,s);
                cout<<"字符串对应的编码为：\n"<<zhuanma(HC,s)<<endl;
                system("pause");
                break;
            }
        case 7:
            {
                flag=0;
                break;
            }
        default :
            {
                cout<<"指令错误！请重新输入！"<<endl;
                system("pause");
                break;
            }
        }
        system("cls");
    }
    return 0;
}
/*
hello world
h 0001
e 010
l 10111
l 10111
o 1001
  111
w 110001
o 1001
r 0010
l 10111
d 10110
000101010111101111001111110001100100101011110110
*/
酥酥～
关注
  • 2
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
最优二叉树——哈夫曼树|最佳编码——哈夫曼编码
diviner_s的博客
05-09 8386
哈夫曼树(最优二叉树) 定N个权值作为N个叶子结点，构造一棵二叉树，若该树的带权路径长度达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树(Huffman Tree)。哈夫曼树是带权路径长度最短的树，权值较大的结点离根较近。 路径：从树中一个结点到另一个结点之间得分支构成这两个结点间的路径。 结点的路径长度：两结点间路径上的分支数。 树的路径长度：从树根到每一个结点的路径长度之和。记作：TL...
【数据结构与算法】二叉树——哈夫曼编码
『诞生之时已至，以此修正万象』
11-25 1099
最近有很多的小朋友问我什么是哈夫曼编码，哈夫曼编码是一种可变字长的编码，那什么是可变字长呢？就是一句话里的每一个字符(ASCII码)它的位数(长度)是不一样的。就像我们一句话(AAAACCCCCDDDDBBE)有A，B，C，D，E五种字符，在这里我们可以用01表示A字符，用001表示B字符，用11表示C字符，用10表示D字符，用000表示E字符。如下图： 既然知道了哈夫曼编码是什么了，那又有...
【数据结构】哈夫曼编码与最优二叉树（哈夫曼树）
师兄怎么办
08-30 1285
在进行大容量存储、图像压缩等数据交换的时候，如果文件过大，恰好WIFI又不怎么快，你是不是会觉得十分暴躁呀？比如有这样一串数据需要传输：上面就有100位二进制数，这还只是数字，如果要传输英文字母、中文等需要更多的二进制位数：这种完完整整原原本本地传输数据的方法叫固定长度压缩算法。但是如果通过哈夫曼编码之后，就会变成数据+转换表（也就是非固定可变长度压缩算法，）：只需要10+9+32= 51位！！节省了将近49位的数据！！...
【数据结构】建立二叉树以及哈夫曼树及哈夫曼编码
专注于Java领域开发 关注我 带你玩转Java
09-12 1647
建立二叉树以及哈夫曼树及哈夫曼编码
数据结构（十三）二叉树—— 哈夫曼树和哈夫曼编码译码器
在路上
07-17 2437
哈夫曼树是二叉树的一种经典应用，哈夫曼树和哈夫曼编码经常搭配使用，用来创建一篇文章对应的加密编码，并且能够对这篇 文章进行加密和解密，通过哈夫曼编码加密后的文章完全通过01构成，并且每一篇文章因为内容的不同，即使是相同的字符所对应的的哈夫曼编码也是不同的，所以，既是单纯的得到一篇文章的密文结构，没有得到对应的哈夫曼编码表，也是无法进行解密的。所以哈夫曼树和哈夫曼编码在密码学当中具有非常高...
【数据结构】哈夫曼树和哈夫曼编码
Eristic0618的博客
05-24 1344
本篇文章围绕哈夫曼树进行讲解，包含哈夫曼树的概念、构造和哈夫曼编码
数据结构实验之二叉树六：哈夫曼编码
qq_45885219的博客
11-17 728
数据结构实验之二叉树六：哈夫曼编码 Description 字符的编码方式有多种，除了大家熟悉的ASCII编码，哈夫曼编码(Huffman Coding)也是一种编码方式，它是可变字长编码。该方法完全依据字符出现概率来构造出平均长度最短的编码，称之为最优编码。哈夫曼编码常被用于数据文件压缩中，其压缩率通常在20%～90%之间。你的任务是对从键盘输入的一个字符串求出它的ASCII编码长度和哈夫曼编码长度的比值。 Input 输入数据有多组，每组数据一行，表示要编码的字符串。 Output 对应字符的ASCII
@【数据结构】（二叉树-哈夫曼编码）
gsgs1234的博客
03-28 519
@【数据结构】（二叉树-哈夫曼树及哈夫曼编码） 实现哈夫曼树的创建算法，并按哈夫曼树实现哈夫曼编码算法。 #include<iostream> #include<stdio.h> #include<stdlib.h> #include<iomanip> #define MAXVALUE 10000 #define MAXLEAF 30 /...
8. 二叉树和哈夫曼树-数据结构入门(c语言实现)
qq_59959075的博客
06-26 952
二叉树由一个根节点和两棵互不相交的称为左子树和右子树的二叉树组成。
数据结构课设-哈夫曼编码树
01-17
这个数据结构课程设计项目旨在让学生理解并实践哈夫曼编码树的构建过程，并将其应用于前端页面展示。 首先，我们需要理解哈夫曼树的概念。哈夫曼树，又称最优二叉树，是一种带权路径长度最短的二叉树。在这个树中，...
数据结构专业课程设计哈夫曼编码.doc
12-06
总结来说，哈夫曼编码是数据结构和算法课程中的一个重要知识点，它结合了数据结构（二叉树）和算法（贪心策略）的原理，对学生分析问题、解决问题的能力提出了较高的要求。通过课程设计，学生不仅能深入理解哈夫曼...
数据结构课设--哈夫曼编码
04-10
在数据结构课程设计中，哈夫曼编码是一个经典的实践项目，它涉及到了二叉树、优先队列（最小堆）以及编码与解码的算法设计。 1. **哈夫曼树构建**：哈夫曼树是一种特殊的二叉树，也被称为最优二叉树或最小带权路径...
头歌数据结构构建哈夫曼树及编码
05-18
哈夫曼树是一种特殊的二叉树，用于解决数据压缩中的编码问题。它的构造原则是使得树中所有叶子节点（代表需要编码的字符）到...此外，哈夫曼树还被广泛应用于数据结构和算法的教学中，帮助学生理解二叉树的操作和应用。
哈夫曼编码译码器（数据结构）
12-09
在给定的项目中，“哈夫曼编码译码器”是一个用C++实现的工具，用于处理哈夫曼编码和解码的过程。首先，这个程序能够创建哈夫曼树，这是哈夫曼编码的关键步骤。创建哈夫曼树时，会根据输入文件中各字符的出现频率来...
【数据结构-前缀哈希】力扣523. 连续的子数组和
最新发布
sjsjs11的博客
08-05 134
当发现有两个余数相同的key的时候，对他们value作差，如果大于等于二，说明该子段长度大于等于二，这时候就找到了一个好的子数组，返回true，如果到最后都没有找到这样一个好的子数组，返回false。，其中 m 是数组 nums 的长度。解释：[23, 2, 6, 4, 7] 是大小为 5 的子数组，并且和为 42。输入：nums = [23,2,6,4,7], k = 13。输入：nums = [23,2,4,6,7], k = 6。输入：nums = [23,2,6,4,7], k = 6。
【数据结构】——链式二叉树
2402_82668782的博客
08-02 939
1>二叉树的结构体 包含了数据和指向左右子树的指针}BTNode;<2>二叉树结点的创建<3>二叉树的创建Tip：二叉树是递归定义的，都可以单独看作 根、左子树、右子树。
数据结构(5.4_1)——树的存储结构
m0_65240792的博客
08-02 302
每个结点中保存指向双亲的“指针” 新增数据元素无需按逻辑上的次序存储，之家在上一个结点后添加新结点，并记录双亲结点 1、删除结点数据域 2、将尾部数据移动至删除结点位置填充空缺寻找其双亲结点相同的结点顺序存储各个节点，每个结点中保存孩子的链表头指针 树和二叉树的转化： 使用孩子兄弟表示法
数据结构：链表经典算法OJ题
2401_86551514的博客
08-04 759
在了解了链表的相关知识后，我们还需要一些题目进行练习加深对链表这方面知识的理解，也可以用来检测链表这块学的的怎么样，废话不多说，开始上手。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值