排序算法——堆排序

堆定义：堆是基于完全二叉树的一种数据结构，并且满足条件：每个根节点的数据都比他的叶子节点的数据要大（大顶堆）或小（小顶堆）；

堆排序：基于堆这种数据结构进行排序的方法叫做堆排序；

排序方法及步骤：

我们用数组结构来实现堆，假设有一个堆使用长度为length的数组array实现，由数学及数据结构知识可知，堆中最后一个非叶子节点对应的数组下标为length/2-1；假设堆中有一个非叶子节点i，i的左右子节点对应在数组中的下标分别为i*2+1、i*2+2；

知道这些基本的完全二叉树属性，我们接下来就可以实现堆排序算法了。

1、 首先对给与的数据进行初始化构建堆，即使这些数据符合堆的定义；

2、 交换堆顶（最大或最小的节点）和堆尾元素；

3、 调整除去最后一个节点的其他节点，使之满足堆的性质；

4、 返回步骤2继续操作，直至堆节点只有一个；

 

下面是算法实现，以大顶堆为例：

#include <iostream>
using namespace std;

void print_log(int *a, int length);

int adjust_heap(int *arr, int index, int length)
{
    int currentValue = arr[index];
    for (int i = index*2+1; i < length; i = i*2+1)
    {
        if (i+1 < length && arr[i] < arr[i+1])
        {
            i++;
        }
        
        if (arr[i] > currentValue)
        {
            arr[index] = arr[i];
            index = i;
        }
        else
        {
            break;
        }
    }
    
    arr[index] = currentValue;
    
    return 0;
}

int init_heap(int *arr, int length)
{
    for (int i = length/2-1; i >= 0; --i)
    {
        adjust_heap(arr, i, length);
    }
    return 0;
}

int swap(int *arr, int index1, int index2)
{
    int temp = arr[index1];
    arr[index1] = arr[index2];
    arr[index2] = temp;
}

int heap_sort(int *arr, int length)
{
    init_heap(arr, length);
    
    print_log(arr, length);
    
    for (int i = length-1; i >= 0; --i)
    {
        swap(arr, 0, i);
        adjust_heap(arr, 0, i);
    }
    return 0;
}

void print_log(int *a, int length)
{
    for (int i = 0; i < length; ++i)
    {
        cout << a[i] << " , ";
    }
    
    cout << endl;
}

int main() {
    int a[10] = {9, 10, 8, 6, 4, 5, 2, 3, 1, 7};
    
    int length = sizeof(a)/sizeof(*a);
    heap_sort(a, length);
    
    print_log(a, length);

    return 0;
}

 

算法重新调整了一下：

#include <iostream>
using namespace std;

int adjust_heap_recursive(int *arr, int index, int length);
void print_log(int *a, int length);
int swap(int *arr, int index1, int index2);

/*****
** summary : create heap.
** parameter@arr : array to sort.
** parameter@length : the length of array.
*****/
int init_heap(int *arr, int length)
{
    for (int i = 0; i < length/2-1; ++i)
    {
        adjust_heap_recursive(arr, i, length);
    }
    return 0;
}

/*****
** summary : adjust correct value to index .
** parameter@arr : array to opera .
** parameter@index : position .
** parameter@length : the length of array .
*****/
int adjust_heap_recursive(int *arr, int index, int length)
{
    if (2*index+1 == length-1)  // have left child node.
    {
        if (adjust_heap_recursive(arr, 2*index+1, length)  > arr[index])
        {
            swap(arr, index, 2*index+1);
        }
    }
    else if (2*index+2 < length)  // have both left and right nodes.
    {
        if (adjust_heap_recursive(arr, 2*index+1, length) < adjust_heap_recursive(arr, 2*index+2, length))
        {
            if (adjust_heap_recursive(arr, 2*index+2, length) > arr[index])
            {
                swap(arr, index, 2*index+2);
            }
        }
        else
        {
            if (adjust_heap_recursive(arr, 2*index+1, length) > arr[index])
            {
                swap(arr, index, 2*index+1);
            }
        }
    }

    return arr[index];
}

/*****
** summary : exchange value between index1 and index2
*****/
int swap(int *arr, int index1, int index2)
{
    int temp = arr[index1];
    arr[index1] = arr[index2];
    arr[index2] = temp;

    return 0;
}

/*****
** summary : heap sort.
** parameter@arr : array to sort.
** parameter@length : the length of array.
*****/
int sort_heap(int *arr, int length)
{
    for (int i = length-1; i >= 0; --i)
    {
        swap(arr, 0, i);
        adjust_heap_recursive(arr, 0, i);
    }

    return 0;
}

/*****
** summary : heap sort.
*****/
int sort(int *arr, int length)
{
    init_heap(arr, length);

    print_log(arr, length);

    sort_heap(arr, length);

    return 0;
}

/*****
** summary : print logs.
** parameter@a : array.
** parameter@length : the length of array.
*****/
void print_log(int *a, int length)
{
    for (int i = 0; i < length; ++i)
    {
        cout << a[i];
        if (i != length-1)
        {
            cout << " ,";
        }
    }

    cout << endl;
}

int main() {
    int a[19] = {9, 10, 8, 6, 4, 5, 2, 3, 1, 7, 11, 13, 12, 15, 14, 100, 201, 300, 821};

    int length = sizeof(a)/sizeof(*a);
    sort(a, length);

    print_log(a, length);

    return 0;
}