还在用老掉牙的冒泡排序吗？快试试堆排序吧！

---

前言

冒泡排序具有很强的局限性，在具体使用的时候并不方便

例如：冒泡排序的时间复杂度为O（N^2），也就代表着100w的数据，如果用冒泡排序的话，需要进行1w亿次

---

为了提高排序的速度，我们可以采用堆排序

一、堆排序的思路

利用堆的性质
大堆：每个结点的值都大于或等于其左右孩子结点的值
小堆 ：每个结点的值都小于或等于其左右孩子结点的值
将堆顶的元素保留起来，放在合理的位置
只要堆始终被维护这，那我们就一直可以获得堆中的最值
依次来进行排序
堆排序的时间复杂度为O(N*logN)

二、使用方法

1.利用现有的堆保存堆顶的数据

代码如下（示例）：

void HeapSort(int* a, int n)
{
    //在有现成的堆的情况
    //把数组导入堆中去
    //把pop堆顶出来的元素存到a里面
    
    HeapInit(&hp);
    
    for (int i = 0; i < n; i++)
    {
        //插入元素
        HeapPush(&hp, a[i]);
    }

    //将堆里面的数据再重新拷贝回数组中
    for (int i = 0; i < n; i++)
    {
        a[i] = HeapTop(&hp);
        HeapPop(&hp);
    }

//以下是建堆时需要的自定义函数
//堆的初始化
void HeapInit(Heap* hp)
{
    hp->_capacity = 4;
    hp->_size = 0;
    HPDataType* tmp = (HPDataType*)malloc(sizeof(HPDataType) * 4);
    if (!tmp)
    {
        perror("malloc");
        return;
    }
    hp->_a = tmp;
}

// 堆的插入
void HeapPush(Heap* hp, HPDataType x)
{
    assert(hp);
    AdjustCapacity(hp);
    //第一步插入
    hp->_a[hp->_size] = x;
    hp->_size++;
    //第二步调整
    AdjustUp(hp->_a, hp->_size - 1);
}


// 堆的删除
void HeapPop(Heap* hp)
{
    assert(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);
    if (HeapEmpty(hp))
    {
        return -1;
    }
    return hp->_a[0];
}

2.把原有的数组调整为堆，将top元素放数组尾

代码如下（示例）：

void HeapSort(int* a, int n)
{
    //当要调整的元素只剩一个时，就意味着调整完了
    while (n != 1)
    {
        //从最后一个叶子节点的父节点开始依次向下调整
        //调整顺序不断向上
        for (int i = (n - 1 - 1) / 2; i >= 0; i--)
        {
            AdjustDown(a, n, i);
        }
        Swap(&a[0], &a[n - 1]);
        n--;
    }
}
//以下是需要使用到的自定义函数
//交换两个元素
void Swap(HPDataType* a, HPDataType* b)
{
    HPDataType tmp = *a;
    *a = *b;
    *b = tmp;
}

//向下调整
void AdjustDown(int *a, int n, int parent)
{
    assert(a);
    int child = parent * 2 + 1;
    while (child < n)
    {
        if (a[child] > a[child + 1] && child + 1 < n)
        {
            child++;
        }

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

    }
}

---

总结

以上就是今天要讲的堆排序的内容，本文仅仅简单介绍了堆排序的使用，能够有效的解决排序速度慢的问题。