数据结构笔记_简单版

ref：漫画算法+ github/huihui

目录

• 第1章、算法概述
  • 1.1 算法复杂度
• 第2章、数据结构基础
  • 2.1 数组
  • 2.2 链表
  • 2.3 栈和队列
    • 2.3.1 栈
    • 2.3.2 队列
    • 2.3.3 循环队列
  • 2.4 散列表
• 第3章、树
  • 3.1二叉树
  • 3.2 二叉树定理
  • 3.3 二叉树遍历
    • 递归版
    • 迭代版
    • 更简单的非递归
  • 3.4 二叉堆
• al-tree-2
  • 插入节点
  • 删除节点
  • 建堆
  • 复杂度
• 第4章、排序
  • 1.插入排序
    • 代码
    • 性能
  • 2.冒泡排序
    • 优化
    • 代码
    • 性能
  • 3.选择排序
    • 代码
    • 性能
    • 优化
  • 4.shell排序
    • 代码
    • 性能
  • 5.快速排序
    • 代码
    • 性能
    • 优化
  • 6.归并排序
    • 代码
    • 性能
    • 优化
  • 7.堆排序
    • 代码
    • 性能

第1章、算法概述

1.1 算法复杂度

时间复杂度按照从低到高的顺序，包括O(1)、O(logn)、O(n)、O(nlogn)、O(n2)等。

空间复杂度按照从低到高的顺序，包括O(1)、O(n)、O(n2)等。其中递归算法的空间复杂度和递归深度成正比。

第2章、数据结构基础

2.1 数组

随机访问；插入、删除元素都会导致大量元素被迫移动，影响效率。

2.2 链表

链表（linked list）是一种在物理上非连续、非顺序的数据结构，由若干节点（node）所组成。

查找节点，只能从头节点开始向逐节点查找。

更新节点

插入节点

尾插

头插

中间

删除元素

2.3 栈和队列

2.3.1 栈

2.3.2 队列

2.3.3 循环队列

（队尾下标+1）%数组长度 = 队头下标时，代表此队列满。队尾指针指向的位置永远空出1位，所以队列最大容量比数组长度小1。

//入队
if((rear+1)%length == front){
	//" 队列已满！";
}
array[rear] = element;
rear = (rear+1) % length;

//出队
if(rear == front){
//" 队列已空！";
}
front = (front+1) % length;

2.4 散列表

也叫作哈希表（hash table），这种数据结构提供了键（Key）和值（Value）的映射关系。只要给出一个Key，就可以高效查找到它所匹配的Value，时间复杂度接近于O(1)。

解决哈希冲突的方法主要有两种，一种是开放寻址法，一种是链表法。

• 开放寻址法的原理很简单，当一个Key通过哈希函数获得对应的数组下标已被占用时，我们可以“另谋高就”，寻找下一个空档位置。
• 当新来的Entry映射到与之冲突的数组位置时，只需要插入到对应的链表中即可。

扩容

1．扩容，创建一个新的Entry空数组，长度是原数组的2倍。
2．重新Hash。

HashMap.Size >= Capacity×LoadFactor

第3章、树

3.1二叉树

• 满二叉树（下图左）：除叶子节点外的所有分支节点都含有2个非空子节点的二叉树
• 完全二叉树（下图右）：除了最后一层，其余层都是“满”的，这样的二叉树是完全二叉树
• 二叉排序树：根节点的值大于其左子树中任意一个节点的值,小于其右节点中任意一节点的值。

3.2 二叉树定理

1）任意二叉树，度数为2的节点个数等于叶节点数减1。

当只有1个节点时，度为0。每派生出1度，就会多出1个节点。派生出的度和派生出的节点数一定相等。

节点总数 = 总度数 + 1设度数为2的节点数为X2，度数为1的节点数为X1，度数为0的节点数为X0。可以得出如下关系式：

X2 + X1 + X0 = 2X2 + X1 + 1，推出 X2 = X0 - 1

2）满二叉树定理：非空满二叉树的叶节点数等于其分支节点数加1。

对于只有1个节点的树，该定理成立。从这开始思考，每产生1个分支节点(度数为2)。叶子节点数也会加1。

3）一颗非空二叉树空子树的数目等于其节点数目加1。

考虑只有1个根节点的二叉树：它有2个空子树，1个节点，因此结论成立。从这里开始考虑，每产生1个节点。空子树便会先减1然后加2。

• 父节点的下标是parent，那么它的左孩子节点下标就是2×parent + 1；右孩子节点下标就是2×parent + 2。
• 左孩子节点的下标是leftChild，那么它的父节点下标就是（leftChild-1）/ 2
• 显然，对于一个稀疏的二叉树来说，用数组表示法是非常浪费空间的。

3.3 二叉树遍历

• 前序遍历：根->左->右

• 中序遍历：左->根->右

• 后序遍历：左->右->根

• 层次遍历：按层次从左到右依次遍历每层中的结点。

• //        3
  //       / 
  //     9    20
  //    /    / 
  //   N   N 15  7
  //前序遍历序列{3,9,20,15,7}
  //中序遍历序列{9,3,15,20,7}
  //后续遍历序列{9,15,7,20,3}
  

struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};

递归版

void InOrder(TreeNode *node)；  //中序遍历
void PostOrder(TreeNode *node)；//后序遍历
void PreOrder(TreeNode *pRoot) //前遍历
{
    if (pRoot == nullptr)
        return;
    std::cout << pRoot->val << " ";
    PreorderTraverse(pRoot->left);
    PreorderTraverse(pRoot->right);
}

迭代版

//前序遍历
void preorderTraversalIteration(TreeNode *root)
{
    stack<TreeNode*> st;
    if(root)
        st.push(root);

    while(!st.empty()){
        TreeNode *nd = st.top();
        st.pop();

        cout << nd->val << " ";//操作当前节点

        if(nd->right)
            st.push(nd->right); //栈
        if(nd->left)
            st.push(nd->left);
    }
}

//中序遍历：
void inorderTraversalIteration(TreeNode *root)
{
    stack<TreeNode*> st;

    TreeNode *curr = root;

    while(curr || !st.empty()){
        if(curr){
            st.push(curr);
            curr = curr->left;
        }
        else{
            curr = st.top();
            st.pop();

            cout << curr->val << " ";//操作当前节点

            curr = curr->right;
        }
    }
}

//后序遍历
void postorderTraversalIteration(TreeNode *root)
{
    stack<TreeNode*> st;
    TreeNode *pre;

    if(root)
        st.push(root);

    while(!st.empty()){
        TreeNode *nd = st.top();
        /*
         * 出栈条件：
         * 对于叶子节点：直接弹出
         * 对于非叶子节点：如果已经遍历过其左子节点或右子节点，则弹出
         */
        if((!nd->left && !nd->right) || (pre && (nd->left == pre || nd->right == pre))){
            st.pop();
            cout << nd->val <<" ";//操作当前节点
            pre = nd;
        }
        else{//说明是一个非叶子节点，并且还未访问其左右孩子
            if(nd->right)
                st.push(nd->right);//栈
            if(nd->left)
                st.push(nd->left);
        }
    }
}

更简单的非递归

//更简单的非递归前序遍历       根，左，右 用栈（反序）
void preOrder(TreeNode *root, std::vector<int> &path)
{
    std::stack<std::pair<TreeNode *, bool> > tmpStack;
    bool isVisited = false;
    tmpStack.push(make_pair(root, isVisited));

    while(!tmpStack.empty())
    {
        root = tmpStack.top().first;
        isVisited = tmpStack.top().second;
        tmpStack.pop();
        if(root == nullptr)
            continue;
        if(isVisited)
        {
            path.push_back(root->val);
        }
        else//用栈（反序）
        {
//            //前序
//            tmpStack.push(make_pair(root->right, false));      //右
//            tmpStack.push(make_pair(root->left, false));       //左
//            tmpStack.push(make_pair(root, true));              //根

//            //中序
//            tmpStack.push(make_pair(root->right, false));      //右
//            tmpStack.push(make_pair(root, true));              //根
//            tmpStack.push(make_pair(root->left, false));       //左

            //后序
            tmpStack.push(make_pair(root, true));              //根
            tmpStack.push(make_pair(root->right, false));      //右
            tmpStack.push(make_pair(root->left, false));       //左
        }
    }
}

void LevelOrder(TreeNode *T){
    std::queue<TreeNode*> tmpQueue;          
    if (T == nullptr){
        return;
    }
    tmpQueue.push(T);
    
    TreeNode *tmpNode = new TreeNode(-1);    
    while (!tmpQueue.empty()){
        tmpNode = tmpQueue.front();
        cout << tmpNode->val<<" ";//输出
        tmpQueue.pop();
        if (tmpNode->left){
            tmpQueue.push(tmpNode->left);
        }
        if (tmpNode->right){
            tmpQueue.push(tmpNode->right);
        }
    }
}

3.4 二叉堆

堆是一棵完全二叉树，使用数组实现堆，堆分为两种：

• 最大堆：父节点大于任意子节点（因此堆顶为最大值）
• 最小堆：父节点小于任意子节点（因此堆顶为最小值）

对于第i个节点（i从0开始计数）：

• 父节点：(i-1)/2
• 左子节点：2i+1
• 右子节点：2i+2

若包含sz个节点，则第一个非叶子节点的序号为(sz - 2) / 2

插入节点

1. 将元素添加到数组末尾；（相当于叶节点接入堆中）
2. 和父节点进行比较，如果大于父节点(以最大堆为例)，则与父节点交换，一直比较交换到根节点

/********************************************
* 向堆中插入元素
*  hole：新元素所在的位置
********************************************/
template <class value>
void _push_heap(vector<value> &arr,int hole){
   value v = arr[hole]; //取出新元素，从而产生一个空洞
   int parent = (hole - 1) / 2;
   //建最大堆，如果建最小堆换成 arr[parent] > value
   while(hole > 0 && arr[parent] < v){
       arr[hole] = arr[parent];
       hole = parent;
       parent = (hole - 1) / 2;
   }
   arr[hole] = v;
} 

删除节点

删除实际上是将堆顶元素移入数组末尾，并不是真的删除。删除节点时，进行下列操作：

1. 保存数组末尾元素(存如临时变量v)，将堆顶元素存入数组末尾
2. 将原来堆顶元素的两个子节点中较大的一个移入堆顶(以最大堆为例)，填补空缺，此时产生新的空缺，继续此步骤，直到空缺为一个叶子节点
3. 将v中存储的值移到空缺叶子节点的位置
4. 对上一步中的新叶子节点完成向上比较交换操作

/********************************************
 * 删除堆顶元素
 ********************************************/
template <class value>
void _pop_heap(vector<value> &arr,int sz)
{
    value v = arr[sz - 1];
    arr[sz - 1] = arr[0];
    --sz;
    int hole = 0;
    int child = 2 * (hole + 1); //右孩子
    while(child < sz){
        if(arr[child] < arr[child - 1])
            --child;
        arr[hole] = arr[child];
        hole = child;
        child = 2 * (hole + 1);
    }
    if(child == sz){
        arr[hole] = arr[child - 1];
        hole = child - 1;
    }
    arr[hole] = v;
    _push_heap(arr,hole);
}

建堆

• 堆的大小固定(且所有元素已知)：按“序号从大到小”的顺序遍历所有非叶子节点，将这些节点与左右子节点较大者(以最大堆为例)交换，执行siftdown一直到叶子节点，因此，每遍历到一个节点时，其左子树和右子树都已经是最大堆，只需对当前节点执行siftdown操作
• 堆的大小未知(如数据流)：可以通过插入操作来构建堆

/********************************************
 * 建堆
 *  sz：删除堆顶元素后的大小
 *  v： 被堆顶元素占据的位置原来的元素的值
 ********************************************/
template <class value>
void _make_heap(vector<value> &arr)
{
    int sz = arr.size();
    int parent = (sz - 2) / 2;
    while(parent >= 0){
        int hole = parent;
        int child = 2 * (hole + 1); //右孩子
        value v = arr[hole];
        while(child < sz){
            if(arr[child] < arr[child - 1])
                --child;
            arr[hole] = arr[child];
            hole = child;
            child = 2 * (hole + 1);
        }
        if(child == sz){
            arr[hole] = arr[child - 1];
            hole = child - 1;
        }
        arr[hole] = v;
        _push_heap(arr,hole);
        --parent;
    }
}

复杂度

• 插入节点：时间复杂度为O(logn)
• 删除堆顶：时间复杂度为O(logn)
• 建堆：
  • 堆的大小固定(且所有元素已知)：每个siftdown操作的最大代价是节点被向下移动到树底的层数。在任意一棵完全二叉树中，大约有一半的节点是叶节点，因此不需要向下移动。四分之一的节点在叶节点的上一层，这样的节点最多只需要移动一层。每向上一层，节点的数目就为前一层的一般，而子树高度加1，因此移动层数加一。时间复杂度为O(n)
  • 堆的大小未知(如数据流)：由于插入节点的时间代价为O(logn)，对于n个元素，每个执行一次插入操作，所以时间复杂度为O(nlogn)

void UpAdjust(){
    int childIndex = array.size() - 1;
    int parentIndex = (childIndex - 1) / 2;
    const int temp = array.back();
    while (childIndex > 0 && temp > array[parentIndex]){
        array[childIndex] = array[parentIndex];
        childIndex = parentIndex;
        parentIndex = (childIndex - 1) / 2;
    }
    array[childIndex] = temp;
}
void DownAdjust(){
    int parentIndex = 0;
    int childIndex = 2 * parentIndex + 1;
    const int temp = array.front();
    while (childIndex < array.size()){
        // 找到左右孩子中的最大值
        if (childIndex + 1 < array.size() && array[childIndex + 1] > array[childIndex]){
            ++childIndex;
        }
        if (temp >= array[childIndex]){
            break;
        }
        else{
            array[parentIndex] = array[childIndex];
            parentIndex = childIndex;
            childIndex  = 2 * parentIndex + 1;
        }
    }
    array[parentIndex] = temp;
}

#include <iostream>
#include <algorithm>
#include <functional>
#include <vector>
int main()
{
    std::cout << "Max heap:
";

    std::vector<int> v { 3, 2, 4, 1, 5, 9 };

    std::cout << "initially, v: ";
    for (auto i : v) std::cout << i << ' ';
    std::cout << '
';

    std::make_heap(v.begin(), v.end(), std::less<int>{});
    std::cout << "make_heap, v: ";
    for (auto i : v) std::cout << i << ' ';
    std::cout << '
';

    v.push_back(6);
    std::push_heap(v.begin(), v.end());

    std::cout << "push_heap, v: ";
    for (auto i : v) std::cout << i << ' ';
    std::cout << '
';

    std::pop_heap(v.begin(), v.end());
    v.pop_back();

    std::cout << "pop_heap, v: ";
    for (auto i : v) std::cout << i << ' ';
    std::cout << '
';

}

第4章、排序

• 内排序
  • 1.插入排序（稳定）
  • 2.冒泡排序（稳定）
  • 3.选择排序（不稳定）
  • 4.shell排序（不稳定）
  • 5.快速排序（不稳定）
  • 6.归并排序（稳定）
  • 7.堆排序（不稳定）
• 外排序
  • 1.多路归并

稳定性：相同的元素在排序前和排序后的前后位置是否发生改变，没有改变则排序是稳定的，改变则排序是不稳定的 ——八大排序算法的稳定性

1.插入排序

逐个处理待排序的记录，每个记录与前面已排序已排序的子序列进行比较，将它插入子序列中正确位置

代码

template<class T>
void inssort(T A[],int len)
{
    cout <<__func__ << endl;
    
    for(int left = 1; left < len; left++){
        T tp = A[left];//待插入元素

        int right = left;
        for(; right >= 1 && tp < A[right-1]; right--)//有序
            A[right] = A[right - 1];//赋值，非交换
        A[right] = tp;
    }
}

性能

• 最佳：升序。时间复杂度为O(n)
• 最差：降序。时间复杂度为O(n^2)
• 平均：对于每个元素，前面有一半元素比它大。时间复杂度为O(n^2)

如果待排序数据已经“基本有序”，使用插入排序可以获得接近O(n)的性能

2.冒泡排序

从数组的底部比较到顶部，比较相邻元素。如果下面的元素更小则交换，否则，上面的元素继续往上比较。这个过程每次使最小元素像个“气泡”似地被推到数组的顶部

优化

1. 从后往前循环，若前者大于后者，则交换数据，这样能够使其他的数往前排。
2. 设置标志数，如果所有元素已经是有序的了，可以避免执行不必要的循环。

代码

template<class T>
void bubsort(T A[],int len)
{
    bool isSored = true;
    for(int left = 0;   left < len - 1 && isSored;  left++){//前-》后 isSored优化
        isSored = false;
        for(int right = len - 1;  right > left; right--){//后-》前
            if(A[right] < A[right-1]){
                swap(A[right],A[right-1]);
                isSored = true;
            }
        }
    }
}

性能

冒泡排序是一种相对较慢的排序，没有较好的最佳情况执行时间。通常情况下时间复杂度都是O(n^2)

3.选择排序

第i次“选择”数组中第i小的记录，并将该记录放到数组的第i个位置。换句话说，每次从未排序的序列中找到最小元素，放到未排序数组的最前面

代码

template<class T>
void selsort(T A[],int len)
{
    cout <<__func__ << endl;
    for(int left = 0;left < len - 1;left++){

        int right = len - left -1;
        int lowindex = left;
        int maxindex = right;

        for(int right = len - left -1;right > left;right--){
            if(A[right] > A[maxindex])//maxindex
                maxindex = right;
            if(A[right] < A[lowindex])//lowindex
                lowindex = right;
        }
        swap(A[left],A[lowindex]);
        swap(A[right],A[maxindex]);
    }
}

性能

不管数组是否有序，在从未排序的序列中查找最小元素时，都需要遍历完最小序列，所以时间复杂度为O(n^2)

优化

每次内层除了找出一个最小值，同时找出一个最大值（初始为数组结尾）。

4.shell排序

shell排序在不相邻的元素之间比较和交换。利用了插入排序的最佳时间代价特性，它试图将待排序序列变成基本有序的，然后再用插入排序来完成排序工作

在执行每一次循环时，Shell排序把序列分为互不相连的子序列，并使各个子序列中的元素在整个数组中的间距相同，每个子序列用插入排序进行排序。每次循环增量是前一次循环的1/2，子序列元素是前一次循环的2倍

最后一轮将是一次“正常的”插入排序（即对包含所有元素的序列进行插入排序）

代码

const int INCRGAP = 3;

template<class Elem>
void shellsort(Elem A[],int n)
{
    for(int incr = n / INCRGAP;incr > 0;incr /= INCRGAP){//遍历所有增量大小
        for(int i = 0;i < incr;i++){
            /*对子序列进行插入排序，当增量为1时，对所有元素进行最后一次插入排序*/
            for(int j = i + incr;j < n;j += incr){
                for(int k = j; k > i && A[k] < A[k - incr];k -= incr){
                    swap(A,k,k - incr);
                }
            }
        }
    }
}

性能

选择适当的增量序列可使Shell排序比其他排序法更有效，一般来说，增量每次除以2时并没有多大效果，而“增量每次除以3”时效果更好

当选择“增量每次除以3”递减时，Shell排序的平均运行时间是O(n^(1.5))

5.快速排序

首先选择一个轴值，小于轴值的元素被放在数组中轴值左侧，大于轴值的元素被放在数组中轴值右侧，这称为数组的一个分割(partition)。快速排序再对轴值左右子数组分别进行类似的操作

选择轴值有多种方法。最简单的方法是使用首或尾元素。但是，如果输入的数组是正序或者逆序时，会将所有元素分到轴值的一边。较好的方法是随机选取轴值

代码

template <class Elem>
int partition(Elem A[],int i,int j)
{
    //这里选择尾元素作为轴值,轴值的选择可以设计为一个函数
    //如果选择的轴值不是尾元素，还需将轴值与尾元素交换
    int pivot = A[j];
    int l = i - 1;
    for(int r = i;r < j;r++)
        if(A[r] <= pivot)
            swap(A,++l,r);
    swap(A,++l,j);//将轴值从末尾与++l位置的元素交换
    return l;
}

template <class Elem>
void qsort(Elem A[],int i,int j)
{
    if(j <= i)  return;
    int p = partition<Elem>(A,i,j);
    qsort<Elem>(A,i,p - 1);
    qsort<Elem>(A,p + 1,j);
}

性能

• 最佳情况：O(nlogn)
• 平均情况：O(nlogn)
• 最差情况：每次处理将所有元素划分到轴值一侧，O(n^2)

快速排序平均情况下运行时间与其最佳情况下的运行时间很接近，而不是接近其最坏情况下的运行时间。快速排序是所有内部排序算法中平均性能最优的排序算法

优化

1. 最明显的改进之处是轴值的选取，如果轴值选取合适，每次处理可以将元素较均匀的划分到轴值两侧：

   三者取中法：三个随机值的中间一个。为了减少随机数生成器产生的延迟，可以选取首中尾三个元素作为随机值

2. 当n很小时，快速排序会很慢。因此当子数组小于某个长度（经验值：9）时，什么也不要做。此时数组已经基本有序，最后调用一次插入排序完成最后处理

6.归并排序

将一个序列分成两个长度相等的子序列，为每一个子序列排序，然后再将它们合并成一个序列。合并两个子序列的过程称为归并

代码

template<class Elem>
void mergesortcore(Elem A[],Elem temp[],int i,int j)
{
    if(i == j)  return;
    int mid = (i + j)/2;

    mergesortcore(A,temp,i,mid);
    mergesortcore(A,temp,mid + 1,j);

    /*归并*/
    int i1 = i,i2 = mid + 1,curr = i;
    while(i1 <= mid && i2 <= j){
        if(A[i1] < A[i2])
            temp[curr++] = A[i1++];
        else
            temp[curr++] = A[i2++];
    }
    while(i1 <= mid)
        temp[curr++] = A[i1++];
    while(i2 <= j)
        temp[curr++] = A[i2++];
    for(curr = i;curr <= j;curr++)
        A[curr] = temp[curr];
}

template<class Elem>
void mergesort(Elem A[],int sz)
{
    Elem *temp = new Elem[sz]();
    int i = 0,j = sz - 1;
    mergesortcore(A,temp,i,j);
    delete [] temp;
}

性能

logn层递归中，每一层都需要O(n)的时间代价，因此总的时间复杂度是O(nlogn)，该时间复杂度不依赖于待排序数组中数值的相对顺序。因此，是最佳，平均和最差情况下的运行时间

由于需要一个和带排序数组大小相同的辅助数组，所以空间代价为O(n)

优化

原地归并排序不需要辅助数组即可归并

void reverse(int *arr,int n)
{
    int i = 0,j = n - 1;
    while(i < j)
        swap(arr[i++],arr[j--]);
}

void exchange(int *arr,int sz,int left)
{
    reverse(arr,left);//翻转左边部分
    reverse(arr + left,sz - left);//翻转右边部分
    reverse(arr,sz);//翻转所有
}

void merge(int *arr,int begin,int mid,int end)
{
    int i = begin,j = mid,k = end;
    while(i < j && j <= k){
        int right = 0;
        while(i < j && arr[i] <= arr[j])
            ++i;
        while(j <= k && arr[j] <= arr[i]){
            ++j;
            ++right;
        }
        exchange(arr + i,j - i,j - i - right);
        i += right;
    }
}

7.堆排序

堆排序首先根据数组构建最大堆，然后每次“删除”堆顶元素（将堆顶元素移至末尾）。最后得到的序列就是从小到大排序的序列

代码

这里直接使用C++ STL中堆的构建与删除函数

template <class Elem>
void heapsort(Elem A[],int n)
{
    Elem mval;
    int end = n;
    make_heap(A,A + end);
    for(int i = 0;i < n;i++){
        pop_heap(A,A + end);
        end--;
    }
}

如果不能使用现成的库函数：

/********************************************
 * 向堆中插入元素
 *  hole：新元素所在的位置
 ********************************************/
template <class value>
void _push_heap(vector<value> &arr,int hole){
    value v = arr[hole];//取出新元素，从而产生一个空洞
    int parent = (hole - 1) / 2;
    //建最大堆，如果建最小堆换成 arr[parent] > value
    while(hole > 0 && arr[parent] < v){
        arr[hole] = arr[parent];
        hole = parent;
        parent = (hole - 1) / 2;
    }
    arr[hole] = v;
}

/********************************************
 * 删除堆顶元素
 ********************************************/
template <class value>
void _pop_heap(vector<value> &arr,int sz)
{
    value v = arr[sz - 1];
    arr[sz - 1] = arr[0];
    --sz;
    int hole = 0;
    int child = 2 * (hole + 1); //右孩子
    while(child < sz){
        if(arr[child] < arr[child - 1])
            --child;
        arr[hole] = arr[child];
        hole = child;
        child = 2 * (hole + 1);
    }
    if(child == sz){
        arr[hole] = arr[child - 1];
        hole = child - 1;
    }
    arr[hole] = v;
    _push_heap(arr,hole);
}

/********************************************
 * 建堆
 *  sz：删除堆顶元素后的大小
 *  v： 被堆顶元素占据的位置原来的元素的值
 ********************************************/
template <class value>
void _make_heap(vector<value> &arr)
{
    int sz = arr.size();
    int parent = (sz - 2) / 2;
    while(parent >= 0){
        int hole = parent;
        int child = 2 * (hole + 1); //右孩子
        value v = arr[hole];
        while(child < sz){
            if(arr[child] < arr[child - 1])
                --child;
            arr[hole] = arr[child];
            hole = child;
            child = 2 * (hole + 1);
        }
        if(child == sz){
            arr[hole] = arr[child - 1];
            hole = child - 1;
        }
        arr[hole] = v;
        _push_heap(arr,hole);
        --parent;
    }
}

template <class value>
void heap_sort(vector<value> &arr)
{
    _make_heap(arr);
    for(int sz = arr.size();sz > 1;sz--)
        _pop_heap(arr,sz);
}

性能

根据已有数组构建堆需要O(n)的时间复杂度，每次删除堆顶元素需要O(logn)的时间复杂度，所以总的时间开销为，O(n+nlogn)，平均时间复杂度为O(nlogn)

注意根据已有元素建堆是很快的，如果希望找到数组中第k大的元素，可以用O(n+klogn)的时间，如果k很小，时间开销接近O(n)