精华内容
下载资源
问答
  • 代码为.cpp程序,可用DevC打开运行,或许有一些不合理的地方或者错误地方,烦请各位加以批评指正,共同进步。
  • 哈夫曼树c语言编写

    2017-08-30 18:15:09
    哈夫曼树构造 输出
  • 哈夫曼树C语言实现

    2021-08-20 16:28:23
    本文实现了用C语言表达的哈夫曼树。欢迎关注个人博客:https://guotianyu-2020.github.io。 1.代码部分 哈夫曼树是带权路径长度最短的树。当给定节点数以及节点的权时,按如下方法创造哈夫曼树。 (1)给定的n个...

    本文实现了用C语言表达的哈夫曼树。欢迎关注个人博客:https://guotianyu-2020.github.io。

    1.代码部分

    哈夫曼树是带权路径长度最短的树。当给定节点数以及节点的权时,按如下方法创造哈夫曼树。

    (1)给定的n个节点构成n个二叉树的森林;

    (2)在森林中选取两棵根节点权重最小的树作为左右子树进而创造新的二叉树,二叉树的根节点权值是左右子树根节点权重之和;

    (3)在森林中删除这两棵树并把新树加入其中;

    (4)重复(2)(3)直至森林中只剩下一棵树为止。

    哈夫曼树采用顺序存储结构,结构体内包含权重、亲代编号、左右子树编号。如下:

    typedef struct {
    	int weight;
    	int parent, rchild, lchild;
    }HTNode;
    

    实现原理比较简单不多赘述。下面是创建函数,需要传入叶子节点的数目。

    void CreatHuffmanTree(int n)  // N leaf nodes.
    {
    	if (n <= 1) { printf("None."); }
    	else 
    	{
    		int i, weight;
    		int m = 2 * n - 1;
    		int s1 = 0, s2 = 0;
    		HTNode* HT = (HTNode*)malloc(20 * sizeof(HTNode));  // See HT as an array.
    		if (HT)
    		{
    			for (i = 1; i <= m;  i++)  // Initialize the array.
    			{
    				HT[i].lchild = HT[i].rchild = HT[i].parent = 0;
    			}
    			for (i = 1; i <= n; i++)
    			{
    				printf("Input weight:\n");
    				scanf_s("%d", &weight);
    				HT[i].weight = weight;  // Value assignment.
    			}
    			for (i = n + 1; i <= m; i++)
    			{
    				Select(HT, i - 1, m, &s1, &s2);  // Funtion Select chooses the smallest two elements.
    				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;
    			}
    		}
    	}	
    }
    

    在其中,需要实现在森林中寻找最小两个根节点权值的函数Select,如下:

    void Select(HTNode* ht, int leaves, int n, int* k1, int* k2)
    {
    	int i, j = 0, min1 = 19, min2 = 19;
    	int p1 = 0, p2 = 0;
    	int pos = 0;
    	int flag = 0;
    	int* num = (int*)malloc(20 * sizeof(int));
    	if (num)
    	{
    		for (i = 1; i <= leaves; i++)
    		{
    			if (ht[i].parent == 0)
    			{
    				j++;
    				num[j] = ht[i].weight;
    			}
    		}
    		for (i = 1; i <= j; i++)
    		{
    			if (min1 < num[i] && min1 > 0)
    			{
    				min1 = min1;
    			}
    			else
    			{
    				min1 = num[i];
    				pos = i;
    			}
    		}
    		for (i = 1; i <= j; i++)
    		{
    			if (i != pos && min2 > num[i])
    			{
    				min2 = num[i];
    			}
    			else
    			{
    				min2 = min2;
    			}
    		}
    		for (i = 1; i <= leaves; i++)
    		{
    			if (flag == 0 && ht[i].weight == min1)
    			{
    				p1 = i;
    				flag = 1;
    				continue;
    			}
    			if (ht[i].weight == min2)
    			{
    				p2 = i;
    				if (flag == 1)
    				{
    					break;
    				}
    				else
    				{
    					continue;
    				}
    			}
    			else
    			{
    				continue;
    			}
    		}
    		*k1 = p1;
    		*k2 = p2;
    	}
    	else
    	{
    		printf("ERROR.");
    	}
    }
    

    主函数,可自行更改节点数:

    int main()
    {
    	int n = 8;
    	CreatHuffmanTree(n);
    	return 0;
    }
    

    2.改进与反思

    Select函数可以做的更加精简,其本质就是返回数组的两个最小值。

    展开全文
  • 哈夫曼树的构建(C语言版) 课程要求: 左0,右1 左子树根节点 < 右 子树根节点 节点 data, w , lchild, rchild 建立哈夫曼 (有序单链表) 初始:循环输入字符与权值,创建节点,插入到链表中 形成一个包含n个...

    哈夫曼树的构建(C语言版)

    课程要求

    左0,右1
    左子树根节点 < 右 子树根节点
    节点 data, w , lchild, rchild
    建立哈夫曼 (有序单链表)
    初始:循环输入字符与权值,创建节点,插入到链表中 形成一个包含n个节点的递增单链表
    然后:将第一、二两个节点从单链表中删除,然后合并形成新的节点,新节点插入到有序表中,直至剩下一个节点。
    可以通过递归遍历的方法得到每个字符的 哈夫曼编码

    1. 建立有序单链表
    有序单链表
    typedef struct Link{
        int  w;//存储整形权重
        char data;//存储char类型字符 
        struct Link *next;//指向直接后继元素的指针
        struct Link *lchild;
    	struct Link *rchild;
    }Link;
    
    1. 初始化链表
    Link* InitLink(){
    	Link* link = (Link*)malloc(sizeof(Link));//创建头结点 
    	link->next = NULL;//头结点的next为空
    	link->lchild = link->rchild = NULL;
    	return link; 
    }
    
    1. 排序插入元素(可以选择头插或者尾插,然后排序)
    void InsertLink(Link* link,Link* node){
    	
    	Link* p = link;
    	Link* q = p->next;
    	
     	while(q && node->w>q->w)
     	{
     		p=q;//记录位置 
     		q=q->next;
    	 }
    	 node->next = q;
    	 p->next = node;
    	
    }
    
    1. 删除节点,返回被删除的节点
    Link* DelLink(Link* link,int index){
    	Link *p, *s;
    	int i = 0;
    	p = link;
    	while(i<index-1 && p->next != NULL)	//搜索指定位置前一个节点
    	{
    		i++;
    		p = p->next;
    	}
    	if(i != index-1 || p->next == NULL)
    		printf("删除位置非法");
    	s = p->next;
    	p->next = s->next;
    
    //	free(s);//释放节点 
    	return s;//返回被删除的节点,后面步骤用
    } 
    
    1. 创建哈夫曼树
    Link* CreateHuffManTree(Link* link,int n){
    		Link *del1,*del2,*p;
    		Link* node ;
    		int w_sum,i;
    		p = link;		
    		for(i=0;i<n-1;i++){
    			
    		del1 = DelLink(p,1);//最小的元素 
    		del2 = DelLink(p,1);//第二小的元素
    		w_sum = del1->w + del2->w; //两个最小的数的和
    		
    		node = (Link*)malloc(sizeof(Link));
    		node->lchild= del1;
    		node->rchild= del2;
    		node->w = w_sum;
    		
    		InsertLink(link,node);
    					
    		}
    		return node; 
    		
    }
    
    1. 哈夫曼编码
    void getCoding(Link *tree,int len){
    	if(!tree)
    	return;
    	static int a[20]; //定义静态数组a,保存每个叶子的编码,数组长度至少是树深度减一
    	int i;
    	if(!tree->lchild && !tree->rchild){
    		printf(" %c的哈夫曼编码为:",tree->data);
    		for(i = 0; i < len; i++)
    		printf("%d",a[i]);
    		printf("\n");
    	}
    	else{//访问到非叶子结点时分别向左右子树递归调用,并把分支上的0、1编码保存到数组a ,的对应元素中,向下深入一层时len值增1 
    		a[len] = 0;
    		getCoding(tree->lchild, len + 1);
    		a[len] = 1;
    		getCoding(tree->rchild, len + 1);
    		
    	}
    }
    
    1. 打印有序链表
    void PrintLink(Link* link){
    	Link* p = link->next;
    	while(p){
    		printf("(%c,%d)",p->data,p->w);
    		p = p->next;
    	}
    	printf("\n");
    }
    
    1. 打印哈夫曼树
    void PrintTree(Link* BT){
    	if (BT != NULL)
        {
            printf("%d", BT->w); //输出根结点的值
            if (BT->lchild != NULL || BT->rchild != NULL)
            {
                printf("(");
                PrintTree(BT->lchild); //输出左子树
                if (BT->rchild != NULL)
                    printf(",");
                PrintTree(BT->rchild); //输出右子树
                printf(")");
            }
        }
    } 
    

    完整代码:

    #include<stdio.h>
    #include<stdlib.h>
    #include<malloc.h>
    /**
    左0,右1
    左子树根节点 <  右 子树根节点 
    节点  data, w , lchild, rchild
    建立哈夫曼 (有序单链表)  
    初始:循环输入字符与权值,创建节点,插入到链表中  形成一个包含8个节点的递增单链表
    然后:将第一、二两个节点从单链表中删除,然后合并形成新的节点,新节点插入到有序表中,直至剩下一个节点。
    可以通过递归遍历的方法得到每个字符的 哈夫曼编码
    **/
    
    //有序单链表
    typedef struct Link{
      int  w;//存储整形权重
      char data;//存储char类型字符 
      struct Link *next;//指向直接后继元素的指针
      struct Link *lchild;
      struct Link *rchild;
    }Link;
    
    
    //初始化链表 
    Link* InitLink(){
      Link* link = (Link*)malloc(sizeof(Link));//创建头结点 
      link->next = NULL;//头结点的next为空
      link->lchild = link->rchild = NULL;
      return link; 
    }
    
    //排序插入元素
    void InsertLink(Link* link,Link* node){
      
      Link* p = link;
      Link* q = p->next;
      
      while(q && node->w>q->w)
      {
      	p=q;//记录位置 
      	q=q->next;
       }
       node->next = q;
       p->next = node;
      
    }
    
    //删除节点,返回被删除的节点 
    Link* DelLink(Link* link,int index){
      Link *p, *s;
      int i = 0;
      p = link;
      while(i<index-1 && p->next != NULL)	//搜索指定位置前一个节点
      {
      	i++;
      	p = p->next;
      }
      if(i != index-1 || p->next == NULL)
      	printf("删除位置非法");
      s = p->next;
      p->next = s->next;
    
    //	free(s);//释放节点 
      return s;
    
    } 
    
    //打印有序链表
    void PrintLink(Link* link){
      Link* p = link->next;
      while(p){
      	printf("(%c,%d)",p->data,p->w);
      	p = p->next;
      }
      printf("\n");
    }
    
    //打印树
    void PrintTree(Link* BT){
      if (BT != NULL)
      {
          printf("%d", BT->w); //输出根结点的值
          if (BT->lchild != NULL || BT->rchild != NULL)
          {
              printf("(");
              PrintTree(BT->lchild); //输出左子树
              if (BT->rchild != NULL)
                  printf(",");
              PrintTree(BT->rchild); //输出右子树
              printf(")");
          }
      }
    } 
    
    //创建哈夫曼树 
    Link* CreateHuffManTree(Link* link,int n){
      	Link *del1,*del2,*p;
      	Link* node ;
      	int w_sum,i;
      	p = link;		
      	for(i=0;i<n-1;i++){
      		
      	del1 = DelLink(p,1);//最小的元素 
      	del2 = DelLink(p,1);//第二小的元素
      	w_sum = del1->w + del2->w; //两个最小的数的和
      	
      	node = (Link*)malloc(sizeof(Link));
      	node->lchild= del1;
      	node->rchild= del2;
      	node->w = w_sum;
      	
      	InsertLink(link,node);
      				
      	}
      	return node; 
      	
    }
    
    
    //哈夫曼编码 
    void getCoding(Link *tree,int len){
      if(!tree)
      return;
      static int a[20]; //定义静态数组a,保存每个叶子的编码,数组长度至少是树深度减一
      int i;
      if(!tree->lchild && !tree->rchild){
      	printf(" %c的哈夫曼编码为:",tree->data);
      	for(i = 0; i < len; i++)
      	printf("%d",a[i]);
      	printf("\n");
      }
      else{//访问到非叶子结点时分别向左右子树递归调用,并把分支上的0、1编码保存到数组a ,的对应元素中,向下深入一层时len值增1 
      	a[len] = 0;
      	getCoding(tree->lchild, len + 1);
      	a[len] = 1;
      	getCoding(tree->rchild, len + 1);
      	
      }
    }
    
    
    void main(){
      Link* link = InitLink();//初始化链表
      Link* tree;
      int num,w,i;//长度
      char data;
      printf("输入元素个数:");
      scanf("%d",&num);getchar();
      for(i=0;i<num;i++){
      	printf("第%d个元素的字符:",i+1);
      	scanf("%c",&data);getchar();
      	printf("第%d个元素的权重:",i+1);
      	scanf("%d",&w);getchar();
      	Link* node = (Link*)malloc(sizeof(Link));;
      	node->data = data;node->w = w;
      	InsertLink(link,node);
      }
      printf("******************\n");
      tree = CreateHuffManTree(link,num);
      printf("哈夫曼树:"); 
      PrintTree(tree);printf("\n"); 
      getCoding(tree,0);
    
    } 
    

    以上为课题作业,哈夫曼树实现方式有多种,请自行查阅。

    展开全文
  • #include <...//创建哈夫曼树 void CreateHT(HTNode ht[],int n) { int i,k,lnode,rnode; double min1,min2; for (i=0;i<2*n-1;i++) /*所有结点的相关域置初值-1*/ ht[i].parent=ht[i].lchild=ht.
    #include <stdio.h>
    #include "tree.h"
    #include <string.h>
    
    //创建哈夫曼树
    void CreateHT(HTNode ht[],int n)
    {
        int i,k,lnode,rnode;
        double min1,min2;
        for (i=0;i<2*n-1;i++)            /*所有结点的相关域置初值-1*/
            ht[i].parent=ht[i].lchild=ht[i].rchild=-1;
        for (i=n;i<2*n-1;i++)            /*构造哈夫曼树*/
        {
            /********** Begin **********/
            min1=min2=32767;
            lnode=rnode=-1;
            for(k=0;k<=i-1;k++)
            {
                if(ht[k].parent==-1)
                {
                    if(ht[k].weight<min1)
                    {
                        min2=min1;
                        rnode=lnode;
                        min1=ht[k].weight;
                        lnode=k;
                    }
                    else if (ht[k].weight<min2)
                    {
                        min2=ht[k].weight;
                        rnode=k;
                    }
                }
            }
            ht[i].weight=ht[lnode].weight + ht[rnode].weight;
            ht[i].lchild=lnode;
            ht[i].rchild=rnode;
            ht[lnode].parent=i;
            ht[rnode].parent=i;
            /********** End **********/
        }
    }
    
     //根据哈夫曼树求哈夫曼编码
    void CreateHCode(HTNode ht[],HCode hcd[],int n)
    {
        int i,f,c;
        HCode hc;
        for (i=0;i<n;i++)   
        {
            hc.start=n;c=i;
            f=ht[i].parent;
            while (f!=-1)    /*循序直到树根结点*/
            {
                /********** Begin **********/
                if(ht[f].lchild==c)
    				hc.cd[hc.start--]='0';
    			else
    				hc.cd[hc.start--]='1';
    			c=f;
    			f=ht[f].parent;
                /********** End **********/
            }
            hc.start++;        /*start指向哈夫曼编码最开始字符*/
            hcd[i]=hc;
        }
    }
    
    //输出哈夫曼编码
    void DispHCode(HTNode ht[],HCode hcd[],int n)
    {
        int i,k;
        double sum=0,m=0;
        int j;
        for (i=0;i<n;i++)
        {
            j=0;
            printf("%s:\t",ht[i].data);
            for (k=hcd[i].start;k<=n;k++)
            {
                printf("%c",hcd[i].cd[k]);
                j++;
            }
            m+=ht[i].weight;
            sum+=ht[i].weight*j;
            printf("\n");
        }
        printf("平均长度=%g\n",1.0*sum/m);
    }

    展开全文
  • C语言实现哈夫曼树的建立

    千次阅读 2020-05-22 16:45:59
    建立哈弗曼,也就是把一片森林转换成一棵,遵循权重越大的离根节点越近,权重越小的离根节点越远的原则。 例如A,B,C,D四棵组成的森林:权重分别是3,6,7,8 选择两颗权重最小的组成一颗新,A,B分别为左孩子...

    建立哈弗曼树,也就是把一片森林转换成一棵树,遵循权重越大的离根节点越近,权重越小的离根节点越远的原则。
    例如A,B,C,D四棵树组成的森林:权重分别是3,6,7,8
    选择两棵树选择两颗权重最小的树组成一颗新树,A,B分别为左孩子右孩子,在删掉森林里A,B两棵树,在重复前面的操作,直到森林里只剩下一棵树。
    完整代码

    #include<stdio.h>
    #include<stdlib.h>
    #define NODE 10  //叶子结点数量
    #define MAXNODE 2*NODE-1  //总结点数量
    
    typedef struct huffmantree {
    	int weight;
    	int leftchild;
    	int rightchild;
    	int parent;
    }Huffmantree,*hfnode;
    
    int select(Huffmantree* T,int *s1,int *s2) {
    	int m1=-1, m2=-1;
    	int i = 1;
    	while ( i <= MAXNODE && m1==-1) {//找到第一个没有双亲的结点
    		if (T[i].parent == 0) {
    			m1 = T[i].weight;
    			*s1 = i;
    			i++;
    		}
    		else
    			i++;
    	}
    	while ( i <= MAXNODE) {//m1为最小权重,s1为下标
    		if (T[i].parent == 0&& T[i].weight!=NULL) {
    			if (m1 > T[i].weight) {
    				m1 = T[i].weight;
    				*s1 = i;
    				i++;
    			}
    			else
    				i++;
    		}
    		else
    			i++;
    	}
    		i = 1;
    		while ( i <= MAXNODE && m2 == -1) {//找到第一个没有双亲的结点
    			if (T[i].parent == 0) {
    				if (i == *s1) {//排除s2找到和s1同一个结点
    					i++;
    				}
    				else {
    					m2 = T[i].weight;
    					*s2 = i;
    					i++;
    				}
    			}
    			else
    				i++;
    		}
    		while ( i <= MAXNODE) {//m2为次于m1的最小权重,s2为下标
    			if (T[i].parent == 0&& T[i].weight != NULL) {
    				if (i == *s1) {
    					i++;
    				}
    				else {
    					if (m2 > T[i].weight) {
    						m2 = T[i].weight;
    						*s2 = i;
    						i++;
    					}
    					else
    						i++;
    				}
    			}
    			else
    				i++;
    		}
    		return m1 + m2;
    }
    void creathf(hfnode *T) {//T[0]不使用,从T[1]开始
    	int i, m,s;
    	int s1, s2;
    	*T = (hfnode)malloc((MAXNODE+1)* sizeof(Huffmantree));
    
    	printf("输入每棵树的权重:\n");
    	for (i = 1; i <= NODE; i++) {
    		(*T + i)->leftchild = 0;
    		(*T + i)->parent = 0;
    		(*T + i)->rightchild = 0;
    		printf("输入第%d颗树的权重:", i);
    		scanf_s("%d", &m);
    		(*T + i)->weight = m;
    	}
    	for (i = NODE + 1; i <= MAXNODE; i++) {
    		s= select(*T, &s1, &s2);
    		(*T)[s1].parent = i;
    		(*T)[s2].parent = i;
    		(*T)[i].weight = s;
    		(*T)[i].leftchild = s1;
    		(*T)[i].rightchild = s2;
    		(*T)[i].parent = 0;
    	}
    }
    void disp(Huffmantree* T) {
    	int i;
    	printf("序号  权重  双亲  左孩子  右孩子\n");
    	for (i = 1; i <= MAXNODE; i++) {
    		printf("%2d    %2d    %2d    %3d     %3d\n",i,T[i].weight,T[i].parent,T[i].leftchild,T[i].rightchild);
    	}
    }
    int main() {
    	Huffmantree *t;
    	creathf(&t);
    	disp(t);
    }
    

    运行结果:
    在这里插入图片描述

    展开全文
  • 待压缩的读入文件:Compress_read.txt ...以上文件请自行创建,其中待压缩文本放在Compress_read.txt中即可编译运行。 #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;s...
  • 本文以实例形式讲述了C++实现哈夫曼树简单创建与遍历的方法,比较经典的C++算法。 本例实现的功能为:给定n个带权的节点,如何构造一棵n个带有给定权值的叶节点的二叉树,使其带全路径长度WPL最小。 据此构造出最...
  • 学校数据结构实验(c语言描述)布置了写求哈夫曼编码的作业,书上采用的是从叶子到根逆向求编码的方式(清华版数据结构c语言描述),我这里给出先序遍历,即“根左右”进行哈夫曼编码的代码#includ...
  • [树] 哈夫曼树创建 | 编码)-C语言

    千次阅读 2018-11-07 10:05:01
    文章目录编码问题哈夫曼树相关概念哈夫曼二叉树哈夫曼二叉树的特点代码哈夫曼n叉树构造 编码问题 等长码 权值相同时,效率最高 翻译很方便,定长 不等长码 缺点:有二义性,翻译的时候有困惑,不...
  • **利用哈夫曼树求解哈夫曼编码:此处的哈夫曼树为了便于遍历,采用顺序存储而不用普遍的链式存储,对于编码最重要的是要保证是前缀编码,即某一个字符的编码不能为另一个字符编码的前缀,否则会使译码出现歧义。...
  • 哈夫曼树编码-C语言

    千次阅读 多人点赞 2019-11-10 17:02:45
    哈夫曼树编码 1.实验目的 了解二叉树的定义,理解二叉树的基本性质和存储结构,掌握哈夫曼树的构造,实现哈夫曼编码与译码算法。 2.实验内容 从键盘输入一串电文字符与权值,输出对应的哈夫曼编码;从键盘输入一...
  • 哈夫曼树 C语言实现

    2018-04-05 23:59:54
    1、基本概念a、路径和路径长度若在一棵中存在着一个结点序列 k1,k2,……,kj, 使得 ki是ki+1 的双亲(1&lt;=i&lt;j),则称此结点序列是从 k1 到 kj 的路径。从 k1 到 kj 所经过的分支数称为这两点...
  • 哈夫曼树的构造(C语言实现)

    万次阅读 多人点赞 2018-12-06 17:48:27
    哈夫曼树的构造过程可以详见推荐博客:哈夫曼树以及哈夫曼编码的构造步骤 建议先看完推荐博客中的文字说明,或者自己找一本数据结构的树来仔细阅读以下关于哈夫曼树的构造 然后再来看下面给出的code 这里给出的是...
  • 哈夫曼树(霍夫曼树)又称为最优树.1、路径和路径长度在一棵树中,从一个结点往下可以达到的孩子或孙子结点之间的通路,称为路径。通路中分支的数目称为路径长度。若规定根结点的层数为1,则从根结点到第L层结点的路径...
  • 本题要求实现一个创建哈夫曼树的函数,根据输入的n个结点的权值,创建一棵哈夫曼树。例如输入5 2 3 5 7 8,其中第一个数值5,表示5个结点,2 3 5 7 8分别表示这5个结点的权值,中间用空格分开,则该函数应该输出5(2,...
  • *创建哈弗曼 *创建树 *每次遍历最小的两个节点 *译码 *遍历(解码的过程) */ #include<stdio.h> #include<stdlib.h> #include<string.h> #define n 4//的叶子节点数 #define m (2*n-1)//...
  • } } void PrintHuffTree(HTNode ht[],int n0) { //输出哈夫曼树 int i,n; printf("\n哈夫曼树各项数据如下表所示:\n"); printf(" 结点i weight parent lchid rchild\n"); for(i=1;i*n0;i++) printf("\t%d\t%d\t%d...
  • #哈夫曼树代码 #include <stdio.h> #define MAXBIT 100 #define MAXVALUE 10000 #define MAXLEAF 30 #define MAXNODE MAXLEAF*2 -1 typedef struct { int bit[MAXBIT]; int start; } HCodeT...
  • //创建哈夫曼树 void select(HuffmanTree ht,int n,int *s1,int *s2);//在前n个选项中选权值最小,且双亲为0的两个结点 main() { int n=5; HuffmanTree ht; int w[n]={5,7,3,2,8}; Create_HuffmanTree(ht,w,...
  • C语言构造哈夫曼树,并打印

    千次阅读 2020-11-22 22:47:07
    许多打印在最后没有注释掉,是debug时用的,参考了一些其他的博客,可以睡了,明天有是新的一周 #include <stdio.h> #include <stdlib.h> #define LEN 3 typedef struct Huffman.../*创建Huffman*/ Huffm
  • C语言-哈夫曼树与哈夫曼编码的实现

    千次阅读 多人点赞 2020-11-08 00:47:33
    C语言-赫夫曼与赫夫曼编码的实现
  • C语言实现哈夫曼树及哈夫曼编码存储结构查找算法创建哈夫曼树创建哈夫曼编码表代码整合测试 存储结构 //哈夫曼树存储结构 typedef struct { int weight; int parent,lchild,rchild; }HTNode,*HuffmanTree; 查找...
  • } //构造哈夫曼树 void createHFTree(HuffmanTree ht, int w[], int n) { int i, m; int s1, s2; for (i = 1; i ; i++) { ht[i].weight = w[i]; ht[i].parent = 0; ht[i].lchild = 0; ht[i].rchild = 0; } m = 2 * ...
  • c语言构造哈夫曼树-哈夫曼编码

    万次阅读 多人点赞 2018-12-05 14:59:59
    构造哈夫曼树 首先,我们需要了解哈夫曼树是什么: 一.相关知识点 路径: 路径是指从一个节点到另一个节点的分支序列。 路径长度: 指从一个节点到另一个结点所经过的分支数目。 ,从根节点到a的分支数目是2, 数...
  • //哈夫曼编码里的权值,赋值给哈夫曼树里面的权值 HT[i].lchild = HT[i].rchild = HT[i].parent = 0;//双亲,左右子树全部赋值为0 } /*整个树的节点数是2*length-1,刨去第0个,就是2*length 上面一个循环已经...
  • 哈夫曼树(C语言)

    千次阅读 热门讨论 2021-04-28 15:14:45
    1、给这个哈夫曼树创建一个结构体数组,其中分配的空间是2 * n - 1,因为我们都 知道哈夫曼树的性质有一个是:给定n个叶子节点,那么由这n个叶子节点构成 的哈夫曼树一共含有2 * n - 1个节点 2、前面n个用于存放n个...
  • #include<stdio.h> #include<stdlib.h>...//定义哈夫曼树的结点 typedef struct LinkNode { int data; struct LinkNode* lchild; struct LinkNode* rchild; }LinkNode; int len; int st_p
  • /** 哈夫曼树编码 **/#include#include#define LENGTH 6typedef int ElemType;typedef struct HuffmanTreeNode{ElemType data;//哈夫曼树中节点的权值struct HuffmanTreeNode* left;struct HuffmanTreeNode* right;}...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,235
精华内容 494
关键字:

哈夫曼树的创建c语言

c语言 订阅