#算法#排序~堆排序

#include <iostream>
#include <vector>
using namespace std;
/*
class MaxHeap {
private:
    vector<int> heap;
    int max_size = 0;
    void swap(vector<int>& arr, int a, int b) {
        int tmp = arr[a];
        arr[a] = arr[b];
        arr[b] = tmp;
    }
public:
    MaxHeap() {
        this->heap = new vector<int>(max_size, -1);
        max_size = 100;
    }

    //上浮过程：一般用于堆尾端插入元素后，重新调整堆
    void upAdjust(vector<int>& arr) {
        int size = arr.size();
        //最后一个元素即为新插入元素
        int child = size - 1;
        int parent = (child - 1) / 2;
        // //将最后一个元素存入temp 最后归位，减少交换计算
        // int temp = arr[child];
        //从下往上循环上浮:判定条件child > 0 保证孩子最大为根节点的子节点
        while (child > 0 && arr[child] > arr[parent]) {
            swap(arr, child, parent);
            //上浮过程
            child = parent;
            parent = (child - 1) / 2;
        }
    }
    //下沉过程：一般用于堆的建造，以及删除元素后堆的重新排列
    void downAdjust(vector<int>& arr, int parent, int size) {
        int child = parent * 2 + 1;
        //从当前节点往下下沉过程
        while (child < size) {
            //若右孩子也存在，则查找左右孩子最大的值
            if (child + 1 < size) {
                child = arr[child + 1] > arr[child] ? child + 1 : child;
            }
            //若父节点大于孩子中最大值则下沉结束
            if (arr[parent] >= arr[child]) return;

            //否则，将父节点与较大孩子交换
            swap(arr, parent, child);

            //迭代子树
            parent = child;
            child = 2 * parent + 1;
        }
    }

    //构建大顶堆，从最后一个非叶子节点开始downAdjust
    void buildHeap(vector<int>& arr) {
        int size = arr.size();
        for (int i = size / 2 - 1; i >= 0; i--) {
            downAdjust(arr, i, size);
        }
    }


    void headSort(vector<int>& arr) {
        //将最大元素放在最后以为，调整堆
        for (int i = arr.size() - 1; i >= 0; i--) {
            swap(arr, 0, i);
            downAdjust(arr, 0, i);
        }

    }

};
*/

void swap(vector<int>& arr, int a, int b) {
    int tmp = arr[a];
    arr[a] = arr[b];
    arr[b] = tmp;
}
//上浮过程：一般用于堆尾端插入元素后，重新调整堆
void upAdjust(vector<int>& arr) {
    int size = arr.size();
    //最后一个元素即为新插入元素
    int child = size - 1;
    int parent = (child - 1) / 2;
    // //将最后一个元素存入temp 最后归位，减少交换计算
    // int temp = arr[child];
    //从下往上循环上浮:判定条件child > 0 保证孩子最大为根节点的子节点
    while (child > 0 && arr[child] > arr[parent]) {
        swap(arr, child, parent);
        //上浮过程
        child = parent;
        parent = (child - 1) / 2;
    }
}
//下沉过程：一般用于堆的建造，以及删除元素后堆的重新排列
void downAdjust(vector<int>& arr, int parent, int size) {
    int child = parent * 2 + 1;
    //从当前节点往下下沉过程
    while (child < size) {
        //若右孩子也存在，则查找左右孩子最大的值
        if (child + 1 < size) {
            child = arr[child + 1] > arr[child] ? child + 1 : child;
        }
        //若父节点大于孩子中最大值则下沉结束
        if (arr[parent] >= arr[child]) return;

        //否则，将父节点与较大孩子交换
        swap(arr, parent, child);

        //迭代子树
        parent = child;
        child = 2 * parent + 1;
    }
}

//构建大顶堆，从最后一个非叶子节点开始downAdjust
void buildHeap(vector<int>& arr) {
    int size = arr.size();
    for (int i = size / 2 - 1; i >= 0; i--) {
        downAdjust(arr, i, size);
    }
}


void headSort(vector<int>& arr) {
    //将最大元素放在最后以为，调整堆
    for (int i = arr.size() - 1; i >= 0; i--) {
        swap(arr, 0, i);
        downAdjust(arr, 0, i);
    }

}


void show(vector<int> arr) {
    for (auto elem : arr) {
        cout << elem << "  ";
    }
    cout << endl;
}
int main(void) {

    vector<int> heap = { 8, 1, 14, 3, 21, 5, 7, 10 };
    show(heap);
    
    
    buildHeap(heap);
    show(heap);
    headSort(heap);
    show(heap);


    return 0;
}