用最小堆实现哈夫曼树

HuffmanTree.h文件

#ifndef HUFFMANTREE
#include<stdlib.h>
#include<stdio.h>

#define MaxCapacity 1000
#define MAXDATA 0xFFFF

typedef struct HuffmanNode
{
	int weight;
	struct HuffmanNode* lchild;
	struct HuffmanNode* rchild;
}HuffmanTree;

typedef struct HEAP {
	HuffmanTree* *data; //HuffmanTree** 创建一个存放地址数组
	int size;     //当前堆的大小
	int capacity; //容量
}Heap;

typedef Heap MinHeap;

MinHeap*      CreatMinHeap(int MaxSize);
bool          HeapInsert(MinHeap*& h, HuffmanTree* item);
bool          IsFull(MinHeap* H);
bool          IsEmpty(MinHeap* H);
HuffmanTree*  HeapDelete(MinHeap*& h);
void          BuildMinHeap(MinHeap*& h);


HuffmanTree*  CreatHuffmanTree(MinHeap*& h);
HuffmanTree*  NewHuffmanNode();

void PreOrderTraversal(HuffmanTree* BST);

#endif // !HUFFMANTREE
#pragma once

HuffmanTree.cpp文件

#include "HuffmanTree.h"


/****************************************
*
*初始化一个最小堆
*
*****************************************/

MinHeap* CreatMinHeap(int MaxSize)
{
	MinHeap* h;
	HuffmanTree* T;
	h = (MinHeap*)malloc(sizeof(MinHeap));
	if (!h)
	{
		printf("最小堆初始化失败");
		return NULL;
	}
	h->data = (HuffmanTree**)malloc(sizeof(HuffmanTree*) * (MaxCapacity + 1));
	if (!h->data)
	{
		printf("最小堆data初始化失败");
		return NULL;
	}
	h->capacity = MaxCapacity;
	h->size = 0;
	T = NewHuffmanNode();
	h->data[0] = T;
	return h;
}

/****************************************
*
*创建一个哈夫曼节点
*
*****************************************/
HuffmanTree* NewHuffmanNode()
{
	HuffmanTree* BST;
	BST = (HuffmanTree*)malloc(sizeof(HuffmanTree));
	if (!BST)
	{
		exit(-1);
	}
	BST->weight = 0;
	BST->lchild = BST->rchild = NULL;
	return BST;
}

/****************************************
*
*判断堆满
*
*****************************************/
bool  IsFull(MinHeap* H)
{
	return (H->size == H->capacity);
}

/****************************************
*
*判断堆空
*
*****************************************/
bool IsEmpty(MinHeap* H)
{
	return (H->size == 0);
}

/****************************************
*
*堆的插入操作
*
*****************************************/
bool HeapInsert(MinHeap*& h, HuffmanTree* item)
{
	int i;
	if (IsFull(h))
	{
		printf("堆已满");
		return false;
	}

	h->size++;

	for (i = h->size; h->data[i / 2]->weight > item->weight; i /= 2)
	{
		h->data[i] = h->data[i / 2];
	}

	h->data[i] = item;
	return true;
}

/****************************************
*
*堆的删除操作
*
*****************************************/
HuffmanTree* HeapDelete(MinHeap*& h)
{
	int parent, child;
	HuffmanTree* Minitem, * temp;
	if (IsEmpty(h))
	{
		printf("堆空");
		return NULL;
	}
	Minitem = h->data[1];
	temp = h->data[h->size--];//先赋值，再自减

	for (parent = 1; parent * 2 <= h->size; parent = child)
	{
		child = parent * 2;
		//找孩子中权重最小的
		if ((child + 1 <= h->size) && h->data[child]->weight > h->data[child + 1]->weight)
		{
			child++;
		}

		if (temp->weight > h->data[child]->weight)
		{
			h->data[parent] = h->data[child];
		}
		else
		{
			break; //比节点的孩子都小，则插入该节点
		}
	}
	h->data[parent] = temp;

	return Minitem;
}

/****************************************
*
*创构建一个最小堆
*
*****************************************/
void  BuildMinHeap(MinHeap*& h)
{
	int i;
	int child, parent;
	HuffmanTree* temp;

	for (i = h->size / 2; i > 0; i--)
	{
		temp = h->data[i];

		for (parent = i; parent * 2 < h->size; parent = child)
		{
			child = parent * 2;
			if ((child + 1 <= h->size) && h->data[child]->weight > h->data[child + 1]->weight)
			{
				child++;
			}
			if (temp->weight > h->data[child]->weight)
			{
				h->data[parent] = h->data[child];
			}
			else
			{
				break;
			}
		}
		h->data[parent] = temp;
	}
}

/****************************************
*
*用最小堆的办法构建一个哈夫曼树
*
*****************************************/
HuffmanTree* CreatHuffmanTree(MinHeap*& h)
{
	int i, num;
	HuffmanTree* T;
	T = (HuffmanTree*)malloc(sizeof(HuffmanTree));
	if (!T)
	{
		printf("哈夫曼树初始化失败");
		return NULL;
	}
	BuildMinHeap(h);
	num = h->size - 1;

	for (i = 0; i < num; i++)
	{
		T = NewHuffmanNode();
		T->lchild = HeapDelete(h);
		T->rchild = HeapDelete(h);
		T->weight = T->lchild->weight + T->rchild->weight;
		HeapInsert(h, T);
	}

	return T;

}

/****************************************
*
*先序遍历
*
*****************************************/
void PreOrderTraversal(HuffmanTree* BST)
{
	if (BST) {
		printf("%d ", BST->weight);     //先访问根节点 
		PreOrderTraversal(BST->lchild);  //再访问左子树 
		PreOrderTraversal(BST->rchild); //最后访问右子树 
	}
}

main.cpp

#include<stdio.h>
#include<stdlib.h>
#include "HuffmanTree.h"


void main()
{
	int i, n;
	MinHeap* h;
	HuffmanTree* T, *BT = NULL;

	printf("输入叶子结点个数:  \n");
	scanf_s("%d", &n);
	h = CreatMinHeap(2 * n);  //总节点 = 叶节点 - 1 ；0位置弃用
	printf("请输入%d个叶子结点对应的权值:\n", n);

	for (i = 1; i <= n; i++) 
	{/*最小堆元素赋值*/
		T = NewHuffmanNode();
		scanf_s("%d", &(T->weight));
		h->data[++(h->size)] = T;//先自加再赋值
	}

	BT = CreatHuffmanTree(h);  //构造哈夫曼树 
	printf("先序遍历此哈夫曼树的权值:\n");
	PreOrderTraversal(BT);  //先序遍历此哈夫曼树 
}