最小堆

实现最小堆的创建,插入,删除(有时候得好好测试函数写的对不对,我之前只看返回值,然而中间错了).准备开始写哈夫曼树

#define  _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
typedef int ElementType;
typedef int ElementType2;
typedef struct HNode* Heap;
#define MaxSize 10000
#define MinSize 0
struct Haffman_Node_ {
	ElementType2 wieght;
	struct Haffman_Node_* left;
	struct Haffman_Node_* right;
}HaffmanNode;
typedef struct Haffman_Node_* HaffmanTree;

struct HNode {
	ElementType *Data;
	int Capacity;
	int Size;//当前大小
};

typedef Heap MaxHeap;
typedef Heap MinHeap;
MaxHeap CreateHeap(int n);
void Get_Num(MaxHeap a, int n);
void Arrange_MaxHeap(MaxHeap a);
void Arrange_MinHeap(MinHeap a);//创建最小堆
ElementType Delete_MinHeap(MinHeap a);
int IsEmpty(Heap a);
int main()
{
	int n;//生成堆的大小
	MaxHeap a = CreateHeap(50);
	scanf("%d", &n);
	Get_Num(a,n);
	Arrange_MinHeap(a);
	for (int i = 1; i <= a->Size; i++)
	{
		printf("%d\n", a->Data[i]);
	}
	Delete_MinHeap(a);
	for (int i = 1; i <= a->Size; i++)
	{
		printf("%d\n", a->Data[i]);
	}


}
Heap CreateHeap(int n)//创建一个最大承载n个节点的堆
{
	Heap a=(Heap)malloc(sizeof(struct HNode));
	a->Data = (ElementType*)malloc((n+1)*sizeof(int));
	a->Capacity = n;
	a->Size = 0;
	a->Data[0] =MinSize;
	return a;
}
void Get_Num(MaxHeap a,int n)//对堆进行初始化
{
	for (int i = 1; i <= n; i++)
	{
		scanf("%d", (a->Data) + i);
	}
	a->Size = n;
}
/**/
void Arrange_MaxHeap(MaxHeap a)//创建最大堆
{
	int Child, Parent;
	ElementType t;
	for (int i = a->Size/ 2;i>=1; i--)
	{
		t = a->Data[i];
		for (Parent = i; Parent * 2 <= a->Size; Parent = Child)//如果有子节点
		{	
			 Child = Parent * 2;
			 if (((Child + 1) <= a->Size) && a->Data[Child] < a->Data[Child + 1])//找出最大的子节点
				 Child = Child + 1;
			 if (t > a->Data[Child])//如果父节点值大于所有子节点
				 break;
			 else
			 {
				 a->Data[Parent] = a->Data[Child];//子节点上移
			 }


				 
		}
		a->Data[Parent] = t;
	}
}
void Arrange_MinHeap(MinHeap a)/*创建最小堆在测试过程中我发现了我的思维误区:Parent
							   节点下移后应该和子节点判断是否是最小的,此函数就是从最后一个子节点的父节点处开始
							   子节点有比它小的就把这个父节点拽下来*/
{
	int Parent, Child;
	ElementType t;
	for (int i = a->Size/2; i > 0; i--)
	{
		t = a->Data[i];
		for (Parent = i; Parent * 2 <= a->Size; Parent = Child)
		{
			Child = 2 * Parent;
			if (Child + 1 <= a->Size && a->Data[Child + 1] < a->Data[Child])
				Child = Child + 1;
			if (a->Data[Child] > t)
				break;
			else
				a->Data[Parent] = a->Data[Child];
				
		}
		a->Data[Parent] = t;
	}
} 
ElementType Delete_MinHeap(MinHeap a)
{
	if (!IsEmpty(a))
	{
		int Parent, Child;
		ElementType t, MinElement;
		MinElement = a->Data[1];
		a->Data[1] = a->Data[a->Size];
		a->Size -= 1;
		t = a->Data[1];

		for (Parent = 1; Parent * 2 <= a->Size; Parent = Child)
		{
			Child = 2 * Parent;
			if (Child + 1 <= a->Size && a->Data[Child] >= a->Data[Child + 1])
				Child++;
			if (t < a->Data[Child])
				break;
			else
				a->Data[Parent] = a->Data[Child];

		}
		a->Data[Parent] = t;
		return MinElement;//返回被删除的值
	}
	else
		return -1;//返回一个不可能的值
}
int Insert_MinHeap(MinHeap a,ElementType k)/*如果父节点比它大,父节点下移*/
{
	int  Child;
	if (a->Size == a->Capacity)
		return 0;
	else
		Child = ++a->Size;
	for (; a->Data[Child/2]>k; Child = Child / 2)//这样就不需要额外声名parent
	{
		
			a->Data[Child] = a->Data[Child/2];
	}
	a->Data[Child] = k;
	return 1;

}
int IsEmpty(Heap a)
{
	if (a->Size == 0)
		return 1;
	else
		return 0;
}