9.堆排序

 1 #include "pch.h"
 2 #include <iostream>
 3 #include <cmath>
 4 //优先级队列用完全二叉堆实现
 5 //使用数组存储某结点i的父结点为(i-1)/2下整，左孩子结点为2*i+1,右孩子结点为2*i+2
 6 //二叉堆的上滤操作
 7 //大根堆
 8 int percolateUp(int *arr, int rank) {
 9     int parent = (rank-1)/2;
10         while (parent>0)                   //尚未解决根节点无法遍及到的问题
11         {
12             if (arr[rank] < arr[parent]) break;
13             std::swap(arr[rank], arr[parent]);
14             rank = parent;
15             parent = (parent - 1) / 2;
16         }
17     return parent;
18 }
19 //二叉堆的下滤操作
20 void percolateDown(int *arr, int rank,int n) {
21     int l = 2 * rank + 1;      //左孩子
22     while (l<n)                                    
23     {
24         if (l+1< n &&arr[l] < arr[l + 1])
25             l++;
26         if (arr[rank] > arr[l])
27             break;
28         else
29         {
30             std::swap(arr[l], arr[rank]);
31             rank = l;
32             l = l * 2 + 1;
33         }
34     }
35 }
36 //一种低效的建堆方式
37 void heapify(int *arr, int n) {              //自上而下的上滤（由上到下，由左到右）
38     for (int i = 1; i < n; i++) {            //复杂度为O(nlogn)
39         percolateUp(arr,i);                  //显然我们不愿意拿如此大的时间仅得到一个偏序
40     }                                        //实际上这样的复杂度足以得到全序
41 }
42 //Floyd建堆方法
43 //大根堆
44 void heapify_Floyd(int *arr, int n) {        //自下而上的下滤
45     for (int i = n / 2 - 1; i >=0; i--) {    //叶子结点无需下滤，最后一个内部结点的秩为n/2-1
46         percolateDown(arr, i, n);
47     }
48 }
49 void heapSort(int *arr, int n) {
50     heapify_Floyd(arr, n);
51     for (int i = n - 1; i > 0; i--) {
52         std::swap(arr[0], arr[i]);
53         percolateDown(arr, 0, i);
54     }
55 }
56 int main() {
57     int a[9]{ 2,1,6,3,9,7,4,8,5 };
58     heapSort(a, 9);
59     for (int i = 0; i < 9; i++) {
60         std::cout << a[i] << " ";
61     }
62     
63 }