数据结构~~二叉树-堆-阿里云开发者社区

一、基本概念

树的概念

树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。有一个特殊的结点，称为根结点，根节点没有前驱结点除根节点外，其余结点被分成M(M>0)个互不相交的集合T1、T2、……、Tm，其中每一个集合Ti(1<=i=M),又是一棵结构与树类似的子树。每棵子树的根结点有且只有一个前驱，可以有0个或多个后继因此，树是递归定义的。

树形结构中，子树之间不能有交集，否则就不是树形结构

1.2树的相关概念：

度节点的：一个节点含有的子树的个数称为该节点的度；如上图：A的为6

叶节点或终端节点：度为0的节点称为叶节点；如上图：B、C、H、I...等节点为叶节点

非终端节点或分支节点：度不为0的节点；如上图：D、E、F、G...等节点为分支节点

双亲节点或父节点：若一个节点含有子节点，则这个节点称为其子节点的父节点；如上图：A是B的父节点

孩子节点或子节点：一个节点含有的子树的根节点称为该节点的子节点；如上图：B是A的孩子节点

兄弟节点：具有相同父节点的节点互称为兄弟节点；如上图：B、C是兄弟节点

树的度：一棵树中，最大的节点的度称为树的度；如上图：树的度为6

节点的层次：从根开始定义起，根为第1层，根的子节点为第2层，以此类推；

树的高度或深度：树中节点的最大层次；如上图：树的高度为4

堂兄弟节点：双亲在同一层的节点互为堂兄弟；如上图：H、I互为兄弟节点

节点的祖先：从根到该节点所经分支上的所有节点；如上图：A是所有节点的祖先

子孙：以某节点为根的子树中任一节点都称为该节点的子孙。如上图：所有节点都是A的子孙

森林：由m（m>0）棵互不相交的树的集合称为森林；

二叉树-堆的概念

一棵二叉树是结点的一个有限集合，该集合: 1. 或者为空 2. 由一个根节点加上两棵别称为左子树和右子树的二叉树组成

从上图可以看出：1. 二叉树不存在度大于2的结点 2. 二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树

对于任意的二叉树都是由以下几种情况复合而成的：

2.二叉树的性质

1. 若规定根节点的层数为1，则一棵非空二叉树的第i层上最多有个结点.

2. 若规定根节点的层数为1，则深度为h的二叉树的最大结点数是 .

3. 对任何一棵二叉树, 如果度为0其叶结点个数为 , 度为2的分支结点个数为 ,则有＝＋1

4. 若规定根节点的层数为1，具有n个结点的满二叉树的深度，h= . (ps：是log以2 为底，n+1为对数)

5. 对于具有n个结点的完全二叉树，如果按照从上至下从左至右的数组顺序对所有节点从0开始编号，则对于序号为i的结点有：

1. 若i>0，i位置节点的双亲序号：(i-1)/2；i=0，i为根节点编号，无双亲节点

2. 若2i+1，左孩子序号：2i+1，2i+1>=n否则无左孩子

3. 若2i+2，右孩子序号：2i+2，2i+2>=n否则无右孩子

3.堆的概念

如果有一个关键码的集合K = { ，，，…， }，把它的所有元素按完全二叉树的顺序存储方式存储在一个一维数组中，并满足：且 = 且 >= ) i = 0，1， 2…，则称为小堆(或大堆)。将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。堆的性质：堆中某个节点的值总是不大于或不小于其父节点的值；堆总是一棵完全二叉树。

二、堆的结构

typedef int HPDateType;
typedef struct Heap
{
  HPDateType* a;  
  int size;
  int capacity;
}HP;

初始化堆

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

摧毁堆

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

向上调整

void AdjustUP(HPDateType* a, int child)
{
  int parent = (child - 1) / 2;
  while (child>0)
  {
    if (a[parent] > a[child])
    {
      HPDateType tmp = a[child];
      a[child] = a[parent];
      a[parent] = tmp;
 
      child = parent;
      parent = (child - 1) / 2;
    }
    else
    {
      break;
    }
  }
}

向下调整

void AdjustDown(int* 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[parent],&a[child]);
      parent = child;
      child = parent * 2 + 1;
    }
    else
    {
      break;
    }
  }
}

插入数据

void HeapPush(HP* php, HPDateType x) 
{
  assert(php);
  if (php->size == php->capacity)
  {
    int newCapacity = php->capacity == 0 ? 4 : php->capacity * 2;
    HPDateType* tmp = (HPDateType*)realloc(php->a, newCapacity * sizeof(HPDateType));
    if (tmp == NULL)
    {
      perror("realloc err");
      return;
    }
    php->a = tmp;
    php->capacity = newCapacity;
  }
  php->a[php->size] = x;
  php->size++;
  AdjustUP(php->a,php->size-1);
}

删除数据

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

获取堆顶元素

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

判断堆是否为空

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

获取堆的长度

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

三、堆排序

向上调整建堆

1.升序建大堆

// 对数组进行堆排序
void AdjustUP(HPDateType* a, int child)
{
  int parent = (child - 1) / 2;
  while (child>0)
  {
    if (a[parent] > a[child])
    {
      HPDateType tmp = a[child];
      a[child] = a[parent];
      a[parent] = tmp;
 
      child = parent;
      parent = (child - 1) / 2;
    }
    else
    {
      break;
    }
  }
}
void HeapSort(int* a, int n)
{
  //建堆小堆
  for (int i = 1; i < n; i++)
  {
    AdjustUP(a, i);
  }
  int end = n - 1;
  //排序升序
  while (end > 0)
  {
    Swap(&a[0],&a[end]);
    AdjustDown(a, end, 0);
    end--;
  }
}
void test()
{
  int arr[] = { 58,5,28,95,62,65,89,85,61,88,90,78,86,87 ,236,1 };
  HeapSort(arr, sizeof(arr) / sizeof(arr[0]));
  for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
  {
    printf("%d ",arr[i]);
  }
}
int main()
{
   test();
}

建堆后：

排序后：

2.降序建小堆

// 对数组进行堆排序
void AdjustDown(int* 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[parent],&a[child]);
      parent = child;
      child = parent * 2 + 1;
    }
    else
    {
      break;
    }
  }
}
void AdjustUP(HPDateType* a, int child)
{
  int parent = (child - 1) / 2;
  while (child>0)
  {
    if (a[parent] > a[child])
    {       //控制建大小堆
      HPDateType tmp = a[child];
      a[child] = a[parent];
      a[parent] = tmp;
 
      child = parent;
      parent = (child - 1) / 2;
    }
    else
    {
      break;
    }
  }
}
void HeapSort(int* a, int n)
{
  for (int i = 1; i < n; i++)
  {
    AdjustUP(a, i);
  }
  int end = n - 1;
  while (end > 0)
  {
    Swap(&a[0], &a[end]);
    AdjustDown(a, end, 0);
    end--;
  }
}
void test()
{
  int arr[] = { 58,5,28,95,62,65,89,85,61,88,90,78,86,87 ,236,1 };
  HeapSort(arr, sizeof(arr) / sizeof(arr[0]));
  for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
  {
    printf("%d ",arr[i]);
  }
}
int main()
{
   test();
}

建堆后 :

排序后：

向下调整建堆

void AdjustDown(int* 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[parent],&a[child]);
      parent = child;
      child = parent * 2 + 1;
    }
    else
    {
      break;
    }
  }
}
void HeapSort(int* a, int n)
{
  for (int i = (n - 1 - 1) / 2; i >= 0; i--)
  {
    AdjustDown(a, n, i);
  }
  int end = n - 1;
  while (end > 0) //n*logn
  {
    Swap(&a[0], &a[end]);
    AdjustDown(a, end, 0);
    end--;
  }
}
void test()
{
  int arr[] = { 58,5,28,95,62,65,89,85,61,88,90,78,86,87 ,236,1 };
  HeapSort(arr, sizeof(arr) / sizeof(arr[0]));
  for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
  {
    printf("%d ", arr[i]);
  }
}
int main()
{ 
    test();
}

建堆：

排序后：

向上调整建堆和向下调整建堆的时间复杂度有所不同。

向上调整建堆的时间复杂度为。O(N*logN)

向下调整建堆的时间复杂度为。O(N)

在实际应用中，通常采用向下调整建堆的方式，因为它的时间复杂度较低。但在某些特定情况下，向上调整建堆也可能会被使用。

四、TOP-K

思路：

topk 问题是指在一组数据中，找出前 k 个最大或最小的元素。以下是解决 topk 问题的思路和算法：

建立最小堆或最大堆：使用堆数据结构来解决 topk 问题。可以先建立一个大小为 k 的最小堆或最大堆，然后依次将剩余的元素与堆顶元素进行比较。如果元素大于或小于堆顶元素，则将其替换堆顶元素，并重新调整堆。最后，堆中的元素就是前 k 个最大或最小的元素。这种方法的时间复杂度为O(NlogK)

当N远比K大是时间复杂度为O(N)

在实际应用中，需要根据具体情况选择合适的算法来解决 topk 问题。如果数据量较小，可以使用简单的排序算法或堆算法

typedef int HPDateType;
void Swap(HPDateType* p1, HPDateType* p2)
{
  HPDateType tmp = *p1;
  *p1 = *p2;
  *p2 = tmp;
}
//向下调整
void AdjustDown(int* 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[parent], &a[child]);
      parent = child;
      child = parent * 2 + 1;
    }
    else
    {
      break;
    }
  }
}
void CreateNDate()
{
  // 造数据
  int n = 10000;
  srand(time(0));
  const char* file = "data.txt";
  FILE* fin = fopen(file, "w");
  if (fin == NULL)
  {
    perror("fopen error");
    return;
  }
 
  for (size_t i = 0; i < n; ++i)
  {
    int x = (rand()+i) % 1000000;
    fprintf(fin, "%d\n", x);
  }
 
  fclose(fin);
}
 
void PrintTopK()
{
  int k = 0;
  printf("请输入k的值:");
  scanf("%d", &k);
  int* kminheap = (int*)malloc(sizeof(int) * k);
  if (kminheap == NULL)
  {
    perror("malloc file");
    return;
  }      
  const char* file = "data.txt";
  FILE* fout = fopen(file, "r");
  if (fout == NULL)
  {
    perror("fopen error");
    return;
  }
  for (int i = 0; i < k; i++)  //写前k个数据
  {
    fscanf(fout,"%d", &kminheap[i]);
  }
             //最后的结点的根
  for (int i = (k - 1 - 1) / 2; i >= 0; i--)  //建堆
  {
    AdjustDown(kminheap,k,i);
  }
  int x = 0;
  while (fscanf(fout,"%d", &x) > 0)
  {
    if (x > kminheap[0])
    {
      kminheap[0] = x;
      AdjustDown(kminheap,k,0);
    }
  }
  printf("最大的前k个是：");
  for (int i = 0; i < k; i++)
  {
    printf("%d ",kminheap[i]);
  }
}
int main()
{
    CreateNDate();
  PrintTopK();
}

void CreateNDate()在这个函数生成完一百万个数据时可以在手动添加最大数据，检查代码是否正确

五、完整代码

Heap.h

#include<assert.h>
#include<stdbool.h>
typedef int HPDateType;
typedef struct Heap
{
  HPDateType* a;
  int size;
  int capacity;
}HP;
 
 
void HeapInit(HP* php);//初始化堆
void HeapDestroy(HP* php);//摧毁堆
 
void HeapPush(HP* php,HPDateType x);//插入堆
void HeapPop(HP* php);//删除堆
 
HPDateType HeapTop(HP* php);//获取堆顶的元素
bool HeapEmpty(HP* php);//堆是否为空
int HeapSize(HP* php);//堆的长度
 
void AdjustDown(int* a, int n, int parent);//向下调整
void AdjustUP(HPDateType* a, int child);//向上调整

Heap.c

#include"Heap.h"
 
void HeapInit(HP* php)
{
  assert(php);
  php->a = NULL;
  php->capacity = 0;
  php->size = 0;
}
void Swap(HPDateType* p1, HPDateType* p2)
{
  HPDateType tmp = *p1;
  *p1 = *p2;
  *p2 = tmp;
}
void HeapDestroy(HP* php)
{
  assert(php);
  free(php->a);
  php->a = NULL;
  php->capacity = php->size = 0;
}
void AdjustDown(int* 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[parent],&a[child]);
      parent = child;
      child = parent * 2 + 1;
    }
    else
    {
      break;
    }
  }
}
void AdjustUP(HPDateType* a, int child)
{
  int parent = (child - 1) / 2;
  while (child>0)
  {
    if (a[parent] > a[child])
    {
      HPDateType tmp = a[child];
      a[child] = a[parent];
      a[parent] = tmp;
 
      child = parent;
      parent = (child - 1) / 2;
    }
    else
    {
      break;
    }
  }
}
void HeapPush(HP* php, HPDateType x) 
{
  assert(php);
  if (php->size == php->capacity)
  {
    int newCapacity = php->capacity == 0 ? 4 : php->capacity * 2;
    HPDateType* tmp = (HPDateType*)realloc(php->a, newCapacity * sizeof(HPDateType));
    if (tmp == NULL)
    {
      perror("realloc err");
      return;
    }
    php->a = tmp;
    php->capacity = newCapacity;
  }
  php->a[php->size] = x;
  php->size++;
  AdjustUP(php->a,php->size-1);
}
void HeapPop(HP* php)
{
  assert(php);
  assert(!HeapEmpty(php));
  Swap(&php->a[0], &php->a[php->size-1]);
  php->size--;
  AdjustDown(php->a,php->size,0);
 
}
HPDateType HeapTop(HP* php)
{
  assert(php);
  assert(!HeapEmpty(php));
  return php->a[0];
}
bool HeapEmpty(HP* php)
{
  assert(php);
  return php->size == 0;
}
int HeapSize(HP* php)
{
  assert(php);
  assert(!HeapEmpty(php));
  return php->size;
}

六、总结

二叉树堆是一种特殊的二叉树，它具有以下性质：

1. 堆中某个节点的值总是不大于或不小于其父节点的值：如果父节点的值大于子节点的值，那么这是一个大顶堆；如果父节点的值小于子节点的值，那么这是一个小顶堆。

2. 堆总是一棵完全二叉树：即除了最后一层可能有部分节点空缺外，其他层的节点都是满的。

二叉树堆可以使用数组来存储，通过维护节点的父子关系和堆的性质，可以实现堆的基本操作，如插入、删除和排序等。常见的堆操作包括：

1. 建堆：将一个数组构建成堆。

2. 堆调整：在插入或删除节点后，对堆进行调整，以保持堆的性质。

3. 堆排序：利用堆的性质进行排序。

二叉树堆在很多领域都有广泛的应用，例如：

1. 优先队列：可以用于实现优先队列，按照优先级对元素进行排序和访问。

2. 数据筛选：从大量数据中快速筛选出前个最大或最小的元素。

3. 图的遍历：在某些图算法中，可以使用堆来优化遍历过程。

数据结构~~二叉树-堆

一、基本概念

树的概念

二叉树-堆的概念

二、堆的结构

三、堆排序

向上调整建堆

向下调整建堆

四、TOP-K

五、完整代码

六、总结

热门文章

最新文章

相关课程

相关电子书