数据结构初阶——堆

树的概念及结构

在介绍堆之前，先来说一下树的概念及结构：

树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因****为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。

有一个特殊的结点，称为根结点，根节点没有前驱结点

除根节点外，其余结点被分成M(M>0)个互不相交的集合T1、T2、……、Tm，其中每一个集合Ti(1<= i <= m)又是一棵结构与树类似的子树。每棵子树的根结点有且只有一个前驱，可以有0个或多个后继因此，树是递归定义的。

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

节点的度：一个节点含有的子树的个数称为该节点的度； 如上图：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. 二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树

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

特殊的二叉树

1. 满二叉树：一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个二叉树的层数为K，且结点总数是，则它就是满二叉树。

2. 完全二叉树：完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。 要注意的是满二叉树是一种特殊的完全二叉树。

二叉树的性质

堆的概念及结构

堆的初始化与销毁

这里的堆是用数组实现的，和顺序表一样：

插入数据

因为只有插入数据的时候才需要考虑扩容的问题，所以就不用单写一个函数，直接写在插入函数中就可以了

数据虽然放了进去，但是只是放在了数组的最后一个位置上，那还是一个堆吗，那就得做一下调整： 向上调整

   插入到末尾已经做好了，接下来就是把数据一步一步向上调整，只要这个数据的父节点大于或者小于这个节点（这取决于是大堆还是小堆）就交换，交换完后，这个节点还要和它的父节点比较，直到成功改成堆或者这个节点变成了根节点。

删除堆顶的数据

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

把首尾的数据交换了之后就是向下调整，向下调整要找到子节点中较小或较大的数据(根据是小堆还是大堆而定)，第一个if判断的就是：先假设左子节点是较小的那个，再和右子节点比较，符合条件再++，这样child就是需要交换的下标，如果不符合child不变；还有一种情况就是这个节点只有左子节点，如果child+1不小于size就证明没有右子节点，也就不用++。

堆的其他功能

堆排序

   这里就比较重要了，之所以叫堆排序，是因为在堆的结构，不管是大堆还是小堆，极值一定是在堆顶，把堆顶的数据拿出来，再向下调整后还是一个堆，以此类推，把每个堆顶的数据重新放到数组中，这样就排好了。

   想要排升序还是降序是因向上调整和向下调整的条件决定的，所以 一定要看好这两个部分。

最后把a数组打印出来，堆排序就完成了。

如何建堆与时间复杂度

   那关于堆排序还有一个重要的点就是，我要是想使用堆排序，那就必须先要有一个堆，那就得写一个堆，那就得把上述的所有代码都写一遍，那可是很麻烦的。

再思考一下，上述的是如何建堆的，把数组中的数据依次拿出，向上调整建堆，建好后再把数据重新排到a数组中，那这其中的关键就是向上调整和向下调整。

第一种：向上调整建堆

直接调整数组，从第二个数据开始向上调整，把整个数组遍历完后堆就建好了。

第二种：向下调整建堆

   这是向下建堆的时间复杂度的推导过程，向上建堆的过程和这个差不多，思想是一样的，从复杂度看，向下建堆比向上建堆要快。

排序

堆既然建好了，那就该排序了。

如果想要排升序就要建大堆，想要排降序就要建小堆，为什么呢，等我介绍完就知道了。

TOP-K问题

   先申请一块空间来存放TOP-K的数据，需要几个k就申请k倍的数据内存；再把k个数据拷贝进去；建堆，上述说到向下建堆的时间复杂度小，TOP-K问题需要建小堆，只要a数组k个数据之后的数据比KMinHeap数组中的数据大，就覆盖进去，再调整，因为小堆中最小的数据在堆顶，正好是数组的首元素，调整完后的所有较大的数据都在后面；把所有数据都比较完了之后，KMinHeap中的k个数据就是需要的数据。最后不要忘了free掉malloc的内存。

    TOP-K问题所需要的数据还是根据需求来定的。

结语

这一节的堆使用数组的形式来完成的，下一节会介绍链式二叉树，总之都是树的性质。

那么堆的代码如下：

Heap.h文件

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>

typedef int HPDataType;

typedef struct HeapNode
{
    HPDataType* a;
    int size;
    int capacity;
}HP;

void Swap(HPDataType* p1, HPDataType* p2);
void HeapPrint(HP* php);
void HeapInit(HP* php);
void HeapDestroy(HP* php);
void HeapPush(HP* php, HPDataType x);
void HeapPop(HP* php);//删除堆顶的数据
HPDataType HeapTop(HP* php);//取堆顶的数据
bool HeapEmpty(HP* php);
int HeapSize(HP* php);
void AjustUp(HPDataType* a, int child);
void AjustDown(HPDataType* a, int size, int parent);
void Heapsort(HPDataType* a, HPDataType n);
void PrintTopK(HPDataType* a, int n, int k);

Heap.c文件

#define _CRT_SECURE_NO_WARNINGS 1
#include"Heap.h"

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

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

void HeapPrint(HP* php)
{
    assert(php);
    int i = 0;
    for (i = 0; i < php->size; i++)
    {
        printf("%d ", php->a[i]);
    }
    printf("\n");
}

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

void AjustUp(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(HP* php, HPDataType x)
{
    assert(php);
    if (php->capacity == php->size)
    {
        HPDataType newCapacity = php->capacity == 0 ? 4 : php->capacity * 2;
        HPDataType* tmp = (HPDataType*)realloc(php->a, sizeof(HPDataType) * newCapacity);
        if (tmp == NULL)
        {
            printf("realloc fail");
            exit(-1);
        }
        php->a = tmp;
        php->capacity = newCapacity;
    }
    php->a[php->size] = x;
    php->size++;

    AjustUp(php->a, php->size - 1);
}

void AjustDown(HPDataType* a, int size, int parent)
{
    int child = parent * 2 + 1;
    while (child < size)
    {
        if (child + 1 < size && 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* php)
{
    assert(php);
    assert(php->size > 0);
    Swap(&(php->a[0]), &(php->a[php->size - 1]));
    php->size--;

    AjustDown(php->a, php->size, 0);
}

HPDataType HeapTop(HP* php)//取堆顶的数据
{
    assert(php);
    assert(php->size > 0);
    return php->a[0];
}

bool HeapEmpty(HP* php)//堆的判空
{
    assert(php);
    return php->size == 0;
}

int HeapSize(HP* php)//堆的数据个数
{
    assert(php);
    return php->size;
}

//升序建大堆
//降序建小堆
void Heapsort(HPDataType* a, HPDataType n)
{
    //第一种建堆方式 时间复杂度O(N*logN)
    //for (int i = 1; i < n; i++)
    //{
    //    AjustUp(a, i);
    //}
    
    //第二种建堆方式 时间复杂度O(N)
    for (int i = (n - 1 - 1) / 2; i >= 0; i--)
    {
        AjustDown(a, n, i);
    }

    int end = n - 1;
    while (end > 0)
    {
        Swap(&a[end], &a[0]);
        AjustDown(a, end, 0);
        end--;
    }
}

void PrintTopK(HPDataType* a, int n, int k)
{
    int* KMinHeap = (int*)malloc(sizeof(int) * k);
    assert(KMinHeap);
    for (int i = 0; i < k; i++)
    {
        KMinHeap[i] = a[i];
    }
    for (int i = (n - 1 - 1) / 2; i >= 0; i--)
    {
        AjustDown(KMinHeap, k, i);
    }

    for (int j = k; j < n; j++)
    {
        if (KMinHeap[0] < a[j])
        {
            KMinHeap[0] = a[j];
            AjustDown(KMinHeap, k, 0);
        }
    }
    for (int i = 0; i < k; i++)
    {
        printf("%d ", KMinHeap[i]);
    }
    printf("\n");
    free(KMinHeap);
    KMinHeap = NULL;
}