算法【排序】 | 堆排序（附图解、代码）

🎊 算法【排序】 | 桶排序（附图解、代码）
🎊 算法【排序】 | 堆排序（附图解、代码）
🎊 算法【排序】 | 快速排序 【荷兰问题】（附代码、图解）
🎊 算法【排序】 | 归并排序【排序、逆序对、小和问题】（附图解、代码）
🎊 算法【排序】 | 插入排序（附图解、代码）

一、简介

堆是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于(或者大于)它的父节点。堆排序可以说是一种利用堆的概念来排序的选择排序；

• 大顶堆：每个结点的值都大于或等于其左右孩子结点的值；
• 小顶堆：或者每个结点的值都小于或等于其左右孩子结点的值。

1.1 时间复杂度

构建时间复杂度：O(nlogn)；

1.2 空间复杂度

重建时间复杂度：O(1)；

1.3 优缺点

不适合待排序序列个数较少的情况。

二、过程

2.1 图解

需要满足根节点大于子节点；故每插入一个数据就需要与其父节点进行比较，若大于父节点，则进行交换；

形成大根堆

排序

取出第一个数据，将最后一个数据填充到第一个中，缩减数组长度；

2.2 代码

/*----------------------------------------------------------------------
	> File Name: heapSort.cpp
	> Author: Jxiepc
	> Mail: Jxiepc
	> Created Time: Fri 28 Jan 2022 07:55:56 AM CST
----------------------------------------------------------------------*/

#include <iostream>
#include <vector>

/**
 * 将数组先进行堆排序，在将头节点删除取最后一个数进行替换
 * 替换后在堆大于该结点的最大子节点替换，得到结果
 * */


/** 交换元素 */
void swap(std::vector<int>& vc, int L, int R) {

    int tmp = vc[L];
    vc[L] = vc[R];
    vc[R] = tmp;
}

/** 插入 */
void heapInsert(std::vector<int>& vc, int idx) {
    /* 判断插入结点与父节点的大小 */
    while(vc[idx] > vc[(idx-1) / 2]) {
        swap(vc, idx, (idx-1)/2);
        idx = (idx-1) / 2; // 将index切换到交换的位置，继续判断父节点
    }
}

/**  */
void heapify(std::vector<int>& vc, int idx, int hSize) {
    int l = idx * 2 + 1;    // 左孩子
    // 判断是否还有孩子
    while(l < hSize) {
        // 判断俩个孩子的大小
        int max = l + 1 < hSize && vc[l + 1] > vc[l] ? l + 1: l; // 判断左右孩子的大小 
        max = vc[max] > vc[idx] ? max : idx;        // 判断孩子与父的大小

        if(max == idx) 
            break;

        swap(vc, max, idx);
        idx = max;
        l = idx* 2 + 1;
    }
}

void heapSort(std::vector<int>& vc) {
    if(vc.size() < 2) {
        return;
    }

    /** 将数组变成大根堆 */
    for(int i=0; i<vc.size(); ++i) {
        heapInsert(vc, i);
    }
    std::cout << "形成大根堆：";
    for(auto& i:vc) 
        std::cout << i << " ";
    std::cout << std::endl;
    int heapSize = vc.size();
    /** 将数组第一个与最后一个交换 */
    swap(vc, 0, --heapSize);

    while(heapSize > 0) {
        heapify(vc, 0, heapSize);
        swap(vc, 0, --heapSize);
    }
}



int main(int argc, char* argv[])
{
    std::vector<int> vc;
    vc.push_back(6);
    vc.push_back(4);
    vc.push_back(1);
    vc.push_back(2);
    vc.push_back(5);
    vc.push_back(14);
    vc.push_back(11);
    vc.push_back(12);
    vc.push_back(15);
    heapSort(vc);
    std::cout << "排序结果:";
    for(auto& i:vc)
        std::cout << i << " ";
    std::cout << std::endl;

    return 0;
}