数据结构-哈夫曼编码

#include <stdio.h>
#include <malloc.h>

# define LIST_MAX_LENGTH 100

typedef struct SequentialList
{
	char character;
	int parent ;
	int direction;
	int weight;
} *SequentialListPtr ;

//初始化
SequentialListPtr SequentialListInit (char paraCharacter[] , int paraData[] , int paraLength ) 
{
	SequentialListPtr resultPtr = (SequentialListPtr) malloc (sizeof(struct SequentialList)*paraLength) ;
	if(resultPtr == NULL)
	{
		printf("内存分配失败！\n") ;
		return NULL ; // 返回指针 
	}
	
	int i = 0 ;
	for(i=0;i<paraLength;i++)
	{
		resultPtr[i].direction = -1 ;
		resultPtr[i].parent = -1 ;
		resultPtr[i].character= paraCharacter[i] ;
		resultPtr[i].weight = paraData[i] ;
	}
	
	return  resultPtr ;
}

//打印
void  SequentialListPrintf (SequentialListPtr tempList , int paraLength)
{
	int i = 0;
	for(i=0;i<paraLength;i++)
	{
		printf("%c\t",tempList[i].character) ;
		printf("%d\t",tempList[i].parent ) ;
		printf("%d\t",tempList[i].direction ) ;
		printf("%d\t\n",tempList[i].weight ) ;
	}
	
}

//找最小weight,并标记direction 
int findmin (SequentialListPtr tempList , int paraLength , int number)
{
	int min_value = 9999 ; //初始化一个最大值
	int min_index = -1 ; 
	
	int i = 0 ;
	for(i=0;i<paraLength;i++)
	{
		if( tempList[i].weight < min_value && tempList[i].direction == -1 )
		{
			min_value = tempList[i].weight ;
			min_index = i ;
		}
	}
	
	if(min_index != -1)
	{
			tempList[min_index].direction = number ;
	}
	
	
	return min_index ;
	
}



//构建哈夫曼树 
int Binarytree (SequentialListPtr tempList , int paraLength)
{	
	
	int i = 0 ;
	for(i=0;i<paraLength-1;i++)
	{
		if (paraLength >= LIST_MAX_LENGTH)
		 {
            printf("超出最大长度限制！\n");
            break;
        }
		//创建新节点
	    tempList[paraLength].weight = -1 ;
	    tempList[paraLength].character = '\0' ;
	    tempList[paraLength].parent = -1 ;
	    tempList[paraLength].direction = -1 ;   
	    
	    //合并两个节点
		int min0 = findmin(tempList,paraLength,0) ;
		int min1 = findmin(tempList,paraLength,1) ;
		
		if (min0 == -1 || min1 == -1)  //终点 (始终会打印)
		{
            // printf("无法找到足够的节点！\n");
            break;
        }
        
		tempList[paraLength].weight = tempList[min0].weight  + tempList[min1].weight ;
		
		
		//设置父节点
		tempList[min0].parent  =  paraLength ;
		tempList[min1].parent  =  paraLength ;
		
		paraLength++ ;
		
	}
	return paraLength ;
}

//找编码
int findencording (SequentialListPtr tempList , char ch ,int paraLength)
{
	int i = 0 ;
	for(i=0;i<paraLength;i++)
	{
		if(tempList[i].character == ch)
		{
			printf("the encording of %c is : ",ch);
			
			//临时存储编码
			int code[LIST_MAX_LENGTH] ;
			int code_length  = 0 ;
			
			int j = i ;
			
			while(tempList[j].parent != -1 )
			{
				code[code_length++] = tempList[j].direction ;
				j = tempList[j].parent ;
			}
			
			//反向打印
			for(j = code_length-1 ; j>=0;j--)
			{
				printf("%d",code[j]);
			 } 
			printf("\n");
			return 0 ;
		}
	}
	
	printf("cannot find the encording of %c\n",ch);
	return 0 ;
}

//text
void SequentialTest()
{
	int paraLength = 5 ;
	char paraCharacter[paraLength] ;
	int paraData[] = {52,8,15,23,2} ; //数据初始化 
	
	int i = 0 ;
	for(i=0;i<paraLength;i++)
	{
		paraCharacter[i] = 'a' + i ;
	}
	
	printf("---- SequentialTest begins. ---- \n") ;
	SequentialListPtr tempList = SequentialListInit(paraCharacter,paraData,paraLength);
	SequentialListPrintf(tempList,paraLength) ;
	
	printf("---- after Binarytree . ---- \n") ;
	paraLength = Binarytree(tempList,paraLength) ;
	SequentialListPrintf(tempList,paraLength) ;
	
	printf("---- after find encoding . ---- \n") ;
	findencording(tempList,'a',paraLength );
	findencording(tempList,'b',paraLength );
	findencording(tempList,'c',paraLength );
	findencording(tempList,'d',paraLength );
	findencording(tempList,'e',paraLength );
	
	free(tempList) ;
}

int main ()
{
	SequentialTest() ;
	return 0 ;
}

结果

    思路图~~