堆的基本操作

special_3

已于 2024-08-23 18:29:10 修改

阅读量660

点赞数 7

文章标签：数据结构开发语言

于 2024-08-23 18:27:35 首次发布

本文链接：https://blog.csdn.net/special_3/article/details/141466097

版权

一、堆的基本含义

堆是计算机科学中一类特殊的数据结构，是最高效的优先级队列。堆通常是一个可以被看作一棵完全二叉树的数组对象，看起像是一颗二叉树，实际存储是像顺序表一样，堆分为两种，一种是小堆，一种是大堆，我这里编写代码默认的是大堆。

就像这样：想象中堆是这样的，注意以上是小根堆，但是实际存储时，是下面这样的：

二、堆的基本操作

在操作之前还是先初始化化一下，避免指针的错误，这里的初始化和顺序标基本一致

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

堆的主要操作只有插入删除，不分前后，其核心就是向上调整和向下调整，向上调整是插入数据时，数据在尾部插入，借助子树与父树的特殊关系向上调整，向上调整的代码如下：

void Swap(int *a, int *b)
{
    int temp = *a;
    *a = *b;
    *b = temp;
}

void AdjustUp(Heap *hp, int child)
{
    int parent = (child - 1) / 2;//父亲的下标刚好是儿子的二倍减1
    while (child > 0)//当儿子的下标等于0相当于已经调整到根部了
    {
        if (hp->data[child] > hp->data[parent])//这里的判断决定了建大堆还是小堆，大于大堆，小于小堆
        {
            Swap(&hp->data[child], &hp->data[parent]);//使用了一个交换函数进行交换
            child = parent;//将父亲的下标给儿子，
            parent = (child - 1) / 2;//算出父亲的下标
        }
        else
        {
            break;
        }
    }
}

再插入之前，先写一个扩容的函数，尽管堆只有一个插入操作，还是封装一下扩容，是代码看起来简洁一点

void CheckHeap(Heap *hp)
{
    if (hp->size == hp->capacity)
    {
        int newcapacity = hp->capacity == 0 ? 4 : 2 * hp->capacity;
        int *newdata = (int *)realloc(hp->data, sizeof(int) * newcapacity);
        if (newdata == NULL)
        {
            perror("malloc perror");
            exit(-1);
        }
        hp->data = newdata;
        hp->capacity = newcapacity;
    }
}

插入函数如下：

void insert(Heap *hp, int data)
{
    assert(hp);//断言判断是否为空
    CheckHeap(hp);//检查是否扩容
    hp->data[hp->size] = data;
    hp->size++;
    AdjustUp(hp, hp->size - 1);//这里传入hp->size-1的原因是因为size表示的存储了多少数据，而减一就是刚刚插入数据的下标
}

删除的接口，首先将首尾交换，进行删除，删除后从顶向下调整，保证不会出现混乱的情况，所以先写出向下调整函数

void AdjustDown(Heap *hp, int parent, int size)
{
    int child = parent * 2 + 1;//算出儿子下表
    while ((child+1) < size)//当孩子下标+1大于size时就意味着已经调整完毕
    {
        if (hp->data[child] < hp->data[child + 1] &&(child + 1) < size)
         //这里是大堆，所以如果左边孩子小于右边孩子就加加调整。
        {
            child++;
        }
        if (hp->data[child] > hp->data[parent])//孩子大于父亲交换值
        {
            Swap(&hp->data[child], &hp->data[parent]);
            parent = child;//
            child = parent * 2 + 1;
        }
        else
        {
            break;
        }
    }
}

删除接口

void earse(Heap *hp)
{
    assert(hp);//判断hp是否为空
    Swap(&hp->data[0], &hp->data[hp->size - 1]);//交换删除
    hp->size--;//减减删除
    AdjustDown(hp, 0, hp->size);//删除后向下调整
}

以上就是堆的核心操作了，那建小堆又该如何操作呢，首先是向上调整，具体代码如下：

void AdjustUp(Heap *hp, int child)
{
    int parent = (child - 1) / 2;
    while (child > 0)
    {
        if (hp->data[child] < hp->data[parent])
        {
            Swap(&hp->data[child], &hp->data[parent]);
            child = parent;
            parent = (child - 1) / 2;
        }
        else
        {
            break;
        }
    }
}

以下是向下调整

void AdjustDown(Heap *hp, int parent, int size)
{
    int child = parent * 2 + 1;
    while ((child+1) < size)
    {
        if (hp->data[child] > hp->data[child + 1] &&(child + 1) < size)
        {
            child++;
        }
        if (hp->data[child] < hp->data[parent])
        {
            Swap(&hp->data[child], &hp->data[parent]);
            parent = child;
            child = parent * 2 + 1;
        }
        else
        {
            break;
        }
    }
}

两段代码修改的都是比较关系，如果父亲节点小于儿子节点，那构建的就是小堆，儿子节点小于父亲节点那就是大堆。

获取top值操作

HPDataType HeapTop(Heap *hp){
    return hp->data[0];//返回下标为0的值
}

判断是否为空

int HeapEmpty(Heap *hp){
    return hp->size==0;
}

获取该堆内有多少数据

int HeapSize(Heap *hp)
{
    return hp->size;
}

三、堆的两种应用，TopK问题以及堆排序

TopK问题是什么，即求数据结合中前K个最大的元素或者最小的元素，一般情况下数据量都比较大。首先我们可以先创建一个文件来模拟一下巨额数据：

void Datawriting() {
	FILE* f = fopen("a.txt", "w");
	int n = 10000000;
	srand((unsigned int)time(NULL));//种下一颗随机数种子
	for (int i = 0; i < n; i++) {
		int num = (rand()+i)%n;//随机数是有限的，所以我们在创造一些数据
			fprintf(f, "%d\n", num);//写入文件
	}
	fclose(f);
}

接下来数据造好了，我们该做什么呢，思考一下这里建大堆还是小堆，很多人可能会觉得建大堆，其实不然，应该建小堆，首先从创建的文件中读取五个元素构建成堆，这样堆顶的元素就是五个中最小的，接下来就是读取文件中数据，不能一下取出来，一次取出一个数据和堆顶元素比较，如果比堆顶元素大，就替换掉，并进行向下调整，具体如下：

void topK() {
	FILE*f= fopen("a.txt", "r");//读取数据
	int* a = (int*)malloc(sizeof(int) * 5);
	for (int i = 0; i < 5; i++) {
		fscanf(f, "%d\n", &a[i]);//构建堆
		AdjustUp(a, i);
	}

	printf("\n");
	int b = 0;//存储临时变量
	while (fscanf(f, "%d\n", &b) != EOF) {//读取到EOF,读取完毕
		if (a[0] < b) {
			a[0] = b;
		AdjustDown(a, 0, 5);//向下调整
		}
	}
	for (int i = 0; i < 5; i++) {
		printf(" %d ", a[i]);
	}
	fclose(f);
}

不过要在刚刚创建的文件中填入几个大的数据，来验证。

堆排序，是一种比较高效的排序，这里建堆是从下往建堆，比较高效的方法，和接口中的尾删一样的方法，建大堆，然后将将堆顶元素和最后一个元素交换，然后将个数减减，这样每次排序都会将队中最大的值调整到堆顶，调整到最后就会变成一个升序的有序数组，建小堆就是降序。

void  HeapSort(int* a, int n) {
	for (int i = (n - 2) / 2; i >= 0;i--) {
		AdjustDown(a, i, n);
	}
	printf("\n");
	int end = n - 1;
	while (end >= 0) {
		swap(&a[0], &a[end]);
		AdjustDown(a, 0, end);
		end--;
	}
	for (int i = 0; i < n; i++) {
		printf(" %d ", a[i]);
	}
}