建立堆，添加元素，删除最大元素，排序，C++

堆相关

void heapAdjust(vector<int> &arrs, int i, int len)
{
    int left=i*2+1, right=i*2+2;
    int maxidx = i;
    if(left<len && arrs[left]>arrs[maxidx]){
        maxidx = left;
    }
    if(right<len && arrs[right]>arrs[maxidx]){
        maxidx = right;
    }
    if(maxidx==i) return;
    swap(arrs[maxidx], arrs[i]);
    heapAdjust(arrs, maxidx, len);
}

void print(vector<int> &arrs)
{
    for(int num:arrs){
        cout<<num<<" ";
    }
    cout<<endl;
}

int main(int argc, char** argv)
{
    vector<int> arrs;
    for(int i=0; i<10; i++){
        arrs.push_back(rand()%100);
    }
    cout<<"init array: ";
    print(arrs);
    int len = arrs.size();
    // buildMaxHeap
    for(int i=len/2; i>=0; i--){
        heapAdjust(arrs, i, len);
    }
    cout<<"init heap: ";
    print(arrs);
    // add
    arrs.push_back(rand()%100);
    len = arrs.size();
    int aidx = len-1, par=(len-2)/2;
    while (arrs[aidx]>arrs[par]){
        swap(arrs[aidx], arrs[par]);
        aidx = par;
        par=(aidx-1)/2;
    }
    cout<<"add elements to heap: ";
    print(arrs);
    // del
    len = len-1;
    swap(arrs[0], arrs[len]);
    arrs.pop_back();
    heapAdjust(arrs, 0, len);
    cout<<"del max heap: ";
    print(arrs);

    // sort
    for(int i=len-1; i>=0; i--){
        swap(arrs[0], arrs[i]);
        heapAdjust(arrs, 0, i);
    }
    cout<<"sort heap: ";
    print(arrs);
    return 0;
}

时间复杂度分析

堆建立：$n/2$次调用 heapAdjust ，平均每次递归$logn$次，所以时间复杂度为$nlogn$
添加：只需与父节点交换数据，最多$logn$次，所以时间复杂度为$logn$
删除最大元素：根节点与末尾元素交换，删除末尾元素，从根节点开始调整，最多$logn$次，所以时间复杂度为$logn$
堆排序：每次根节点与末尾元素交换，然后从跟节点调整，堆元素数量减1，一直调整到第一个元素，调整时间复杂度为$logn$， $n$次调整，所以时间复杂度为$nlogn$