堆的基本操作详解

堆的性质

1，堆中某节点的值总是不大于或不小于其父节点的值。

2，堆是一颗完全二叉树。

1，堆分为两种，大根堆和小根堆。

 

2，我们用数组来存储堆，所以我们想象出来的是一颗完全二叉树，实际上操纵的是数组。如图：

3，现在我们来实现堆的基本操作。

（1）首先，我们来创建一个结构体来表示堆。

typedef struct Heap
{
	HPDataType* _a;//使用动态的数组，方便扩容。
	int _size;//堆的有效数字的个数
	int _capacity;//堆的容量
}Heap;

 （2）写出堆基本操作的声明。

void HeapCreate(Heap* hp);// 堆的构建
void HeapDestory(Heap* hp);//堆的销毁
void HeapPush(Heap* hp, HPDataType x);//堆的插入
void AdjustUp(HPDataType* a,int child);//向上调整
void AdjustDown(HPDataType* a, int size,int parent);//向下调整
void HeapPrintf(Heap* hp);//打印堆
void swap(HPDataType* x, HPDataType* y);//两数交换
void HeapPop(Heap* hp);//堆的删除
HPDataType HeapTop(Heap* hp);//获取堆顶的数据
int HeapSize(Heap* hp);//堆的个数
int HeapEmpty(Heap* hp);//堆的判空

（3）实现上述操作。

1，堆的创建和销毁。 

void HeapCreate(Heap* hp)//创建
{
	assert(hp);
	hp->_a=NULL;
	hp->_size=hp->_capacity= 0;
}
void HeapDestory(Heap* hp)//销毁
{
	assert(hp);
	assert(hp->_a);
	free(hp->_a);
	hp->_capacity = hp->_size = 0;
}

2，堆的插入。

    因为是数组，插入数据可以在任意位置插入，但是在前面插入数据，需要挪动数据，为了降低复杂度，我们决定尾插。

   

 

void HeapPush(Heap* hp, HPDataType x)
{
	assert(hp);
	if (hp->_size == hp->_capacity)//如果满了就需要扩容。
	{
		int newcapacity = hp->_capacity == 0 ? 4 : 2 * hp->_capacity;
		HPDataType* temp = (HPDataType*)realloc(hp->_a, sizeof(HPDataType) * newcapacity);
		if (temp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}
			hp->_a = temp;
		hp->_capacity = newcapacity;
	}

	hp->_a[hp->_size] = x;//尾插
	hp->_size++;
	AdjustUp(hp->_a,hp->_size-1);

}

void swap(HPDataType *x, HPDataType *y)
{
	HPDataType temp = *x;
	*x = *y;
	*y = temp;
}

void AdjustUp(HPDataType *a,int child)//向上调整
{
	int parent = (child - 1) / 2; 
	while (child > 0)
	{
		if (a[child] > a[parent])  //这里是大根堆，如果要写小根堆就是<
		{
			swap(&a[child], &a[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else {
			break;
		}
	}
}

3，堆的删除 ，堆的删除删除的是堆顶的元素，删除其他位置没有意义。

我们需要采用向下调整算法。

 

// 堆的删除
void HeapPop(Heap* hp)
{
	assert(hp);
	assert(hp->_size > 0);
	swap(&hp->_a[0], &hp->_a[hp->_size - 1]);//先将堆顶和最后一个元素交换。
	hp->_size--;  //删除
	AdjustDown(hp->_a,hp->_size,0);
}




void AdjustDown(HPDataType* a, int size, int parent)//向下调整
{
	int child = parent * 2 + 1;//只定义一个左孩子，右孩子就为左孩子+1。
	while (child < size)//调整到叶子节点就停止，孩子节点的下标不能超出数组。
	{   
		if (child + 1 < size && a[child+1] > a[child])//在确保右孩子存在的情况下，选出大的。
		{
			child++;
		}
		if (a[child] > a[parent])//将大的和父亲节点比较，如果父亲小，就交换
		{
			swap(&a[child], &a[parent]);
			parent = child;
			child = 2 * parent + 1;//迭代，继续向下调整。
		}
		else
		{
			break;
		}
	}
}

堆的其他操作。 

HPDataType HeapTop(Heap* hp)
{
	assert(hp);
	assert(hp->_size>0);
	return hp->_a[0];
}
// 堆的数据个数
int HeapSize(Heap* hp)
{
	assert(hp);
	return hp->_size;
}
// 堆的判空
int HeapEmpty(Heap* hp)
{
	assert(hp);
	return hp->_size == 0;
}

堆有一个重要的应用，堆排序。 以升序为例。

 如何实现堆排序，第一步，建堆。我们可以用向上调整，向下调整的思路建堆。

向下调整建堆只需要从倒数第一个非叶子节点开始调整，向下调整的前提是左右子树必须是堆。

注意：升序需要建大堆，如果用小堆，那么第一次选出最小的数，后面的关系就乱了，就要将后面所有的数重新建堆,代价太大。如果建大堆，如图

void HeapSort(int* a, int n)
{

//for(int i=1;i<n;i++)向上调整建堆
//{AdjustUp(a,i);
//}


                            O(N)
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)//优先使用向下调整建堆
	{
		AdjustDown(a, n, i);
	}
	int end = n - 1;
	while (end>0)
	{
		swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);   o(NlogN)
		end--;
	}
}

现在我们分析一下堆排序的时间复杂度。 

向下调整建堆

​​​​​​​

   向上调整建堆。

 所以堆排序的时间复杂度为NlogN