C语言实现，huffman算法，将输入的十个整数，按数字大小组成一个huffman树，并输出编码方式

#include <stdio.h>
#include <malloc.h>
#include <string.h>
/*节点又三个指针组成，f作为链表指向下一个节点或在树中指向父节点，l、r分别指向节点的左右孩子节点*/
typedef struct node {
	int value;
	struct node* f;
	struct node* l;
	struct node* r;
}NODE, *NODEP;
NODEP root;
/*存放huffman编码*/
char a[10] = "";
/*新申请节点初始化*/
void init_node(NODEP p)
{
	p->f = NULL;
	p->l = NULL;
	p->r = NULL;
}
/*初始化链表，十个节点*/
NODEP init()
{
	NODEP p, q, r;
	int i, j;

	r = (NODEP)malloc(sizeof(NODE));
	init_node(r);
	p = r;
	printf("Enter the 10 nums:\n");
	for(i = 0;i < 10;i++) {
		scanf("%d", &j);
		q = (NODEP)malloc(sizeof(NODE));
		init_node(q);
		q->value = j;
		p->f = q;
		p = q;
	}
	return r; 
		
}
/*顺序输出链表节点*/
void print(NODEP head)
{
	NODEP p;
	
	p = head;
	if (head == NULL )
		return;

	printf("%d", p->value);
	putchar('(');
	print(p->l);
	printf(",");
	print(p->r);
	putchar(')');
}
/*获得链表中，最小节点，并将节点从链表中拿下来，作为函数的返回值*/
NODEP get_least(NODEP head)
{
	NODEP p, p_f, q, q_f;
	
	p_f = head;
	p = p_f->f;
	
	q_f = p_f;
	q = p;
 	
	while(q != NULL) {
		if (q->value < p->value) {
			p_f = q_f;
			p = q;
		} 
		q_f = q;
		q = q->f;
		
	}
	p_f->f = p->f;
	return p;

}
/*将两个最小的节点数值的和，创建一个新节点，加入链表中*/
void insert(NODEP head, NODEP p1, NODEP p2)
{
	NODEP new;
	
	new = (NODEP)malloc(sizeof(NODE));
	new->value = p1->value + p2->value;
	new->l = p1;
	p1->f = new;
	new->r = p2;
	p2->f = new;
	
	new->f = head->f;
	head->f = new;	
}
/*实现huffman算法*/
void haffuman(NODEP head)
{
	NODEP p, q, r;
	
	p = head->f;
	
	while( p->f != NULL) {
		q = get_least(head);
		r = get_least(head);
		insert(head, q, r);
		p = head->f;
	}
}
void p1(NODEP h)
{

	while(h != NULL) {
		printf("%-5d", h->value);
		h = h->f;
	}
	putchar('\n');
	return;
}
/*输出huffman编码，递归*/
void p2(int p,NODEP h)
{
	if ((h->l == NULL)&&(h->r == NULL)) {
		printf("\n%d:", h->value);
		a[p] = '\0';
		printf("%s", a);
		return;
	}
	if (h->l != NULL) {
		a[p] = '0';
		p2(p+1, h->l);
	}
	if (h->r != NULL) {
		a[p] = '1';
		p2(p+1,h->r);
	}	
} 
int main(int argc, char* argv[])
{
	NODEP head;
	
	head = init();
	//p1(head->f);

	haffuman(head);
	//print(head->f);
	p2(0, head->f);
	return 1;
}

输入：1 2 3 4 5 6 7 8 9 10

输出：

10:00

1:01000

2:01001

3:0101

6:011

7:100

8:101

4:1100

5:1101

输入： 3 2 6 7 23 5 3 45 8 1

输出：

45:0

23:10

7:1100

3:11010

5:11011

8:1110

1:1111000

2:1111001

3:111101

6:11111