算法导论 哈夫曼编码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define N 6
typedef struct Huff
{
	int freq;
	Huff *left;
	Huff *right;
	char c;
}HuffNode,*pHuff;

typedef struct 
{
	int len;
	pHuff *arr;
}MinHeap;

void swop(pHuff *a,pHuff *b)
{
	pHuff temp=*a;
	*a=*b;
	*b=temp;
}

void minHeapify(pHuff *a,int len,int i)
{
	int l=i*2,r=i*2+1,min=a[i]->freq,p=i;
	if(l<len && a[l]->freq<a[i]->freq)
	{
		min=a[l]->freq;
		p=l;
	}
	if(r<len && a[r]->freq<min)
	{
		min=a[r]->freq;
		p=r;
	}
	if(p!=i)
	{
		swop(&a[i],&a[p]);
		minHeapify(a,len,p);
	}
}

MinHeap* buildHeap(int *a,int len,char *cs)
{
	MinHeap *m=(MinHeap *)malloc(sizeof(MinHeap));
	m->arr=(pHuff*)malloc(len*sizeof(pHuff));
	m->len=len;
	for(int i=0;i<len;i++)
	{
		m->arr[i]=(pHuff)malloc(sizeof(Huff));
		m->arr[i]->freq=a[i];
		m->arr[i]->c=cs[i];
		m->arr[i]->left=m->arr[i]->right=NULL;
	}
	for(int i=(len+1)/2;i>=0;i--)
	{
		minHeapify(m->arr,m->len,i);
	}
	return m;
}

void printHeap(MinHeap *heap)
{
	for(int i=0;i<heap->len;i++)
	{
		printf("%d ",heap->arr[i]->freq);
	}
	printf("\n");
}

pHuff extractMin(MinHeap *heap)
{
	pHuff x=heap->arr[0];
	swop(&heap->arr[0],&heap->arr[heap->len-1]);
	heap->len--;
	minHeapify(heap->arr,heap->len,0);
	return x;
}

void insert(MinHeap *heap,pHuff h)
{
	heap->arr[heap->len++]=h;
	int i=heap->len-1;
	int x=i/2;
	while(x>0)
	{
		if(heap->arr[i]->freq<heap->arr[x]->freq)
		{
			swop(&heap->arr[i],&heap->arr[x]);
			i=x;
			x=x/2;
		}
		else
			break;
	}
	if(x==0 && heap->arr[i]->freq<heap->arr[x]->freq)
	{
		swop(&heap->arr[i],&heap->arr[x]);
	}
}

pHuff makeNode(int freq,pHuff l,pHuff r)
{
	pHuff ph=(pHuff)malloc(sizeof(Huff));
	ph->freq=freq;
	ph->left=l;
	ph->right=r;
	ph->c='*';
	return ph;
}

pHuff huffman(int *a,int len,char*cs)
{
	MinHeap*m=buildHeap(a,len,cs);
	//printHeap(m);
	for(int i=1;i<len;i++)
	{
		pHuff x=extractMin(m);
		pHuff y=extractMin(m);
		pHuff z=makeNode(x->freq+y->freq,x,y);
		insert(m,z);
	}
	return m->arr[0];
}

void getCode(pHuff ph,char *s,char c,int i)
{
	if(ph==NULL)
		return;
	if(c==ph->c)
	{
		s[i]='\0';
		printf("%s",s);
		return;
	}
	s[i]='0';
	getCode(ph->left,s,c,i+1);
	s[i]='1';
	getCode(ph->right,s,c,i+1);
}

void printHuff(pHuff ph)
{
	if(ph==NULL)
		return;
	printf("%c ",ph->c);
	printHuff(ph->left);
	printHuff(ph->right);
}

void  main()
{
	int a[N]={45,13,12,16,9,5};
	char cs[N]={'a','b','c','d','e','f'};
	pHuff ph=huffman(a,N,cs);
	char*s=(char*)malloc((N+1)*sizeof(char));
	//printHuff(ph);
	getCode(ph,s,'e',0);
	getchar();
}