堆的实现(C版)-阿里云开发者社区

堆的实现(C版)

2023-10-20 25

版权

本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。

简介： 堆的实现(C版)

普通的二叉树是不适合用数组来存储的，因为可能会存在大量的空间浪费。而完全二叉树更适合使用顺序结构存储。现实中我们通常把堆(一种二叉树)使用顺序结构的数组来存储，需要注意的是这里的堆和操作系统虚拟进程地址空间中的堆是两回事，一个是数据结构，一个是操作系统中管理内存的一块区域分段。

1.堆的概念及结构

堆的性质：

堆中某个节点的值总是不大于或不小于其父节点的值；
堆总是一棵完全二叉树。

2.堆的实现

2.1建堆

给定一个数组,这个数组逻辑上可以看做一颗完全二叉树，但是还不是一个堆，这个时候就需要我们通过算法，把它构建成一个堆。根节点左右子树不是堆，我们从倒数的第一个非叶子节点的子树开始调整，一直调整到根节点的树，就可以调整成堆(向下调整)。

建堆时间复杂度：

因为堆是完全二叉树，而满二叉树也是完全二叉树，此处为了简化使用满二叉树来证明(时间复杂度本来看的就是近似值，多几个节点不影响最终结果)

根据上图可以推算出: 建堆的时间复杂度为O(N)。

2.2堆的插入与删除

堆插入

插入一个树到数组的尾上，再进行向上调整算法，直到满足堆.

堆删除

删除堆是删除堆顶的数据，将堆顶的数据根最后一个数据一换，然后删除数组最后一个数据，再进行向下调整算法。

2.3堆的向下调整算法

从堆顶开始,与子级节点进行比较,满足进行交换,一直到最后的叶子结点就结束.(公式:(n*2)+1),这里要注意的+1是找左1子树,+2是找右子树.(用于堆的删除操作)

2.4向上调整算法

拿到子结点的位置,根据子节点的下标索引(公式:(n-1)/2),找到父级,跟父级进行比较,若满足则进行交换,直到交换到根结点. (用于堆的插入操作)

3.堆代码实现

typedef int HeapDataType;
typedef struct Heap
{
  HeapDataType* a;
  int size;  //有效元素
  int cpciti; //容量
}HP;
//初始化
void HeapInit(HP* hp);
//销毁
void HeapDestroy(HP* hp);
// 堆的插入
void HeapPush(HP* hp, HeapDataType x);
// 堆的删除
void HeapPop(HP* hp);
// 取堆顶的数据
HeapDataType HeapTop(HP* hp);
// 堆的数据个数
int HeapSize(HP* hp);
// 堆的判空
int HeapEmpty(HP* hp);

void HeapInit(HP* hp)
{
  assert(hp);
  hp->a = NULL;
  hp->size = hp->cpciti = 0;
}
void HeapDestroy(HP* hp)
{
  assert(hp);
  free(hp->a);
  hp->a = NULL;
  hp->size = hp->cpciti = 0;
}
void HeapPrintf(HP* hp)
{
  assert(hp);
  assert(hp->size > 0);
  for (int i = 0; i < hp->size; i++)
  {
    printf("%d ", hp->a[i]);
  }
  printf("\n");
}
void Swap(HeapDataType* p1, HeapDataType* p2)
{
  HeapDataType tmp = *p1;
  *p1 = *p2;
  *p2 = tmp;
}
void AdjustUp(HeapDataType* a, int child)
{
  int parent = (child - 1) / 2;
  while (child > 0)
  {
    if (a[child] < a[parent])
    {
      Swap(&a[child], &a[parent]);
      child = parent;
      parent = (parent - 1) / 2;
    }
    else
    {
      break;
    }
  }
}
void HeapPush(HP* hp, HeapDataType x)
{
  assert(hp);
  //
  if (hp->size == hp->cpciti)
  {
    int newCapacity = hp->cpciti == 0 ? 4 : hp->cpciti * 2;
    HeapDataType* tmp = (HeapDataType*)realloc(hp->a, sizeof(HeapDataType) * newCapacity);
    if (tmp == NULL)
    {
      perror("realloc fail");
      exit(-1);
    }
    hp->a = tmp;
    hp->cpciti = newCapacity;
  }
  hp->a[hp->size] = x;
  hp->size++;
  AdjustUp(hp->a, hp->size-1);
}
void AdjustDown(HeapDataType* 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 HeapPop(HP* hp)
{
  assert(hp);
  assert(hp->size > 0);
  Swap(&hp->a[0], &hp->a[hp->size - 1]);
  hp->size--;
  AdjustDown(hp->a,hp->size,0);
}
HeapDataType HeapTop(HP* hp)
{
  assert(hp);
  assert(hp->size > 0);
  return hp->a[0];
}
int HeapSize(HP* hp)
{
  return hp->size;
}
int HeapEmpty(HP* hp)
{
  assert(hp);
  return hp->size == 0;
}

本期的内容就是以上这些啦，希望大家动动小手指，给博主一键三连，大家的支持是我前行的最大动力。