【数据结构】手推堆实现,拳打堆排序,脚踩Top-k

目录

  • 一.完全二叉树的顺序结构
  • 二.堆的概念及结构
  • 三.堆的实现
    • 1.堆向下调整
    • 2.向下调整建堆
    • 3.向下调整建堆时间复杂度
    • 4.堆的插入(向上调整)
    • 5.向上调整建堆
    • 6.向上调整建堆时间复杂度
    • 7.堆的删除
    • 8.堆的代码实现
  • 四.Top-K问题
  • 五.堆排序

一.完全二叉树的顺序结构

堆的逻辑结构采用完全二叉树,而堆就是在一定条件下将完全二叉树使用数组存储,我们可以利用完全二叉树更好的学习堆。

普通的二叉树是不适合用数组来存储的,因为可能会存在大量的空间浪费。而完全二叉树更适合使用顺序结构(数组)存储。
【数据结构】手推堆实现,拳打堆排序,脚踩Top-k_第1张图片

如上图该完全二叉树(按从上到下,从左到右顺序存储)的数组结构就叫做堆(上图的数组满足条件所以可以叫做堆,条件下面会讲)

  • 需要注意,这里的堆和操作系统虚拟进程地址空间中的堆是两回事,一个是数据结构,一个是操作系统中管理内存的一块区域分段。

二.堆的概念及结构

那是不是只要是一个完全二叉树,把它按顺序放在数组里就是一个堆呢?当然不是

堆的种类分为两种:

  1. 一个堆中某个节点的值总是不大于其父节点的值叫:大堆
  2. 一个堆中某个节点的值总是不小于其父节点的值叫:小堆

【数据结构】手推堆实现,拳打堆排序,脚踩Top-k_第2张图片
我们得出堆的性质:

  • 堆中某个节点的值总是不大于或不小于其父节点的值;
  • 堆总是一颗完全二叉树。(可以在逻辑上形成完全二叉树)

只有满足这两点的数组才可以被称之为堆

三.堆的实现

现在给出一个数组,逻辑上看做是一颗完全二叉树。我们已经知道堆分为大堆和小堆两种,那我们要如何才能将它变成一个完整的堆呢?

int arr[8] = { 7,4,2,9,3,4 };

【数据结构】手推堆实现,拳打堆排序,脚踩Top-k_第3张图片

  • 堆的数据结构,难点就在于堆的创建、插入和删除,所以这三个功能会放在一起讲,剩余的功能最后讲解。

这里就需要先来学一种方法完成堆的构建:堆向下调整

1.堆向下调整

按照完全二叉树的逻辑结构,从最后一个节点的父节点开始,以该节点下标为起始,与自己的两个孩子节点(可能为一个孩子节点)比较大小并根据情况交换位置(大堆比较更大的孩子节点,小堆比较更小的孩子节点),一直调整到根节点,最终得到大堆/小堆

  • 向下调整算法的前提:根节点的左右子树必须都为堆,才能调整,否则在本就无序的情况下去,去使用根节点的值去比对查找,是无法找到适合的元素的,所以向下调整只能从最后一个节点的父节点开始(也可以说是倒数的第一个非叶子节点)对比,才能保证根节点的

我们在这些做一个大堆并画出它的流程图:
【数据结构】手推堆实现,拳打堆排序,脚踩Top-k_第4张图片

  • 从最后一个父节点向下比较,建大堆,将最大值移到上面,数组的切换如上图

【数据结构】手推堆实现,拳打堆排序,脚踩Top-k_第5张图片

  • 接着使用下一个父节点与其子节点中最大值比较,与最大值交换

【数据结构】手推堆实现,拳打堆排序,脚踩Top-k_第6张图片

  • 在将下一个父节点与其子节点中的最大值比较并交换,查看交换后的子节点是否为其子节点的最大值,若不是则继续进行向下调整,否则以调整到根节点,建堆结束。

我们之前以及提过了,这个堆的存储形式是一个数组,而最后一个节点就是数组下标最大的元素,那我们要如何求出它的父节点?

这个是有固定的公式,根据这个公式:
当我们知道孩子节点的下标就能求出其父节点的下标,知道父亲节点的下标,就能求出孩子节点的下标,

下标如下图:

【数据结构】手推堆实现,拳打堆排序,脚踩Top-k_第7张图片

  • 知道父亲节点下标,求孩子节点下标
    father = 0 :
    左孩子 = father * 2 + 1 = 1;
    右孩子 = father * 2 + 2 = 2;
    father = 3 :
    左孩子 = father * 2 + 1 = 7;
    右孩子 = father * 2 + 2 = 8;
    知道父亲节点,求孩子节点的公式如下:
    左孩子 = father * 2 + 1;
    右孩子 = father * 2 + 2;

  • 知道孩子节点下标,求父亲节点下标
    知道左孩子下标
    由上面的公式推导:father = (左孩子-1)/2;
    知道右孩子下标
    由上面的公式推导:father = (右孩子-2)/2;
    其中,左孩子一定是奇数,右孩子是偶数,而在C语言中,一个偶数减1后除以2和一个偶数减2后除以2是相同的,因为下标为整数,偶数减1后除以2所得必须为整数,除不尽的部分直接舍弃。
    因此,我们不需要知道该孩子节点是左孩子还是右孩子。
    知道孩子节点下标,求父亲节点下标公式如下:
    father = (孩子-1)/2;

2.向下调整建堆

我们已经知道了一个堆是如何创建的,现在有如下数组,我们使用代码来实现堆的创建。

int arr[8] = { 7,4,2,9,3,4,5,6 };

代码如下:

void swap(int* a1, int* a2)
{
	int tmp = *a1;
	*a1 = *a2;
	*a2 = tmp;
}

void AdjustDown(int* arr, int n, int father)//向下调整
{
	int child = father * 2 + 1;//左孩子节点下标

	while (child < n) //向下调整,child只会越来越大,当超出数组范围时,退出循环
	{
		if (child+1 < n && arr[child] < arr[child + 1])//判断是否存在右孩子节点,存在左右孩子结点谁大,要是建小堆,取小的那个元素
			child = child + 1;
		if (arr[father] < arr[child])//判断父亲结点和孩子结点那个大,若孩子结点大,则进行交换,并继续向下调整,建小堆取小值即可
		{
			swap(&arr[father], &arr[child]);//两节点进行交换
			father = child;//孩子结点的下标赋给父亲结点
			child = father * 2 + 1;//孩子节点获得新的左孩子下标
		}
		else
			break;
	}
}

int CreatHeap(int* arr, int n)//arr为要建堆的数组
{
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)//循环的初始值为倒数第一个非叶子节点的下标
	{
		AdjustDown(arr, n, i);//向下调整
	}
}

3.向下调整建堆时间复杂度

时间复杂度是求该函数在最坏的情况下基本操作次数,而我们现在算的是建堆这一功能的时间复杂度,因为堆是完全二叉树,而满二叉树(除叶子节点外,每个节点都有两个孩子节点)也是完全二叉树,此处我们就能使用满二叉树来判断堆的时间复杂度。

【数据结构】手推堆实现,拳打堆排序,脚踩Top-k_第8张图片
因为需要按照最坏的情况考虑,我们就将堆中除最后一层外的其他节点都需要向下移动到最底层。
【数据结构】手推堆实现,拳打堆排序,脚踩Top-k_第9张图片
所以:建堆的时间复杂度为O(N)

4.堆的插入(向上调整)

如下图所示,我们在原有完全二叉树的基础上,向其中尾插一个10,之后就需要进行向上调整,做法如下图:
【数据结构】手推堆实现,拳打堆排序,脚踩Top-k_第10张图片

该堆为小堆,先找到新插入节点的父节点,进行对比,父节点大,进行替换,新插入的节点取代父节点,并向新的父节点进行对比操作,直到到达根节点。若是父节点小于新插入的节点,停止操作,表面堆的插入以完成。

注意:这里最好不要用向下调整,堆的插入操作是在一个堆已经成型的情况下进行,如果用向下调整,新插入的节点的父节点后的所有节点都要重新遍历一遍,时间复杂度一定要比只是移动新节点的向上调整大。

知道孩子节点,如何求父节点的公式之前已经讲了,这里我们就能直接得出代码(这里做的是小堆的插入):

向上调整代码如下:

void AdjustUp(int* arr, int child)
{
	int father = (child - 1) / 2;//获得父亲节点的下标

	while (child)
	{
		if (arr[father] > arr[child])//孩子结点数据小于父亲结点数据,两数交换
		{
			swap(&arr[father], &arr[child]);
			child = father;
			father = (child - 1) / 2;
		}
		else
			break;
	}
}
  • 向上调整也可以被用来做堆的构建但时间复杂度要大于向下调整,在下面堆的代码实现中有完整代码。

5.向上调整建堆

我们在堆的插入中已经学了堆的向上调整的思想,我们也可以利用向上调整来建堆,但是这个时间复杂度要大于向下调整,实际操作中不会用到这个方法建堆,这里简单介绍一下。
【数据结构】手推堆实现,拳打堆排序,脚踩Top-k_第11张图片

  • 使用如上图片中的数组建大堆

【数据结构】手推堆实现,拳打堆排序,脚踩Top-k_第12张图片

  • 向上调整建堆,需要按照数组一个一个插入堆中比较,出现比父节点大的数据,进行向上调整,直到数组全部进入堆中。

【数据结构】手推堆实现,拳打堆排序,脚踩Top-k_第13张图片

  • 发现插入数据比父节点大,按照向上调整,直到遇到更大的或到达根节点停止。
    【数据结构】手推堆实现,拳打堆排序,脚踩Top-k_第14张图片
    代码如下:
void AdjustUp(int* arr, int child)
{
	int father = (child - 1) / 2;//获得父亲节点的下标

	while (child)
	{
		if (arr[father] > arr[child])//孩子结点数据小于父亲结点数据,两数交换
		{
			swap(&arr[father], &arr[child]);
			child = father;
			father = (child - 1) / 2;
		}
		else
			break;
	}
}
void CreatHeap(int* a,int n)
{
	for (int i = 0; i < n; i++)
	{
		AdjustUp(a, i);
	}
}

6.向上调整建堆时间复杂度

以最坏情况来算时间复杂度,与向下调整不同,假设高度为h,最底层每个节点都要向上移动h-1次,剩余节点按层数依次类推。

【数据结构】手推堆实现,拳打堆排序,脚踩Top-k_第15张图片
将这些移动次数相加为:
【数据结构】手推堆实现,拳打堆排序,脚踩Top-k_第16张图片
所以:建堆的时间复杂度为O(Nlog(N))

向上调整建堆的时间复杂度要大于向下调整建堆

7.堆的删除

堆的删除就是将堆顶的数据删除。

具体操作:将堆顶的数据与最后一个节点的数据交换,然后删除数组中的最后一个数据,在对堆顶的数据进行向下调整,如下图。

【数据结构】手推堆实现,拳打堆排序,脚踩Top-k_第17张图片

8.堆的代码实现

由上面几个功能,比如堆的插入和删除,这是要直接对数组进行扩容等相关操作的,如果只在数组上进行会造成很多的麻烦,所以我们需要创建一个结构体来用来存储堆,而堆的删除也用用到了结构体相关的内容,结构体定义如下:

typedef int HPDataType;
typedef struct Heap
{
HPDataType* _a;
int _size;
int _capacity;
}Heap;

堆的其他功能实现难度不大,这里就只整体展示代码,不一个个讲解了。
注意:下面代码中一些类型用自定义结构体类型交换,与上面实现的代码相同
堆的所有功能代码如下;

//打印堆
void PrintHeap(Heap* hp)
{
	assert(hp);
	for (int i = 0; i < hp->size; i++)
	{
		printf("%d ", hp->a[i]);
	}
	printf("\n");
}

void HeapInit(Heap* hp)
{
	hp->a = NULL;
	hp->capacity = 0;
	hp->size = 0;
}

// 堆的销毁
void HeapDestory(Heap* hp)
{
	assert(hp);
	free(hp->a);
	hp->a = NULL;
	hp->capacity = 0;
	hp->size = 0;
}

堆的构建——偷懒的写法——使用向上调整实现堆的构建
//void HeapCreat(Heap* hp, HPDataType* a, int n)
//{
//	hp->a = (HPDataType*)malloc(sizeof(HPDataType) * n);
//	if (!hp->a)
//	{
//		perror("malloc fail!");
//		exit(-1);
//	}
//	hp->capacity = n;
//
//	for (int i = 0; i < n; i++)
//	{
//		HeapPush(hp, a[i]);
//	}
//}

//堆的构建——建堆算法
void HeapCreat(Heap* hp, HPDataType* a, int n)
{
	hp->a = (HPDataType*)malloc(sizeof(HPDataType) * n);
	if (!hp->a)
	{
		perror("malloc fail!");
		exit(-1);
	}

	memcpy(hp->a, a, sizeof(HPDataType) * n);
	hp->capacity = hp->size = n;

	//建堆算法——函数接收父亲结点算法
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(hp->a, n, i);
	}
}

//两数交换
void swap(HPDataType* a1, HPDataType* a2)
{
	HPDataType tmp = *a1;
	*a1 = *a2;
	*a2 = tmp;
}

//向上调整
void AdjustUp(HPDataType* arr, int child)
{
	int father = (child - 1) / 2;//父亲结点位置

	while (child)
	{
		if (arr[child] > arr[father])//孩子结点数据大于父亲结点数据,两数交换
		{
			swap(&arr[child], &arr[father]);
			child = father;
			father = (child - 1) / 2;
		}
		else
			break;
	}
}

// 堆的插入
void HeapPush(Heap* hp, HPDataType x)
{
	assert(hp);
	if (hp->capacity == hp->size)
	{
		int newSize = hp->capacity * 2;
		HPDataType* newArr = (HPDataType*)realloc(hp->a, newSize);
		if (!newArr)
		{
			perror("realloc fail!");
			exit(-1);
		}
		hp->capacity = newSize;
		hp->a = newArr;
	}

	hp->a[hp->size++] = x;

	AdjustUp(hp->a, 0);
}

//向下调整
void AdjustDown(HPDataType* arr,int n,int parent)
{
	int child = parent * 2 + 1;

	while (child < n)
	{
		if (child + 1 < n && arr[child] > arr[child + 1])
			child = child + 1;

		if (arr[parent] > arr[child])
		{
			swap(&arr[parent], &arr[child]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
			break;
	}
}

// 堆的删除
void HeapPop(Heap* hp)
{
	assert(hp);
	assert(hp->size);

	hp->a[0] = hp->a[--hp->size];

	AdjustDown(hp->a, hp->size, 0);
}

//取堆顶的数据
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;
}

四.Top-K问题

问题:在一个很大的数据中,取出它最大或最小的前k个值。

比如:专业前10名、世界500强、富豪榜、游戏中前100的活跃玩家等。

对于这个问题,想到最简单的方法就是排序,但是数据量非常大,当数据不可能一下子全部加载到内存中时,排序就不太可取了。

最佳的方法就是用堆来解决,基本思路如下:

1. 用数据集合中前k个元素来建堆

  • 取前k个最大的元素,建小堆
  • 取前k个最小的元素,建大堆

2.用剩余的N-k个元素依次与堆顶元素来比较,不满足则替换堆顶元素,在进行向下调整。

将剩余N-k个元素依次与堆顶元素比较完之后,堆中剩余的K个元素就是所求的前K个最小或者最大的元素。

如下图,为取前6个最大的元素的一次对比图:

【数据结构】手推堆实现,拳打堆排序,脚踩Top-k_第18张图片

具体代码如下:

void TopK(int* arr,int n,int k)
{
	int* tmpArr = (int*)malloc(sizeof(int) * k);
	
	//方法1
	//memcop(tmpArr, arr, sizeof(int) * k);//使用内存函数拷贝数组前k个数

	//方法2
	for (int i = 0; i < k; i++)
	{
		tmpArr[i] = arr[i];
	}

	for (int i = (k - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(tmpArr, k, i);//向下调整建堆
	}
	for (int i = k; i < n; i++)
	{
		if (arr[i] > tmpArr[0])
		{
			swap(&arr[i], &tmpArr[0]);
		    AdjustDown(tmpArr, k, 0);//将此时栈顶的元素进行向下调整
		}
	}
	for (int i = 0; i < k; i++)
	{
		printf("%d ", tmpArr[i]);//打印出这k个数,但此时这k个数是无序的
	}
}

五.堆排序

当我们掌握了上面的堆的创建、向下调整和父亲与孩子节点下标的转换后,堆排序的实现就非常简单

先说一下思路:

当我们想要得到一个排好序的数组时,我们需要将它先建成堆。

  • 升序:大堆
  • 降序:小堆
    假设我们要对一个大小为n的数组进行降序,
    首先,建好的小堆的堆顶就是最小的数,我们将它和第n个数交换,在将堆的大小调整为(n-1),对堆顶进行向下调整。
    其次,此时堆顶的数就是次小的数,我们在将它和第n-1个数交换,在将堆的大小调整为(n-2),对堆顶进行向下调整。
    如此循环,最后得到的n个数就是降序排好的

如下图,是堆排序的部分循环图:

【数据结构】手推堆实现,拳打堆排序,脚踩Top-k_第19张图片
剩余步骤与上述步骤相同,不在展示。

根据该思路,堆排序的实现代码如下:

void AdjustDown(int* arr, int n, int father)
{
	int child = father * 2 + 1;//左孩子节点下标

	while (child < n)
	{
		if (child+1 < n && arr[child] > arr[child + 1])//判断是否存在右孩子节点,存在左右孩子结点谁大
			child = child + 1;
		if (arr[father] > arr[child])//判断父亲结点和孩子结点那个大,若孩子结点大,则进行交换,并继续向下调整
		{
			swap(&arr[father], &arr[child]);//两节点进行交换
			father = child;//孩子结点的下标赋给父亲结点
			child = father * 2 + 1;//孩子节点获得新的左孩子下标
		}
		else
			break;
	}
}

int* HeapSort(int* arr,int n)
{
	for (int i = (n-1-1)/2; i >= 0; i--)//先建堆
	{
		AdjustDown(arr, n, i);
	}

	for (int i = 0; i < n; i++)//向下调整堆排序
	{
		swap(&arr[i], &arr[n - i - 1]);//堆顶元素与最后一个元素交换,将最大值或最小值放在最后
		AdjustDown(arr, n - i - 1, 0);
	}

	return arr;
}

你可能感兴趣的:(数据结构初阶,数据结构,算法)