数据结构:堆的实现和堆排序及TopK问题

已于 2023-09-26 18:51:14 修改
阅读量202 收藏
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构 算法
于 2023-09-26 11:38:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Kuzuba/article/details/133302058
版权

文章目录


物理结构有顺序结构存储和链式结构存储两种,二叉树理所应当也是可以顺序结构存储和链式结构存储的.

但是普通的二叉树显然不适合使用数组来存储,因为可能会存在大量的空间浪费,而完全二叉树更加适合用顺序结构存储,因为它中间不会有空的元素,从头到尾一直连续.

在这里插入图片描述

有一种数据结构就是将完全二叉树以数组存放的,这就是下面介绍的堆.

1. 堆的概念和性质

1.1 堆的概念

堆（Heap）是计算机科学中一类特殊的数据结构的统称.堆通常是一个可以被看做一棵完全二叉树的数组对象.

如果有一个关键码的集合 K = { k 0 , k 1 , k 2 , . . . , k n − 1 k_0, k_1, k_2, ..., k_{n-1} k0​,k1​,k2​,...,kn−1​}, 把它的所有元素按完全二叉树的顺序存储方式存储在一个一维数组中, 并满足: K i < = K 2 ∗ i + 1 且 K i < = K 2 ∗ i + 2 ( i = 0 , 1 , 2... ) , 则称为小堆 K_i<=K_{2*i+1}且K_i<=K_{2*i+2}(i=0,1,2...),则称为小堆 Ki​<=K2∗i+1​且Ki​<=K2∗i+2​(i=0,1,2...),则称为小堆

或 K i > = K 2 ∗ i + 1 且 K i > = K 2 ∗ i + 2 ( i = 0 , 1 , 2... ) , 则称为大堆 或K_i>=K_{2*i+1}且K_i>=K_{2*i+2}(i=0,1,2...),则称为大堆 或Ki​>=K2∗i+1​且Ki​>=K2∗i+2​(i=0,1,2...),则称为大堆将根节点最大的堆叫做最大堆或大根堆,根节点最小的堆叫做最小堆或小根堆.

总结为
小堆:任意一个父亲都 <= 孩子
大堆:任意一个父亲都 >= 孩子

1.2 堆的性质

  • 堆中某个结点的值总是不大于或不小于其父结点的值;
  • 堆总是一棵完全二叉树

在这里插入图片描述

1.3 堆的作用

  • 堆排序:时间复杂度为 O ( N ∗ l o g N ) O(N*logN) O(N∗logN)
  • 解决 T o p K TopK TopK问题:在 N N N个数中间找出最大的前 k k k个或者最小的前 k k k个
  • 在操作系统中:根据优先级决定若干进程中使用哪个进程

2. 堆的声明

所有的数组都可以被当作完全二叉树,但不是所有的数组都能被称为堆.

本文实现大堆,若想灵活实现大小堆转换,可以使用函数指针

// 堆的结构
typedef struct Heap
{
  HPDatatype* a;    //堆底层用数组存储
  int size;         //堆的元素个数
  int capacity;     //堆的容量
}Heap;

//向上调整
void AdjustUp(HPDatatype* a, int child);
//向下调整
void AdjustDown(HPDatatype* a, int n , int parent);

//交换值
void Swap(HPDatatype* p1, HPDatatype* p2);
//堆初始化
void HeapInit(Heap* hp);
//堆打印
void HeapPrint(Heap* hp);
//堆使用数组初始化
void HeapArrayInit(Heap* hp, HPDatatype* a, int n); 
//堆销毁
void HeapDestroy(Heap* hp);
//堆插入
void HeapPush(Heap* hp, HPDatatype x);
//删除堆顶元素
void HeapPop(Heap* hp);
//返回堆顶数据
HPDatatype HeapTop(Heap* hp);
//判断堆是否为空,为空返回非0,非空返回0
int HeapEmpty(Heap* hp);

可以发现,虽然堆的结构和顺序表是一样的,但是它们的逻辑结构是不同的.堆是特殊的完全二叉树,是树形层次结构;顺序表是顺序存储的线性表,是线性存储结构.

3. 堆的实现

关于堆的初始化,打印,销毁等操作,与顺序表基本一致,这里不过多赘述.

最重要的是堆的插入,删除堆顶元素和堆使用数组初始化,需要保持堆序性质,

3.1 堆的插入

先将元素 X X X 插入到数组最后一个位置,随后将它与它的父亲相比较,如果不满足堆序,则交换两值, 直至 X X X 到堆顶或者满足堆序结束判断.
在这里插入图片描述

上面的行为可以称之为向上调整(AdjustUp), 具体实现如下

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;
    }
  }  
}

有了向上调整的函数,堆插入就很容易写出来了

void HeapPush(Heap* hp, HPDatatype x)
{
  assert(hp);

  //扩容
  if (hp->size == hp->capacity)
  {
    int newCapacity = hp->capacity == 0 ? 4 : 2 * hp->capacity;
    HPDatatype* tmp = (HPDatatype*)realloc(hp->a, sizeof(HPDatatype) * newCapacity);
    if (tmp != NULL)
    {
      hp->a = tmp;
      hp->capacity = newCapacity;
    }
    else 
    {
      perror("realloc");
    }
  }

  //先将元素插到数组末尾
  hp->a[hp->size] = x;
  
  //向上调整
  AdjustUp(hp->a, hp->size);
  
  //修改大小
  hp->size++;
}

向上调整逻辑上控制树,物理上控制数组,向上调整只会影响该元素的祖先,不会影响根结点的另外一棵子树.

时间复杂度为 O ( l o g N ) O(logN) O(logN)

3.2 删除堆顶元素

首先交换堆顶和堆底的元素,删除此时位于堆底的元素,随后将此时堆顶的元素和其孩子中的较大(或较小)值比较,如果不满足堆序进行交换,直至满足堆序或者该元素已经没有孩子.

在这里插入图片描述

需要注意的是:并不是所有的结点都有两个孩子,所以在寻找结点孩子中的较大(较小)值,需要提前判断是否有右孩子

void AdjustDown(HPDatatype* a, int n, int parent)
{
  int child = parent * 2 + 1;

  while (child < n)
  {
    //找到更大的孩子
    if (child + 1 < n && a[child + 1] > a[child])
    {
      child++;
    }

    //如果孩子比父亲大,交换元素
    if (a[child] > a[parent])
    {
      Swap(&a[child], &a[parent]);
      parent = child;
      child = parent * 2 + 1;
    }
    else 
    {
      break;
    }
  }
}

向下调整有个前提,就是该结点的左右子树都是堆.
时间复杂度也是 O ( l o g N ) O(logN) O(logN),最坏情况是从根节点移动到叶子节点.

void HeapPop(Heap* hp)
{
  assert(hp); //确保hp合法
  assert(!HeapEmpty(hp)); //确保堆不为空
 
  //交换最后一个元素和首元素
  Swap(&hp->a[0], &hp->a[hp->size - 1]);
  hp->size--;

  //向下调整
  AdjustDown(hp->a, hp->size, 0);
}

3.3 利用数组建堆

有两种方法:
一. 从头遍历数组依次将元素 push 进堆, 即每 push 一个元素调用一次向上调整算法
二. 从最后一个不为叶子结点的结点开始向下调整,向前直到根节点, 即使用向下调整算法

  • 使用插入建堆
    在这里插入图片描述
void HeapArrayInit(Heap* hp, HPDatatype* a, int n)
{
  assert(hp); //确保hp合法

  hp->size = hp->capacity = n;
  HPDatatype* tmp = (HPDatatype*)malloc(sizeof(HPDatatype) * n);
  if (tmp == NULL)
  {
     perror("malloc");
  }

  hp->a = tmp;
  memcpy(hp->a, a, sizeof(HPDatatype) * n);
  
  //建堆
  int i = 0;
  for (i = 0; i < n; i++)
  {
    AdjustUp(hp->a,i);
  }
}

由于每个向上调整算法是 O ( l o g N ) O(logN) O(logN)的时间复杂度, 一共有 N 个结点, 需要调用 N 次向上调整算法, 所以插入建堆的时间复杂度为 O ( N ∗ l o g N ) O(N*logN) O(N∗logN)

假设堆是满二叉树,方便运算.
在这里插入图片描述

等式 1 : T ( N ) = 2 0 ∗ 0 + 2 1 ∗ 1 + . . . + 2 h − 1 ∗ ( h − 1 ) 等式1:T(N) = 2^0*0 + 2^1*1 +...+2^{h-1}*(h-1) 等式1:T(N)=20∗0+21∗1+...+2h−1∗(h−1)
等式 2 : 2 T ( N ) = 2 1 ∗ 0 + 2 2 ∗ 1 + . . . + 2 h ∗ ( h − 1 ) 等式2:2T(N) = 2^1*0 + 2^2*1 +...+2^h*(h-1) 等式2:2T(N)=21∗0+22∗1+...+2h∗(h−1)

等式2 - 等式1推出:
T ( N ) = − ( 2 1 + 2 2 + . . . + 2 h − 1 ) − 2 h ∗ ( h − 1 ) T(N) = -(2^1 + 2^2 +...+2^{h-1})-2^h*(h-1) T(N)=−(21+22+...+2h−1)−2h∗(h−1)

= 2 ∗ ( 1 − 2 h − 1 ) 1 − 2 − 2 h ∗ ( h − 1 ) = \frac{2*(1-2^{h-1})}{1-2} -2^h*(h-1) =1−22∗(1−2h−1)​−2h∗(h−1)

= 2 h − 1 − 1 − 2 h ∗ ( h − 1 ) = 2^{h-1}-1-2^h*(h-1) =2h−1−1−2h∗(h−1)

又因为 h = l o g 2 ( N + 1 ) 即 2 h = N + 1 又因为 h = log_2(N+1) 即 2^h = N+1 又因为h=log2​(N+1)即2h=N+1

最终 T ( N ) = N + 1 2 − 1 − ( N + 1 ) ∗ [ l o g 2 ( N + 1 ) − 1 ] = O ( N ∗ l o g N ) 最终 T(N) = \frac{N+1}{2} - 1 - (N+1)*[log_2(N+1) - 1] = O(N*logN) 最终T(N)=2N+1​−1−(N+1)∗[log2​(N+1)−1]=O(N∗logN)

  • 从最后一个分支节点开始 由下向上 向下调整
    在这里插入图片描述
void HeapArrayInit(Heap* hp, HPDatatype* a, int n)
{
  assert(hp); //确保hp合法

  hp->size = hp->capacity = n;
  HPDatatype* tmp = (HPDatatype*)malloc(sizeof(HPDatatype) * n);
  if (tmp == NULL)
  {
     perror("malloc");
  }

  hp->a = tmp;
  memcpy(hp->a, a, sizeof(HPDatatype) * n);
  
  int i = 0;  
  //从最后一个分支结点开始向下调整建堆
  for (i = (n-2)/2; i >= 0; i--)
  {
    AdjustDown(hp->a, n, i);
  }
}

让我们分析使用向下调整的时间复杂度,假设堆是满二叉树,方便计算.
在这里插入图片描述

等式 1 : T ( N ) = 2 0 ∗ ( h − 1 ) + 2 1 ∗ ( h − 2 ) + . . . + 2 h − 2 ∗ 1 等式1:T(N) = 2^0*(h-1) + 2^1*(h-2) +...+2^{h-2}*1 等式1:T(N)=20∗(h−1)+21∗(h−2)+...+2h−2∗1
等式 2 : 2 T ( N ) = 2 1 ∗ ( h − 1 ) + 2 2 ∗ ( h − 2 ) + . . . + 2 h − 1 ∗ 1 等式2:2T(N) = 2^1*(h-1) + 2^2*(h-2) +...+2^{h-1}*1 等式2:2T(N)=21∗(h−1)+22∗(h−2)+...+2h−1∗1

等式2 - 等式1推出:
T ( N ) = − ( h − 1 ) + 2 1 + 2 2 + . . . + 2 h − 2 + 2 h − 1 T(N) = -(h-1) + 2^1+2^2+...+2^{h-2}+2^{h-1} T(N)=−(h−1)+21+22+...+2h−2+2h−1

= − h + 2 0 + 2 1 + 2 2 + . . . + 2 h − 2 + 2 h − 1 = 1 ∗ ( 1 − 2 h ) 1 − 2 − h = -h + 2^0 +2^1+2^2+...+2^{h-2}+2^{h-1} = \frac{1*(1-2^h)}{1-2} -h =−h+20+21+22+...+2h−2+2h−1=1−21∗(1−2h)​−h

= 2 h − 1 − h = 2^h-1-h =2h−1−h

又因为 h = l o g 2 ( N + 1 ) 即 2 h = N + 1 又因为 h = log_2(N+1) 即 2^h = N+1 又因为h=log2​(N+1)即2h=N+1

最终 T ( N ) = N − l o g 2 ( N + 1 ) = O ( N ) 最终 T(N) = N - log_2(N+1) = O(N) 最终T(N)=N−log2​(N+1)=O(N)

最终可以发现,两种方式不仅建堆的结果不同,而且由下向上的建堆方式时间复杂度更低.

在这里插入图片描述

平常都是使用第二种方式进行建堆的

3.4 完整代码

  • Heap.h
#pragma once 

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>

typedef int HPDatatype;

// 堆的结构
typedef struct Heap
{
  HPDatatype* a;    //堆底层用数组存储
  int size;         //堆的元素个数
  int capacity;     //堆的容量
}Heap;

void AdjustUp(HPDatatype* a, int child);
void AdjustDown(HPDatatype* a, int n , int parent);

void Swap(HPDatatype* p1, HPDatatype* p2);
void HeapInit(Heap* hp);
void HeapPrint(Heap* hp);
void HeapArrayInit(Heap* hp, HPDatatype* a, int n); 
void HeapDestroy(Heap* hp);
void HeapPush(Heap* hp, HPDatatype x);
void HeapPop(Heap* hp);
HPDatatype HeapTop(Heap* hp);
int HeapEmpty(Heap* hp);
  • Heap.c
#include "Heap.h"

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;
    }
  }  
}

void AdjustDown(HPDatatype* a, int n, int parent)
{
  int child = parent * 2 + 1;

  while (child < n)
  {
    //找到更大的孩子
    if (child + 1 < n && a[child + 1] > a[child])
    {
      child++;
    }

    //如果孩子比父亲大,交换元素
    if (a[child] > a[parent])
    {
      Swap(&a[child], &a[parent]);
      parent = child;
      child = parent * 2 + 1;
    }
    else 
    {
      break;
    }
  }

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

void HeapInit(Heap* hp)
{
  assert(hp); //确保hp合法

  hp->a = NULL;
  hp->size = hp->capacity = 0;
}

void HeapArrayInit(Heap* hp, HPDatatype* a, int n)
{
  assert(hp); //确保hp合法

  hp->size = hp->capacity = n;
  HPDatatype* tmp = (HPDatatype*)malloc(sizeof(HPDatatype) * n);
  if (tmp == NULL)
  {
     perror("malloc");
  }

  hp->a = tmp;
  memcpy(hp->a, a, sizeof(HPDatatype) * n);
  
  int i = 0;
  //插入建堆
  //for (i = 0; i < n; i++)
  //{
  //  AdjustUp(hp->a,i);
  //}
  
  //从最后一个分支结点开始向下调整建堆
  for (i = (n-2)/2; i >= 0; i--)
  {
    AdjustDown(hp->a, n, i);
  }
}

void HeapPrint(Heap* hp)
{
  assert(hp); //确保hp合法

  int i = 0;
  for (i = 0; i < hp->size; i++)
  {
    printf("%d ", hp->a[i]);
  }
  printf("\n");
}

void HeapDestroy(Heap* hp)
{
  assert(hp); //确保hp合法

  free(hp->a);
  hp->a = NULL;
  hp->size = hp->capacity = 0;
}

void HeapPush(Heap* hp, HPDatatype x)
{
  assert(hp);

  //扩容
  if (hp->size == hp->capacity)
  {
    int newCapacity = hp->capacity == 0 ? 4 : 2 * hp->capacity;
    HPDatatype* tmp = (HPDatatype*)realloc(hp->a, sizeof(HPDatatype) * newCapacity);
    if (tmp != NULL)
    {
      hp->a = tmp;
      hp->capacity = newCapacity;
    }
    else 
    {
      perror("realloc");
    }
  }

  //先将元素未查到数组末尾
  hp->a[hp->size] = x;
  
  //向上调整
  AdjustUp(hp->a, hp->size);
  
  //修改大小
  hp->size++;
}

void HeapPop(Heap* hp)
{
  assert(hp); //确保hp合法
  assert(!HeapEmpty(hp)); //确保堆不为空
 
  //交换最后一个元素和首元素
  Swap(&hp->a[0], &hp->a[hp->size - 1]);
  hp->size--;

  //向下调整
  AdjustDown(hp->a, hp->size, 0);
}

HPDatatype HeapTop(Heap* hp)
{
  assert(hp);
  assert(!HeapEmpty(hp));

  return hp->a[hp->size-1];
}

int HeapEmpty(Heap* hp)
{
  assert(hp); //确保hp合法

  if (hp->size == 0)
  {
    return 1;
  }
  else 
  {
    return 0;
  }
}
  • test.c
#include "Heap.h"

void HeapTest1()
{ 
  int a[] = {60, 70, 80, 50, 40, 30}; 
  AdjustDown(a, 6, 0);

  int i = 0;

  for (i = 0; i < sizeof(a) / sizeof(a[0]); i++)
  {
    printf("%d ", a[i]);
  }
  printf("\n");
}

void HeapTest2()
{
  Heap heap;

  HeapInit(&heap);
  HeapPush(&heap, 60);
  HeapPush(&heap, 70);
  HeapPush(&heap, 80);
  HeapPush(&heap, 50);
  HeapPush(&heap, 40);
  HeapPrint(&heap);
  HeapPush(&heap, 30);
  AdjustDown(heap.a, 6, 0);
  HeapPrint(&heap);
}

void HeapTest3()
{
  Heap heap;

  int a[] = {7, 8, 6, 4, 9, 2, 1, 0};
  HeapArrayInit(&heap, a, 8);
  HeapPrint(&heap);

  HeapPop(&heap);
  HeapPrint(&heap);
}

//升序
void HeapSort(int* a, int n)
{
  int i = 0;
  //建大堆
  for (i = 0; i < n; i++)
  {
    AdjustUp(a, i);
  }

  //不断将根元素放置最后一个,让前面的元素向下调整
  for (i = 0; i < n; i++)
  {
    Swap(&a[0], &a[n - 1 - i]);
    AdjustDown(a, n - 1 - i, 0);
  }
}

int main(void)
{
  //HeapTest1();
  //HeapTest2();
  HeapTest3();
  
  int a[] = {3,4,5,6,9,10,2};
  HeapSort(a, sizeof(a) / sizeof(a[0]));

  int i = 0;
  for (i = 0; i < sizeof(a) / sizeof(a[0]); i++)
  {
    printf("%d ", a[i]);
  }
  printf("\n");
  return 0;
}

4. 堆的应用

4.1 堆排序

堆排序即用堆的思想来进行排序.

总共分为两个步骤:

  • 建堆
    • 升序:建大堆
    • 降序:建小堆
  • 利用堆删除思想来进行排序

首先考虑,为什么升序只能建大堆,我建小堆不可以吗?

  • 答案肯定是否定的.如果我建小堆,根据小堆的性质,小堆的根结点是最小数.此时 1 是最小值.
    在这里插入图片描述

  • 随后我忽视 1, 对剩下的元素进行堆排序,但是剩下的元素并不一定是堆.

    忽视 1,2,3 后, 此时只剩下

    在这里插入图片描述

    但是此时剩下的数并不能构成小堆,需要我重新建堆

  • 为了避免剩下的数不能构成小堆的情况,我需要每次都对剩下元素进行重新建堆.每一次将剩余元素前移需要消耗 O ( N ) O(N) O(N)的时间复杂度,同时上面已经讨论过,建堆至少也要消耗 O ( N ) O(N) O(N)的时间复杂度.

  • 也就是说,这样操作的时间复杂度是 O ( N 2 ) O(N^2) O(N2),那我为什么不直接用代码更简便的冒泡排序呢?

堆排序的基本思想:

  • 将待排序的序列构造成一个大顶堆.此时,整个序列的最大值就是堆顶的根结点.
  • 将它移走(其实就是将其与堆数组的末尾元素交换,此时末尾元素就是最大值)
  • 然后将剩余的 n-1 个序列重新构造成一个堆, 这样就会得到 n 个元素中的次大值.
  • 如此反复执行,便能得到一个有序序列了.

在这里插入图片描述

//升序
void HeapSort(int* a, int n)
{
  int i = 0;
  //建大堆,从最后一个分支结点开始向下调整
  for (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);
    --end;
  }

}

堆排序时间复杂度分析:

  • 首先建堆的时间复杂度为 O ( N ) O(N) O(N)
  • 每次向下调整的时间复杂度为 O ( l o g N ) O(logN) O(logN), 一共会有 n-1 次.那么就是 O ( N ∗ l o g N ) O(N*logN) O(N∗logN)
  • 所以总体来说L:堆排序的时间复杂度是 O ( N ∗ l o g N ) O(N*logN) O(N∗logN), 最好,最坏和平均时间复杂度都是如此.

4.2 TopK问题

在 N 个数中找出最大的前 K 个 （比如在1000个数中找出最大的前10个）

  • 方法一:按降序 堆排序 所有的元素, 前 K 个元素就是最大的前 K 个元素
    时间复杂度: O ( N ∗ l o g N ) O(N*logN) O(N∗logN)

有没有更优化的呢?我只需要取前 K 个, 那么我并不需要将所有的元素都排序.

  • 方法二:先建大堆, Pop K 次, 取到最大的 K 个数
    时间复杂度: O ( N + l o g N ∗ K ) O(N + logN*K) O(N+logN∗K)
    空间复杂度: O ( N ) O(N) O(N)

还是有点复杂,如果N很大的话,空间复杂度也会很大.

假设 N 是10亿,我需要先建一个占据 10亿字节的堆, 10亿字节约为 1G 空间,这所消耗的空间是巨大的.

  • 方法三:
  • 用前 K 个数先建小堆
  • 剩下的 N-K 个数, 依次和堆顶元素进行比较. 如果比堆顶元素大, 替换堆顶元素并且向下调整.
  • 遍历完 N 个数后, 最后堆里的 K 个数就是最大的 K 个数

时间复杂度: O ( K + ( N − K ) ∗ l o g K ) = O ( N ∗ l o g K ) O(K + (N-K)*logK) = O(N*logK) O(K+(N−K)∗logK)=O(N∗logK)
空间复杂度: O ( K ) O(K) O(K)

为什么建的是小堆呢?

最大的 K 个数一定比其他的数都要大, 同时小堆大数会沉底. 也就是说, 留在堆顶的只能是第 K 个大的数, 或者是其他比 第 K 个大的数 小的数.这样最大的 K 个数一定会进堆.

代码实现

首先我写了个CreateData()函数用来往文件中存放数据,我存放的数的范围是 [ 0 , 10000000 ) [0,10000000) [0,10000000),为了验证我之后写的代码是否能找到前 K 个数, 我在 data 文件中修改了 K 个数, 都比 10000000 大.

void CreateData()
{
  //打开文件
  FILE* fout = fopen("data", "w+");
  if (fout == NULL)
  {
    perror("fopen");
  }

  //随机放数
  srand(time(0));
  int i = 0;
  int n = 10000000;

  for (i = 0; i < 10000; i++)
  {
    int num = (rand() + i) % n; 
    fprintf(fout, "%d\n", num);
  }

  fclose(fout);
}

接着是解决 TopK 的核心代码

//小堆向下调整
void AdjustDown_small(HPDatatype* a, int n, int parent)
{
  assert(a);
  
  int child = parent * 2 + 1;

  while (child < n)
  {
    if (child + 1 < n && a[child + 1] < a[child])
    {
      child++;
    }

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

//得到n个数中的最大k个
void PrintTopK(const char* filename, int k)
{
  //打开文件
  FILE* fout = fopen(filename, "r");
  if (fout == NULL)
  {
    perror("fopen");
  }

  //申请一个大小为k的数组空间
  int* a = (int*)malloc(sizeof(int) * k);

  //先将前k个数据建小堆
  int i = 0; 
  for (i = 0; i < k; i++)
  {
    fscanf(fout, "%d", &a[i]);
  }

  for (i = (k-2)/2; i>=0; i--)
  {
    AdjustDown_small(a, k, i);
  }

  //遍历剩余的数，如果有比堆顶大的数，入堆并向下调整
  int num = 0;
  while (fscanf(fout, "%d", &num) != EOF)
  {
    //如果num大于堆顶元素，入堆并向下调整
    if (num > a[0])
    {
      a[0] = num;
      AdjustDown_small(a, k, 0);
    }
  }

  fclose(fout);

  for (i = 0; i < k; i++)
  {
    fprintf(stdout, "%d\n", a[i]);
  }

  free(a);
}

结果如下:
k = 10:
在这里插入图片描述

k = 11:
在这里插入图片描述

本章完.

想学好C++的oMen
关注
专栏目录
【算法与数据结构】堆排序&&TOP-K问题
a_sen的博客
03-17 2435
堆排序即利用堆的思想来进行排序，总共分为两个步骤： 代码运行： TOP-K问题是数据挖掘和信息检索中的一个重要问题。TOP-K问题：即求数据结合中前K个最大的元素或者最小的元素，一般情况下数据量都比较大。 TOP-K问题是数据挖掘和信息检索中的一个重要问题。TOP-K问题的含义是:给定一个集合,找出其中值最大或最小的前K个元素。常见的TOP-K问题有:查找文档集合中与查询条件最相关的前K篇文档。这在搜索引擎中很常见。从用户评分最高的物品中找出前K个最受欢迎的物品。从数据库中找出收入前K高的用户。从候选
【数据结构入门】堆的应用：TopK & 堆排序
codewinter的博客
02-28 4071
文章目录一、Top-k问题1.1 解法一：暴力排序1.2 解法二：建N个数的堆1.3 解法三：建K个数的堆（最优解法）二、堆排序 一、Top-k问题 Top-k问题：在 N 个数中，找出前 K 个（最大/最小）的元素，一般情况下数据量 N 都远大于 k。 Top-k问题在生活中是非常的常见，比如游戏中某个大区某个英雄熟练度最高的前10个玩家的排名，我们就要根据每个玩家对该英雄的熟练度进行排序，可能有200万个玩家，但我只想选出前10个，要对所有人去排个序吗？显然没这个必要。 再比如：专业前10名、世界50
数据结构：手撕图解堆的实现和TopK的应用
海绵宝宝de派小星的博客
07-14 2726
堆的实现，堆排序和TopK
【数据结构】堆——堆排序与海量TopK问题
Eraser的博客
09-08 1142
上一篇我们学习了堆的数据结构，现在我们来看看堆的日常应用和排序建堆的时间复杂度是O(N)，排序的时间复杂度是，整体是，具体怎么算出来的大家可以看下面内容。建堆需要从倒数第一个非叶子结点开始调整，从后往前，直到堆顶的数据最后一个非叶子结点的计算方式：n - 1是最后一个节点的下标，父亲 = (孩子 - 1) / 2，所以(n - 1 - 1) / 2end是最后一个数据的下标，我们先交换，在向下调整，就传过去了end(n-1)个要调整的数据，正好排除掉了最后已经排序好的数据。end > 0。
【数据结构】堆排序与Top-K问题
Brant_zero的博客
07-07 639
在上篇文章了解了堆的基本功能后，我们便可以使用堆来实现其独特的功能——堆排序与Top-K问题，我们一起来往下学习。
[数据结构]堆的经典——TopK问题与堆排序
weixin_46016019的博客
03-27 2721
详细讲解堆中经典的TopK问题与堆排序以及实现源码
【数据结构】堆(Heap):堆的实现、堆排序、TOP-K问题
m0_64476561的博客
11-13 1466
先考虑扩容，将数据插到最后，再用向上调整法。
＜ 数据结构 ＞ 堆的应用 --- 堆排序和Topk问题
bit_zyx的博客
04-18 1416
目录 1、堆排序 法一：自己写堆进行排序 时间复杂度分析 法二：直接对数组建堆 ①、向上调整建堆 ②、向下调整建堆 向上建堆和向下建堆熟优？ 升序能否建小堆？ 排序（建大堆） 2、TopK问题 何为Topk？ 实现过程 1、堆排序 假如我们有一串乱序数组，如...
堆排序在topK场景题中的应用及原理
梦~'
11-15 964
堆排序在topK场景题中的应用及原理
数据结构：堆的应用(堆排序和topk问题)
li209779的博客
08-13 865
以上就是我对于堆的应用的理解！！！
数据结构：堆排序(升序排序建大堆)，TOP-K问题
10-06
总的来说，掌握堆排序和如何解决TOP-K问题对于理解和优化算法性能至关重要。这两个概念不仅在理论上有价值，而且在实际编程中，特别是在大数据分析、实时数据处理等领域有广泛应用。理解并能熟练运用它们，将有助于...
【数据结构】堆的拓展延伸 —— 堆排序 和 TopK问题
StackFrame
11-22 1151
图文详解 + 多样例分析证明带你掌握 堆排序 和 TopK问题
堆C++(堆排序+topK问题)
qq_41067989的博客
12-30 1071
今天复习一下堆的知识。 先手写复现一边堆排序，C++代码如下。 代码写的是小顶堆。 void heap_build(vector<int> &arr,int i,int size){ int l=2*i+1; int r=l+1; int flag=i; if(l<size && arr[l]>arr[flag]){ flag=l; } if(r<size && arr[r]
考研数据结构——C语言实现插入排序
最新发布
weixin_58879477的博客
09-24 396
C语言实现插入排序
数据结构：树、森林
pranaa的博客
09-24 836
此外，访问子节点和父节点的索引计算也会变得复杂，因为需要额外的数据结构（如指针或索引数组）来跟踪每个节点的子节点位置。在转换为二叉树时，我们可以将节点的第一个孩子视为二叉树的左孩子，将节点的下一个兄弟视为二叉树的右孩子。这种转换在处理树形结构的问题时非常有用，因为二叉树具有一些特殊的性质（如左子树和右子树的明确区分）和高效的算法（如二叉搜索树、堆等）。二叉树和树的顺序存储结构在本质上是相似的，但由于二叉树结构的特殊性，它在顺序存储中更加高效和直接。二叉树转换为树的过程是上述转换的逆过程。
优先级队列(堆)
wuweixiaoyue的博客
09-24 335
什么是优先级队列：队列是一种先进先出(FIFO)的数据结构，但如果操作的数据带有优先级并且我们需要处理优先级更高的队列，此时光用【队列】不太合适，故而我们引入了【优先级队列(PriorityQueue)】如何实现优先级队列：JDK1.8中的PriorityQueue底层使用了堆这种数据结构来模拟优先级队列概念：堆实际就是在完全二叉树的基础上进行了一些调整 + 以顺序存储(数组)的方式存储二叉树。
javaScript 数据结构可变性和不可变性
everyStudy的博客
09-24 399
【代码】javaScript 数据结构可变性和不可变性。
数据结构 - 排序算法
kaneki_lh的博客
09-23 462
①.经过一趟快速排序后，确认。②.对每一组 分别 / 交替 直接插入排序。①.对序列进行分组，增量为 d。③.逐渐减小增量 d。②.该基准将整个数组分为。
Java-数据结构-排序(三) |ू･ω･` )
2303_80388948的博客
09-24 725
OK，到这里呢我们的排序呢就结束了，这次关于排序的代码呢还是比较多的，要认真的理解它们，同时要画图的去理解它们的执行流程。下一篇博客呢我们就要介绍关于Map与Set的知识啦，让我们尽情期待吧！！！拜拜~~~
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值