数据结构-----二叉堆的实现(含堆排序讲解)

前言
我们要想实现一个堆出来,那么我们得先知道父亲和孩子之间的关系!
father=(child-1)/2;
左child=father * 2+1;
右child=father * 2+2;
我们还得知道堆的结构,堆分为小堆和大堆,小堆就是在这个完全二叉树中,父亲一定比孩子小,大堆就是父亲一定比孩子大!

举一个小堆的例子:

堆的创建

typedef int HPDataType;
typedef struct Heap
{
	HPDataType* data;
	int size;
	int capacity;
}HP;

堆的初始化

void HeapInit(HP* php)
{
	assert(php);
	php->capacity = 0;
	php->size = 0;
	php->data = NULL;
}

堆的销毁

void HeapDestroy(HP* php)
{
	assert(php);
	free(php->data);
	php->capacity = 0;
	php->size = 0;
	php->data = NULL;
}

获取堆顶数据

HPDataType HeapTop(HP* php) 
{
	assert(php);
	assert(!HeapEmpty(php));
	return php->data[0];
}

判空

bool HeapEmpty(HP* php)
{
	assert(php);
	return php->size == 0;
}

获取堆中元素个数

int HeapSize(HP* php)
{
	return php->size;
}

这些都是简单的,我们重点讲解一下堆的 插入和删除!

堆的插入

我们插入一个元素肯定是在数组的最后,那么我们怎样将他移到堆中合适的位置呢?
我们看一组图:

这我们称为向上调整!
那具体代码怎么实现呢?

void ADjustUp(HPDataType* data, HPDataType child)
{
	HPDataType father = (child-1) / 2;
	while (child > 0)
	{
		//if (data[child] > data[father])//大堆
		if (data[child] > data[father])//小堆
		{
			Swap(&data[child], &data[father]);
			child = father;
			father = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

其中也包含Swap交换函数:

void Swap(HPDataType* p1, HPDataType* p2)
{
	HPDataType tmp;
	tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

所以堆的插入整体代码为:

void HeapPush(HP* php, HPDataType x)
{
	assert(php);
	if (php->capacity == php->size)
	{
		int newcapacity = php->capacity == 0 ? 4 : php->capacity * 2;
		HPDataType* tmp = realloc(php->data, sizeof(HPDataType) * newcapacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}
		php->data = tmp;
	}
	php->data[php->size++] = x;
	ADjustUp(php->data,php->size-1);
}

堆的删除

堆的删除操作是,将堆顶元素和堆尾元素交换,然后通过向下调整,将堆完善好!
看向下调整的图:

那具体我们对怎么写呢? 其实就是父亲和孩子比较,小堆就和较小的孩子比,大堆就和较大的孩子比,小堆父亲比孩子大就交换,大堆父亲比孩子小就交换,然后在向下进行操作,这个就得将孩子变成父亲才可!
看代码:

void ADjustDown(HPDataType* data, HPDataType father,int size)
{
	//法一:迭代
	//HPDataType child = father * 2 + 1;
	// //if ((data[child] < data[child + 1])&&(child+1<size))//找到孩子较大的一个
	//if ((data[child] > data[child + 1]) && (child + 1 < size))//小堆,找到孩子较小的一个

	//{
	//	child++;
	//}
	//while (child<size) 
	//{
	//	if (data[father] < data[child])//大堆
	//	//if (data[father] > data[child])//小堆
	// 
	//	{
	//		Swap(&data[father], &data[child]);
	//		father = child;//孩子变父亲,向下迭代
	//		child = father * 2 + 1;
	//	}
	//	else
	//	{
	//		break;
	//	}
	//}
	//法二:递归
	HPDataType child = father * 2 + 1;
	if (child >= size)return;
	else
	{
		//if ((data[child] < data[child + 1]) && (child + 1 < size))//大堆,找到孩子较大的一个
		if ((data[child] > data[child + 1]) && (child + 1 < size))//小堆,找到孩子较小的一个

		{
		child++;
		}
		//if (data[father] < data[child])//大堆
		if (data[father] > data[child])//小堆
		{
		Swap(&data[father], &data[child]);
		}
		ADjustDown(data,child,size);
	}
}	

上面的方法最好用迭代,递归会占用空间!
看删除的整体代码:

void HeapPop(HP* php)
{
	assert(php);
	assert(!HeapEmpty(php));
	Swap(&php->data[0], &php->data[php->size-1]);
	php->size--;
	ADjustDown(php->data,0,php->size);
}

堆的应用–堆排序

我们先思考一下,怎么实现一个堆排序呢?
我们是不是先将数组变成一个堆,然后取出堆顶元素赋值到数组中,再删除堆顶元素?
这样虽然可行,但是你得先写一个堆的数据结构出来吧,而且还要额外空间的占用,显然没有啥优势了!
那我们怎么改呢??
我们可以通过原数组来进行实现一个堆的结构,怎么实现呢?
有两种方法,第一就是向上调整,第二就是向下调整,但是向上调整时间复杂度较高,O(n*logn),想要算这个时间复杂度,你看完下面我计算向下调整的时间复杂度就会了,这里我们推荐向下调整(时间复杂度O(logn)),这是最优解!!
向下调整怎样将一个毫无规律的数组变成一个堆结构呢??
看图:
就是从后往前建堆,也就是先建小堆,然后再建大堆,而且得依次建堆!!!
堆结构实现了后.我们这样排序呢??
我们可以将堆顶元素和最后一个元素交换,然后将交换完的的结构再重新建堆(和删除的向下调整一样),当然这建堆过程的size得-1,因为我们不能算交换到最后的那个元素!
所以小堆我们能排降序,大堆我们能排升序

代码实现:

void Swap(HPDataType* p1, HPDataType* p2)
{
	HPDataType tmp;
	tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
//向下调整
void ADjustDown(HPDataType* data, HPDataType father,int size)
{
	//法一:迭代
	//HPDataType child = father * 2 + 1;
	// //if ((data[child] < data[child + 1])&&(child+1<size))//找到孩子较大的一个
	//if ((data[child] > data[child + 1]) && (child + 1 < size))//小堆,找到孩子较小的一个

	//{
	//	child++;
	//}
	//while (child<size) 
	//{
	//	if (data[father] < data[child])//大堆
	//	//if (data[father] > data[child])//小堆
	// 
	//	{
	//		Swap(&data[father], &data[child]);
	//		father = child;//孩子变父亲,向下迭代
	//		child = father * 2 + 1;
	//	}
	//	else
	//	{
	//		break;
	//	}
	//}
	//法二:递归
	HPDataType child = father * 2 + 1;
	if (child >= size)return;
	else
	{
		//if ((data[child] < data[child + 1]) && (child + 1 < size))//大堆,找到孩子较大的一个
		if ((data[child] > data[child + 1]) && (child + 1 < size))//小堆,找到孩子较小的一个

		{
		child++;
		}
		//if (data[father] < data[child])//大堆
		if (data[father] > data[child])//小堆
		{
		Swap(&data[father], &data[child]);
		}
		ADjustDown(data,child,size);
	}
}	
void Heapsort(HPDataType* data,int size)
{
	for (int i = (size - 1 - 1) / 2; i >= 0; i--)
	{
		ADjustDown(data,i,size);
	}
	int end = size - 1;
	while (end > 0)
	{
		Swap(&data[0], &data[end]);
		ADjustDown(data, 0, end);
		end--;
	}
}

现在我们来计算一下建堆的时间复杂度:

ps:上述图片来源网络收集,如有侵权,请联系删除!