用最小堆生成哈夫曼树C++

#include<iostream>
#include<queue>
using namespace std;
#define MaxNumHeap 101

//哈夫曼树
typedef char HTElemType;
typedef struct HTreeNode* PtrToHTNode;
typedef struct HTreeNode {
	HTElemType Data;
	int a;
	PtrToHTNode Left, Right;
};
typedef PtrToHTNode HuffmanTree;

//以哈夫曼树结点指针为元素的最小堆
typedef PtrToHTNode HElemType;
typedef struct HeapNode {
	HElemType data[MaxNumHeap+1];
	int size,capacity;
}*MinHeap,*MaxHeap;

MinHeap CreatMinHeap(int N)
{
	MinHeap H = (MinHeap)malloc(sizeof(HeapNode));
	H->data[0]= (PtrToHTNode)malloc(sizeof(HTreeNode));
	H->data[0]->a = -1;
	H->size = 0;
	H->capacity = N;
	return H;
}
bool InsertMinHeap(MinHeap H, HElemType E)
{
	if (H->size >= H->capacity)
	{
		cout << "堆已满" << endl;
		return false;
	}
	int i = ++H->size;
	while (H->data[i / 2]->a > E->a)
	{
		H->data[i] = H->data[i / 2];
		i /= 2;
	}
	H->data[i] = E;
	return true;
}
bool DeleteMinHeap(MinHeap H, HElemType& E)   //删除头结点最小值，并把头结点的最小值传递给E  地址传递
{
	if (H->size == 0)
	{
		cout << "堆已空" << endl;
		return false;
	}
	E = H->data[1];
	HElemType t = H->data[H->size--];
	int Parent=1, Child;
	while (Parent * 2 <= H->size)
	{
		Child = Parent*2;
		if (Child + 1 <= H->size && H->data[Child]->a > H->data[Child + 1]->a)  Child++;
		if (H->data[Child]->a >= t->a)  break;
		H->data[Parent] = H->data[Child];
		Parent = Child;
	}
	H->data[Parent] = t;
}
void ReadData(MinHeap H,int N)
{
	int i;
	for (i = 0; i < N; i++)
	{
		HElemType a= (PtrToHTNode)malloc(sizeof(HTreeNode));
		a->Left = a->Right = NULL;
		cin >> a->Data>>a->a;
		InsertMinHeap(H, a);
	}
}
void PrintHeap(MinHeap H)
{
	int i;
	for (i = 1; i <= H->size; i++)
	{
		cout << H->data[i] << "  " << H->data[i]->Data << "  " << H->data[i]->a << "  "
			<< H->data[i]->Left << "  " << H->data[i]->Right << endl;
	}
	cout << "-------***********--------" << endl;
}

//建立一个哈夫曼树
HuffmanTree Huffman(MinHeap H)
{
	if (H->size == 0)
	{
		cout << "空堆" << endl;
		return NULL;
	}
	HuffmanTree First,Second, NewNode=NULL;
	HuffmanTree T=NULL;
	int n = H->size;
	for (int i = 0; i < n-1; i++)
	{
		NewNode = (PtrToHTNode)malloc(sizeof(HTreeNode));
		DeleteMinHeap(H, First);
		DeleteMinHeap(H, Second);
		PrintHeap(H);
		NewNode->Left = First;
		NewNode->Right = Second;
		NewNode->a = First->a + Second->a;
		NewNode->Data = '#';
		InsertMinHeap(H, NewNode);
		PrintHeap(H);
		T = NewNode;
	}
	return T;
}

//后序遍历
void PostOrderTraversal(HuffmanTree BT)
{
	if (BT)
	{
		PostOrderTraversal(BT->Left);
		PostOrderTraversal(BT->Right);
		cout << BT->Data << "  ";
	}
	
}

//层序遍历
void LevelOredrTraversal(HuffmanTree BT)
{
	queue<HuffmanTree> Q;
	Q.push(BT);
	while (!Q.empty())
	{
		BT = Q.front();
		Q.pop();
		if (BT->Left)
			Q.push(BT->Left);
		if (BT->Right)
			Q.push(BT->Right);
		cout << BT->Data << "  ";
	}
}

int main()
{
	MinHeap H = CreatMinHeap(7  );
	ReadData(H,7);
	PrintHeap(H);
	HuffmanTree T = Huffman(H);
	PostOrderTraversal(T);
	cout << endl;
	cout << "-------***********--------" << endl;
	LevelOredrTraversal(T);
	return 0;
}