堆排序【代码】

思路参考《算法导论》P84

堆排序中用到的最重要的就是堆这种数据结构，也正是因为这种数据结构能把时间复杂度控制在O(n * lgn)

heapsort算法主要依赖于两个函数

MAX_HEAPIFY(int *A,int i,int len)

用于维护最大堆，时间复杂度为O(lgn)，注意书上描述这个函数的算法只用了两个形参，而由于C++无法通过指针获取数组的大小，所以我额外添加了一个参数作为数组的大小

BUILD_MAX_HEAP(int *A,int len)

从无序的输入数据数组中构造一个最大堆，时间复杂度为O(n)，这里同样添加了一个参数

如果用其他语言比如Java实现，只需把数组名作为参数穿进来即可，Java支持数组拷贝，支持通过数组名获取数组大小，比这里简单一点

排序算法的详细过程就不描述了，书上讲的挺清楚的

----------------------------------------------------------代码-------------------------------------------------------

// Heapsort.cpp: 定义控制台应用程序的入口点。
//


#include "stdafx.h"
#include <iostream>

using namespace std;

int PARENT(int i)
{
    return (i - 1) / 2;
}

int LEFT(int i)
{
    return 2 * i + 1;
}

int RIGHT(int i)
{
    return 2 * i + 2;
}
//维护最大堆，时间复杂度为O(lgn)
int MAX_HEAPIFY(int *A,int i,int len)
{
    int l, r, largest;//l为左孩子的下标，r为右孩子的下标，largest为三者中最大数的下标
    int temp;
    l = LEFT(i);
    r = RIGHT(i);
    if (l < len && A[l] > A[i])
        largest = l;
    else
        largest = i;

    if (r < len && A[r] > A[largest])
        largest = r;
    
    if (largest != i)
    {
        temp = A[i];
        A[i] = A[largest];
        A[largest] = temp;
        MAX_HEAPIFY(A, largest, len);
    }
    else
    {
        if (l >= len && r >= len)//到达了叶节点，停止递归
        {
            return 0;
        }
        MAX_HEAPIFY(A, l, len);
        MAX_HEAPIFY(A, r, len);
    }    
}

//从无序的输入数据数组中构造一个最大堆，时间复杂度为O(n)
int BUILD_MAX_HEAP(int *A,int len)
{
    int start = PARENT(len);
    for (int i = start; i >= 0; i--)
    {
        MAX_HEAPIFY(A, i, len);
    }
    return 0;
}

int HEAPSORT(int *A,int len)
{
    int length = len;
    int *res = new int[len]{0};//记录排完序后的结果
    int ptr = len - 1;
    BUILD_MAX_HEAP(A, len);

    for (int i = 0; i < length; i++)
        cout << A[i] << ends;
    cout << endl << endl;

    for (int i = length; i >= 1; i--)
    {
        res[ptr--] = A[0];
        A[0] = A[len-1];
        len--;
        int *A_temp = new int[len];
        for (int i = 0; i < len; i++)//把删掉最后一个元素后的数组A复制到A_temp中
        {
            A_temp[i] = A[i];
        }
        MAX_HEAPIFY(A_temp, 0, len);//对A_temp重新维持为最大堆
        for (int i = 0; i < len; i++)//把A_temp的值复制给A
        {
            A[i] = A_temp[i];
        }

        for (int i = 0; i < len; i++)
            cout << A[i] << ends;
        cout << endl;
        delete A_temp;
    }

    cout << "排序后的数组为（升序）：" << endl;
    for (int i = 0; i < length; i++)
        cout << res[i] << ends;
    cout << endl;
    return 0;
}

int main()
{
    int A[] = {16,4,10,14,7,9,3,2,8,1};
    cout << "排序前的数组为：" << endl;
    for (auto c : A)
        cout << c << ends;
    cout << endl;
    /*BUILD_MAX_HEAP(A,10);
    for (auto c : A)
        cout << c << ends;
    cout << endl;*/
    HEAPSORT(A,10);
    return 0;
}

运行结果：