精华内容
下载资源
问答
  • 本文主要是对哈夫曼树代码进行介绍,感性趣的朋友可以参考下。
  • 哈夫曼树代码

    2015-05-20 17:21:49
    哈夫曼树代码,哈夫曼树的代码,哈夫曼树的创建与输出
  • 代码为.cpp程序,可用DevC打开运行,或许有一些不合理的地方或者错误地方,烦请各位加以批评指正,共同进步。
  • 哈夫曼树又称作最优二叉树,是带权路径长度最小的二叉树。 一、算法步骤: 构造哈夫曼树算法的实现可以分成两大部分。 ①初始化:首先动态申请2n个单元;然后循环2n-1次,从1号单元开始,依次将1至m所有单元中的...

    哈夫曼树又称作最优二叉树,是带权路径长度最小的二叉树。

    一、算法步骤:

    构造哈夫曼树算法的实现可以分成两大部分。 

    ①初始化:首先动态申请2n个单元;然后循环2n-1次,从1号单元开始,依次将1至m所有单元中的双亲、左孩子、右孩子的下标都初始化为0;最后再循环n次,输人前n个单中叶子结点的权值。
    ②创建树:循环n-1次,通过n-1次的选择、删除与合并来创建哈夫曼树。选择是从当前森林中选择双亲为0且权值最小的两个树根结点s1和s2;删除是指将结点s1和s2的双亲改为非0;合并就是将s1和s2的权值和作为一个新结点的权值依次存人到数组的第n+1之后的单元中,同时记录这个新结点左孩子的下标为s1,右孩子的下标为s2。

    二、完整代码:

    #include <iostream>
    using namespace std;
    
    //哈夫曼的存储结构
    typedef struct {
        int weight;
        int parent,lchild,rchild;
    }HTNode, *HuffmamTree;
    
    //选两个权值最小的结点
    void Select(HuffmamTree &HT, int n, int &s1, int &s2){
        int min;
        for (int i = 1; i <= n; ++i) {
            if(HT[i].parent == 0){
                min = i;
                break;
            }
        }
        for (int j = 1; j <= n; ++j) {
            if(HT[j].parent == 0){
                if(HT[j].weight < HT[min].weight)
                    min = j;
            }
        }
        s1 = min;
        for (int i = 1; i <= n; ++i) {
            if(HT[i].parent == 0 && i != s1){
                min = i;
                break;
            }
        }
        for (int j = 1; j <= n; ++j) {
            if(HT[j].parent == 0 && j != s1){
                if(HT[j].weight < HT[min].weight)
                    min = j;
            }
        }
        s2 = min;
    }
    
    //输出哈夫曼树状态表
    void Show(HuffmamTree HT, int m){
        cout<<"==============================="<<endl;
        for (int i = 1; i <= m; ++i) {
            cout<<i<<".   "<<HT[i].weight<<"   "<<HT[i].parent<<"   "<<HT[i].lchild<<"   "<<HT[i].rchild<<endl;
            cout<<"-------------------------"<<endl;
        }
    }
    
    //创建哈夫曼树
    void CreateHuffmanTree(HuffmamTree &HT, int n){
        //初始化构造n个结点的哈夫曼树
        if(n <=1) return;
        int m = n*2-1;
        HT = new HTNode[m+1];
        for (int i = 0; i <= m; ++i) {
            HT[i].parent = 0;
            HT[i].lchild = 0;
            HT[i].rchild = 0;
            HT[i].weight = 0;
        }
        for (int j = 1; j <= n; ++j) {
            cout<<"请输入第"<<j<<"个结点的权值:";
            cin>>HT[j].weight;
        }
    
        //输出哈夫曼树初态表
        cout<<"HT的初态:"<<endl;
        Show(HT, m);
    
        //创建哈夫曼树
        int s1,s2;
        for (int i = n+1; i <= m; ++i) {
            Select(HT,i-1,s1,s2);  //从HT[k](1 <= k <= i-1)中获得两个权值最小的结点的位置
            HT[s1].parent = i;  //将s1 s2位置的结点的双亲域改为i
            HT[s2].parent = i;
            HT[i].lchild = s1;  //s1 s2分别作为结点i的左右子树
            HT[i].rchild = s2;
            HT[i].weight = HT[s1].weight + HT[s2].weight;  //i结点的权值等于左右子树权值之和
        }
        //输出哈夫曼树终态表
        cout<<"HT的终态:"<<endl;
        Show(HT, m);
    }
    
    int main() {
        HuffmamTree HT;
        int n;
        cout<<"请输入叶子节点个数:";
        cin>>n;
        CreateHuffmanTree(HT,n);
        return 0;
    }

    三、运行结果展示:

     

     

    展开全文
  • 哈夫曼树代码实现

    2014-03-15 15:50:34
    哈夫曼树的c语言实现 实现过程:着先通过 HuffmanTree() 函数构造哈夫曼树,然后在主函数 main()中 * 自底向上开始(也就是从数组序号为零的结点开始)向上层层判断,若在 * 父结点左侧,则置码为 0,若在右侧,则置...
  • 哈夫曼树编码参考程序 含 h头文件 main函数分开
  • 建立哈夫曼树

    2018-02-21 11:01:24
    哈夫曼树的建立。(可求哈弗曼编码) 算法思想: 哈夫曼树的建立: 1.在已有的字符和权中,用select函数选出其中权最小的两个字符; 2.在哈夫曼树的存储结构中,用这两个字符建立与其parent的关系; 3.从n+1到2*n-1...
  • 这是数据结构课设 哈夫曼树的c语言实现 大家可以借鉴一下
  • 主要为大家详细介绍了C++实现哈夫曼树编码解码,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 哈夫曼树C++实现

    2018-04-24 22:03:17
    数据结构编码实战:哈夫曼树c++实现可以 定义,哈夫曼各种函数实现
  • 哈夫曼树 代码实现

    千次阅读 2017-10-09 15:23:13
    什么是哈夫曼树哈夫曼树又称最优二叉树, 是一种带权路径最短的二叉树。所谓树的路径长度,就是树中所有的叶结点 的权值乘上其到根结点的 路径长度(若根结点为0层,叶结点到根结点的路径长度 为叶结点的层数)...

    什么是哈夫曼树。哈夫曼树又称最优二叉树,

    是一种带权路径最短的二叉树。所谓树的路径长度,就是树中所有的叶结点

    的权值乘上其到根结点的 路径长度(若根结点为0层,叶结点到根结点的路径长度

    为叶结点的层数)。树的带权路径长度记为W= (W1*L1+W2*L2+W3*L3+...+Wn*Ln)

    ,N个权值Wi(i=1,2,...n)构成一棵有N个叶结点的二叉树,相应的叶结点的路径

    长度为Li(i=1,2,...n)。可以证明哈夫曼树的W是最小的。

    实现代码 

    #include <stdio.h>
    #include<stdlib.h>
     
    #define MAXBIT      100
    #define MAXVALUE  10000
    #define MAXLEAF     30
    #define MAXNODE    MAXLEAF*2 -1
     
    typedef struct 
    {
        int bit[MAXBIT];
        int start;
    } HCodeType;        /* 编码结构体 */
    typedef struct
    {
        int weight;
        int parent;
        int lchild;
        int rchild;
        int value;
    } HNodeType;        /* 结点结构体 */
     
    /* 构造一颗哈夫曼树 */
    void HuffmanTree (HNodeType HuffNode[MAXNODE],  int n)
         int i, j, m1, m2, x1, x2;
        /* 初始化存放哈夫曼树数组 中的结点 */
        for (i=0; i<2*n-1; i++)
        {
            HuffNode[i].weight = 0;
            HuffNode[i].parent =-1;
            HuffNode[i].lchild =-1;
            HuffNode[i].rchild =-1;
            HuffNode[i].value=i; //实际值,
        } 
     
        /* 输入 n 个叶子结点的权值 */
        for (i=0; i<n; i++)
        {
            printf ("Please input weight of leaf node %d: \n", i);
            scanf ("%d", &HuffNode[i].weight);
        } /* end for */
     
        /* 循环构造 Huffman 树 */
        for (i=0; i<n-1; i++)
        {
            m1=m2=MAXVALUE;     /* m1、m2中存放两个无父结点且结点权值最小的两个结点 */
            x1=x2=0;
            /* 找出所有结点中权值最小、无父结点的两个结点,并合并之为一颗二叉树 */
            for (j=0; j<n+i; j++)
            {
                if (HuffNode[j].weight < m1 && HuffNode[j].parent==-1)
                {
                    m2=m1; 
                    x2=x1; 
                    m1=HuffNode[j].weight;
                    x1=j;
                }
                else if (HuffNode[j].weight < m2 && HuffNode[j].parent==-1)
                {
                    m2=HuffNode[j].weight;
                    x2=j;
                }
            }
                /* 设置找到的两个子结点 x1、x2 的父结点信息 */
            HuffNode[x1].parent  = n+i;
            HuffNode[x2].parent  = n+i;
            HuffNode[n+i].weight = HuffNode[x1].weight + HuffNode[x2].weight;
            HuffNode[n+i].lchild = x1;
            HuffNode[n+i].rchild = x2;
     
            printf ("x1.weight and x2.weight in round %d: %d, %d\n", i+1, HuffNode[x1].weight, HuffNode[x2].weight);  /* 用于测试 */
            printf ("\n");
        } /* end for */
      /*  for(i=0;i<n+2;i++)
        {
            printf(" Parents:%d,lchild:%d,rchild:%d,value:%d,weight:%d\n",HuffNode[i].parent,HuffNode[i].lchild,HuffNode[i].rchild,HuffNode[i].value,HuffNode[i].weight);
                      }*///测试 
    } /* 结束 */
     
     
    
    void decodeing(char string[],HNodeType Buf[],int Num)
    {
      int i,tmp=0,code[1024];
      int m=2*Num-1;
      char *nump;
      char num[1024];
      for(i=0;i<strlen(string);i++)
      {
       if(string[i]=='0')
      num[i]=0;        
      else
      num[i]=1;                    
      } 
      i=0;
      nump=&num[0];
      
     while(nump<(&num[strlen(string)]))
     {tmp=m-1;
      while((Buf[tmp].lchild!=-1)&&(Buf[tmp].rchild!=-1))
      {
      
       if(*nump==0)
       {
         tmp=Buf[tmp].lchild ;          
       } 
       else tmp=Buf[tmp].rchild;
       nump++;
            
      } 
      
      printf("%d",Buf[tmp].value);                                  
     }
     
      
    }
     
     
    int main(void)
    {
        
        HNodeType HuffNode[MAXNODE];            /* 定义一个结点结构体数组 */
        HCodeType HuffCode[MAXLEAF],  cd;       /* 定义一个编码结构体数组, 同时定义一个临时变量来存放求解编码时的信息 */
        int i, j, c, p, n;
        char pp[100];
        printf ("Please input n:\n");
        scanf ("%d", &n);
        HuffmanTree (HuffNode, n);
       
        
        for (i=0; i < n; i++)
        {
            cd.start = n-1;
            c = i;
            p = HuffNode[c].parent;
            while (p != -1)   /* 父结点存在 */
            {
                if (HuffNode[p].lchild == c)
                    cd.bit[cd.start] = 0;
                else
                    cd.bit[cd.start] = 1;
                cd.start--;        /* 求编码的低一位 */
                c=p;                    
                p=HuffNode[c].parent;    /* 设置下一循环条件 */
            } /* end while */
            
            /* 保存求出的每个叶结点的哈夫曼编码和编码的起始位 */
            for (j=cd.start+1; j<n; j++)
            { HuffCode[i].bit[j] = cd.bit[j];}
            HuffCode[i].start = cd.start;
        } /* end for */
        
        /* 输出已保存好的所有存在编码的哈夫曼编码 */
        for (i=0; i<n; i++)
        {
            printf ("%d 's Huffman code is: ", i);
            for (j=HuffCode[i].start+1; j < n; j++)
            {
                printf ("%d", HuffCode[i].bit[j]);
            }
            printf(" start:%d",HuffCode[i].start);
           
            printf ("\n");
            
        }
    /*    for(i=0;i<n;i++){
        for(j=0;j<n;j++)
            {
                 printf ("%d", HuffCode[i].bit[j]);           
            }
            printf("\n");
            }*/
        printf("Decoding?Please Enter code:\n");
        scanf("%s",&pp);
    decodeing(pp,HuffNode,n);
        getch();
        return 0;
    }




    展开全文
  • 数据结构基于C++的书实验的代码,有需要的可以下载参考
  • 给定N个权值作为N个叶子结点,构造一棵二叉树,若该树的带权路径长度达到最小,称这样的二叉树为最优二叉树,也称为哈夫曼树(Huffman Tree)。哈夫曼树是带权路径长度最短的树,权值较大的结点离根较近。
  • 哈夫曼树的构造什么是哈夫曼树理解哈夫曼树哈夫曼树的构造哈夫曼树构造-代码实现 什么是哈夫曼树 构造一颗二叉树,该树的带权路径长度达到最小,称为最优二叉树,也称为哈夫曼树(Huffman Tree) 注:带权路径长度...

    什么是哈夫曼树

    构造一颗二叉树,该树的带权路径长度达到最小,称为最优二叉树,也称为哈夫曼树(Huffman Tree)

    注:带权路径长度就是下文提到的树的编码长度

    理解哈夫曼树

    为了更深理解哈夫曼树的由来,我们先来举个例子一步一步引入哈弗曼树是如何解决编码问题的

    假设有一串字符,包含abcdefg这几个字符,每个字符出现的频次不同,如图:
    在这里插入图片描述
    先来思考一下,给定一段字符串,如何对字符串进行编码可以使得字符串的编码存储空间最少?

    假如一段文本中,有58个字符,那么,
    用ASCII编码:58 x 8 = 464位
    用等长3位编码:58 x 3 = 174位
    用不等长编码:出现频次高的字符用的编码短些,出现频次低编码长

    那么我们重新计算一下编码长度,如下图:
    在这里插入图片描述
    10x3+15x2+12x2+3x5+4x4+13x2+1x5=146位,算完以后,是不是占用存储空间小了很多,但这还不是最小的,那么有什么办法可以使得字符编码的存储空间最小呢?答:二叉树

    二叉树进行编码
    将二叉树的左右分支设置为0和1,可以将频次高低不同的字符进行字符编码,如图,是4个频次最高的字符
    在这里插入图片描述
    经过字符重新编码以后,
    b 编码 0
    f 编码 1
    c 编码 10
    a 编码 11

    思考:不等长编码容易出现什么问题?
    举例:1011是什么字符串的编码呢?
    如图,1011可以代表以下这几种字符组合的可能,容易出现二义性
    在这里插入图片描述
    那么,如何避免二义性
    答:字符只在叶子节点上就不会有二义性,如图:
    在这里插入图片描述
    在这里插入图片描述
    这样10只能是f,11只能是b,具有唯一性

    那么问题来了,我们怎么解决不等长问题的空间存储最小呢?终于说到哈夫曼树了

    哈夫曼树的构造

    • 每次把权值最小的两棵二叉树合并;
    • 左节点权值比右节点小

    构造步骤如图:
    在这里插入图片描述
    ![在这里插入图片描述](https://img-blog.csdnimg.cn/20210614233028672.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L211cm9uZ3lleWU=,size_16,color_FFFFFF,t_70
    在这里插入图片描述
    在这里插入图片描述
    看步骤(6)中就是最终构造的哈夫曼树了,所有节点都在叶子节点上,
    也是带权路径长度最小的了,用每个节点的值和距离根节点的深度相乘再将值加起来,就是我们上文例子中算出来的值10x3+15x2+12x2+3x5+4x4+13x2+1x5=146位

    哈夫曼树构造-代码实现

    /**
     * 哈夫曼树
     */
    
    public class HuffmanTree {
        //节点
        public static class Node<E> {
            E data; //数据
            int weight; //权重
            Node leftChild; //左子节点
            Node rightChild;//右子节点
    
            public Node(E data, int weight) {
                super();
                this.data = data;
                this.weight = weight;
            }
    
            public String toString() {
                return "Node[" + weight + ",data=" + data + "]";
            }
        }
    
        public static void main(String[] args) {
            List<Node> nodes = new ArrayList<Node>();
            //把节点加入至list中
            nodes.add(new Node("a", 10));
            nodes.add(new Node("b", 15));
            nodes.add(new Node("c", 12));
            nodes.add(new Node("d", 3));
            nodes.add(new Node("e", 4));
            nodes.add(new Node("f", 13));
            nodes.add(new Node("g", 1));
            //进行哈夫曼树的构造
            Node root = HuffmanTree.createTree(nodes);
            //打印哈夫曼树
            printTree(root);
    
        }
    
        /**
         * 构造哈夫曼树
         *
         * @param nodes
         *            节点集合
         * @return 构造出来的哈夫曼树的根节点
         */
        private static Node createTree(List<Node> nodes) {
            //如果节点node列表中海油2个和2个以上的节点
            while(nodes.size()>1){
                //什么是最小的,list表进行排序,增序的方式, 0,1,
                sort(nodes);//排序方式是增序的
                Node left = nodes.get(0);//权重最小的
                Node right = nodes.get(1);//权重第二小的
                //生成一个新的节点(父节点),父节点的权重为两个子节点的之和
                Node parent = new Node(null,left.weight+right.weight);
                //树的连接,让子节点与父节点进行连接
                parent.leftChild = left;
                parent.rightChild = right;
                nodes.remove(0);//删除最小的
                nodes.remove(0);//删除第二小的。
                nodes.add(parent);
            }
            return nodes.get(0); //返回根节点
        }
        /**
         * 冒泡排序,用于对节点进行排序(增序排序)
         *
         * @param nodes
         */
        public static void sort(List<Node> nodes) {
            if (nodes.size() <= 1)
                return ;
            /*循环数组长度的次数*/
            for (int i = 0; i < nodes.size(); i++){
                /*从第0个元素开始,依次和后面的元素进行比较
                 * j < array.length - 1 - i表示第[array.length - 1 - i]
                 * 个元素已经冒泡到了合适的位置,无需进行比较,可以减少比较次数*/
                for (int j = 0; j < nodes.size() - 1 - i; j++){
                    /*如果第j个节点比后面的第j+1节点权重大,交换两者的位置*/
                    if (nodes.get(j + 1).weight < nodes.get(j).weight) {
                        Node temp = nodes.get(j + 1);
                        nodes.set(j+1,nodes.get(j));
                        nodes.set(j,temp);
                    }
                }
            }
            return ;
        }
    
        /*
    
         * 递归打印哈夫曼树(先左子树,后右子树打印)
         */
    
        public static void printTree(Node root) {
            System.out.println(root.toString());
            if(root.leftChild !=null){
                System.out.print("left:");
                printTree(root.leftChild);
            }
            if(root.rightChild !=null){
                System.out.print("right:");
                printTree(root.rightChild);
            }
        }
    }
    
    展开全文
  • 实 验 报 告 实验目的 掌握哈夫曼树的基本概念及所用的存储结构 掌握哈夫曼树的建立算法 掌握哈夫曼树的应用哈夫曼树的编码和译码 实验内容 给定权值529781423311建立哈夫曼树输出哈夫曼编码对上述给定的哈夫曼树及...
  • 本篇文章主要介绍了C++哈夫曼树编码和译码的实现,详细的讲诉了哈夫曼树编码的原理,有需要的同学可以了解一下。
  • c语言哈夫曼树构造代码 博主就很掘的一个人,最近学哈夫曼树,想着用指针去实现,觉得用指针实现,内存消耗会更少,写到后面发现越来与麻烦,且内存开销并没有减少,于是还是使用结构体数组中规中矩的去实现哈夫曼树...

    c语言哈夫曼树构造代码

    博主就很掘的一个人,最近学哈夫曼树,想着用指针去实现,觉得用指针实现,内存消耗会更少,写到后面发现越来与麻烦,且内存开销并没有减少,于是还是使用结构体数组中规中矩的去实现哈夫曼树,博主不爱看别人的代码,知道原理便直接上手实现,所以,我的代码往往更加简单,因为,自己写,越简单越好,谁愿意写复杂的代码呢,学习哈夫曼树得小伙伴可以学习学习下面的代码。

    #include<stdio.h>
    #include<stdlib.h>
    
    typedef struct Tree {
    	int data = -1;
    	int parent = -1;
    	int  lchild = -1;
    	int rchild = -1;
    
    }Tree;
    
    void InitHuffmanTree(Tree HT[],int a[],int n) {
    	int i;
    	for (i = 0; i < n; i++) {
    		HT[i].data= a[i];
    	//	HT[i].rchild = NULL;
    		//HT[i].lchild = NULL;
    	}
    
    }
    
    void HuffmanTree_print(Tree HT[], int  n ) {
    
    	int i;
    	for (i = 0; i < n; i++) {
    		printf("%d ", HT[i].data);
    	//	printf("%d ", HT[i].parent);
    	}
    }
    void select(Tree HT[],int n) {
    	int min1, min2, min1_index, min2_index;
    	int ju1=0 ,ju2=0;
    	for (int i = 0; i < n; i++) {
    		if (HT[i].parent == -1 && ju1==0) {
    			min1 = HT[i].data;
    			min1_index = i;
    			ju1 = 1;
    
    		}
    		if (HT[i].parent == -1 && ju1 != 0&& min1> HT[i].data) {
    			min1 = HT[i].data;
    			min1_index = i;
    		}
    	}
    	HT[min1_index].parent = n;
    	for (int i = 0; i < n; i++) {
    		if (HT[i].parent == -1 && ju2 == 0) {
    			min2 = HT[i].data;
    			min2_index = i;
    			ju2 = 1;
    
    		}
    		if (HT[i].parent == -1 && ju2 != 0 && min2 > HT[i].data) {
    			min2 = HT[i].data;
    			min2_index = i;
    			
    
    		}
    	}
    	HT[min2_index].parent = n;
    	HT[n].data = HT[min2_index].data + HT[min1_index].data;
    
    	HT[n].lchild = min1_index;
    	HT[n].rchild = min2_index;
    	
    	//printf("%d", HT[n].data);
    
    }
    
    void CreateHuffmanTree(Tree HT[], int n) {
    	int min1, min2, min1_index, min2_index;
    	int i;
    	for (i = n; i < 2 * n - 1; i++) {
    		select(HT, i);
    		HuffmanTree_print(HT, i);
    		printf("\n");
    	}
    	
    }
    void HuffmanTree_erfodic(Tree HT[], int top) {
    	
    	printf("%d ", HT[top].data);
    	if (HT[top].lchild != -1) {
    		HuffmanTree_erfodic(HT,HT[top].lchild);
    	}
    	if (HT[top].rchild != -1) {
    		HuffmanTree_erfodic(HT,HT[top].rchild);
    	}
    
    }
    
    int main() {
    	Tree* T=NULL;
    	int i;
    	int a[] = { 4,6,7,2,5,8,6,9 };
    	
    	Tree HT[16];
    	//sort_data(a, 8);
    	InitHuffmanTree(HT, a, 8);
    	CreateHuffmanTree(HT, 8);
    	//HuffmanTree_print(HT, 8);
    	
    	//data_print(a, 8);//输出数组元素
    	//createTree(T);
    	HuffmanTree_erfodic(HT,14);
    	printf("\n%d ", T);//输出树的根节点地址
    	return 0;
    
    }
    
    展开全文
  • NULL 博文链接:https://128kj.iteye.com/blog/1637940
  • 【C++数据结构】哈夫曼树代码实现

    千次阅读 2017-03-14 21:00:59
    // 传入语句 生成相应的哈夫曼树 int GetTotalWeight( void ); // 得到总权重 string GetEnCode( void ); // 得到编码 string GetDeCode( string str); // 解码 void Display( void ); //显示 ...
  • C++实现的哈夫曼树的生成已经解码。绝对好用!
  • 哈夫曼树java代码实现

    2019-10-22 19:06:28
    哈夫曼树哈夫曼树是一种带权路径长度最短的二叉树,也称为最优二叉树。下面用一幅图来说明。 package com.sun.hafumanTree; import java.security.PublicKey; import java.util.ArrayList; import java.util....
  • 1. 将提供的字符串(自定义字符串)进行排序,获取...5. 直到链表中只剩一个节点时,将此节点赋给哈夫曼树头; 6. 利用创建的哈夫曼树得到编码; 用递归得到叶子节点,由叶子节点追溯到根节点,得到编码后反转顺序;
  • 哈夫曼树功能函数 测试样例 实现代码 哈夫曼树功能函数 void CreatHuffmanTree(HuffmanTree &HT, int n);//构造哈夫曼树 void PrintT(HuffmanTree HT, int n); //打印哈夫曼树 void CreatHu...
  • 哈夫曼树的构建代码

    2020-12-15 11:40:21
    哈夫曼树的构建代码 输入一个字符串,构建相应的哈夫曼树,输出WPL。 #include <iostream> #include<cstdio> #include<cstring> #include<stdlib.h> using namespace std; #define INF 0x3...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 13,108
精华内容 5,243
关键字:

哈夫曼树的代码