堆（数据结构）的基本操作

堆（数据结构）的基本操作

typedef int HeapDateType;

typedef struct Heap
{
	HeapDateType* _a;
	size_t _size;
	size_t _capacity;//容量
}Heap;

初始化堆

void HeapInit(Heap* hp, HeapDateType* a, size_t n)
{
	hp->_a = (HeapDateType*)malloc(sizeof(HeapDateType)*n);
	int i = 0;
	for (;i < n;i++)
	{
		hp->_a[i] = *a;
		a++;
	}
	hp->_size = n;
}

容量扩充

void HeapDilatation(Heap* hp)
{
	if (hp->_size == hp->_capacity)
	{
		(Heap*)realloc(hp,hp->_capacity*sizeof(Heap));
	}
}

给一个交换两个数的函数，方便后面的向上向下调整算法。

void Swap( HeapDateType* a, HeapDateType* b)
{
	HeapDateType c=0;
	c = *b;
	*b = *a;
	*a = c;
}

大堆向下调整，先让parents指向父亲节点，child指向左孩子节点，判断如果有右孩子节点并且右孩子节点大于左孩子节点，那么让child++指向右孩子节点。接下来判断父亲节点是否小于孩子节点，如果小于的话交换父亲节点与孩子节点。这样可以保证在父亲节点一定大于孩子节点。再将孩子节点给到父亲节点，在进行以上操作直到叶子节点为止。

void HeapBigAdjustDown(Heap* hp,size_t x)
{//大堆向下调整
	int parents = x;
	int child = parents * 2 + 1;
	while (child < hp->_size)
	{
		if (child+1 < hp->_size && (hp->_a[child] < hp->_a[child + 1]))
		{
			++child;
		}
		if (hp->_a[parents] < hp->_a[child])
		{
			Swap(&(hp->_a[parents]),&(hp->_a[child]));
			parents = child;
			child = parents * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

小堆向下调整，将选定的节点所存的数据一直向下调整，原理同上。

void HeapSmallAdjustDown(Heap* hp, size_t x)
{//小堆向下调整
	int parents = x;
	int child = parents * 2 + 1;
	while (child < hp->_size)
	{
		if (child+1 < hp->_size && (hp->_a[child] > hp->_a[child + 1]))
		{
			++child;
		}
		if (hp->_a[parents] > hp->_a[child])
		{
			Swap(&(hp->_a[parents]), &(hp->_a[child]));
			parents = child;
			child = parents * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

小堆向上调整。给定child参数，用child参数得到parents数据。判断如果child大于parents的话将两个数据交换。并且将parents的数据给child，直到调整到根节点或者child小于parents结束。以下为实现代码。

void HeapSmallAdjustUp(Heap* hp, int child)
{//小堆向上调整
	int parents = (child - 1) / 2;
	while (child != 0)
	{
		if (hp->_a[child] < hp->_a[parents])
		{
			Swap(&(hp->_a[child]), &(hp->_a[parents]));
			child = parents;
			parents = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

大堆向上调整，算法原理同上。

void HeapBigAdjustUp(Heap* hp, int child)
{//大堆向上调整
	int parents = (child - 1) / 2;
	while (child != 0)
	{
		if (hp->_a[child] > hp->_a[parents])
		{
			Swap(&(hp->_a[child]), &(hp->_a[parents]));
			child = parents;
			parents = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

建一个大堆。从最后一个非叶子节点开始向下调整到根节点即可。调整最后一个非叶子节点保证从最后开始每一次的左子树与右子树都是大堆，一直调到根节点的时候，根节点左子树与右子树都是大堆，只需要调整根节点即可。

void MakeBigHeap(Heap* hp)
{
	int i = (hp->_size-2)/2;
	for (;i >= 0;i--)
	{
		HeapBigAdjustDown(hp,i);
	}
}

建一个小堆。原理同上。

void MakeSmallHeap(Heap* hp)
{
	int i = (hp->_size - 2) / 2;
	for (;i >= 0;i--)
	{
		HeapSmallAdjustDown(hp, i);
	}
}

插入一个数据，在尾巴插入一个数据，将这个数据进行向上调整即可。

void HeapPush(Heap* hp, HeapDateType x)
{
	hp->_a[hp->_size] = x;
	HeapSmallAdjustUp(hp,hp->_size);
	hp->_size += 1;
}

删除一个数据。将堆顶数据与最后一个数据交换，将size--并且将交换后的根节点向下调整即可。

void HeapPop(Heap* hp)
{
	Swap(&hp->_a[0], &hp->_a[hp->_size - 1]);
	hp->_size--;
	HeapSmallAdjustDown(hp, 0);
}

堆内存储的数据个数。直接返回size即可。

size_t HeapSize(Heap* hp)
 {
	return hp->_size;
}

堆判空，如果size等于0的话那么为空堆返回0，反之返回1

size_t HeapEmpty(Heap* hp)
{
	if (hp->_size == 0)
	{
		return 0;
	}
	else
	{
		return 1;
	}
}

取堆顶元素

HeapDateType HeapTop(Heap* hp)
{
	return hp->_a[0];
}

void HeapSort(Heap* hp,size_t n)
{//降序
	while (hp->_size)
	{
		Swap(&(hp->_a[0]),&(hp->_a[hp->_size-1]));
		hp->_size-=1;
		HeapSmallAdjustDown(hp,0);
	}
	hp->_size = n;
}

打印堆

void HeapPrint(Heap* hp)
{
	Heap* ptr = hp;
	int i = 0;
	for (;i < hp->_size;i++)
	{
		printf("%d  ",hp->_a[i]);
	}
}