[算法 笔记]堆排序（续）

　　上一篇有关堆排序的源码是从STL标准库中抽出来，但是源码有点让我混乱。最近闲来无事，再写一篇有关堆排序的博客，并附上简单的过程描述。

　　（参考书籍：《算法引论 —— 一种创造性方法》 4.7和6.4.5节）

 

　　堆排序最坏情况下的运行时间是O(n log n)。堆排序中建堆方式有两种：

　　1. 自顶向下建立大根堆。简单点说，就是从无到有插入元素到堆中。这样可以有效地维护了大根堆的性质，即大根堆是由满足大根堆性质的子堆构成。

　　2. 自底向上建立大根堆。一般都是从堆存储数组的一半的位置开始递减比较。需要注意的是，在每次比较后，需要调整子堆来满足大根堆的性质。有点类似于从建好的大根堆中移除元素之后的调整。（这种方式参考《数据结构（C语言版）》 严蔚敏，吴伟民著的10.4.3节）

　　通过上述资料会发现，自顶向下建立大根堆的方式要比自底向上建立大根堆的方式简单。这里使用的是第一种方式：

void build_heap( int heap[], int current_size )
{
    int start = 0;

    while ( start < current_size - 1 )
    {
        // start在insert_to_heap函数会发生变化      
        insert_to_heap( heap, &start, start + 1, heap[start] );
    }
}

　　在建立堆之后，堆排序的处理：只需要将大根堆中的最大值（heap[0]）从堆中移除，并将其插入到数组的末尾（升序方式）。

 

void heap_sort( int heap[], int current_size )
{
    int i = current_size - 1;
    int j = current_size;

    build_heap( heap, current_size );
    while ( j )
    {
        int data = remove_max_from_heap( heap, &j );
        heap[i] = data;
        --i;
    }
}

 

　　完整的源码：

#include <stdio.h>
#include <assert.h>

void swap_value( int heap[], int lhs, int rhs )
{
    int tmp = heap[lhs];
    heap[lhs] = heap[rhs];
    heap[rhs] = tmp;
}

/** @*current_size: 表示heap中已经存在的元素个数。
 ** @heap_size：表示heap的最大容量是多少
 */
void insert_to_heap( int heap[], int *current_size,
                     int heap_size, const int value )
{
    int child = *current_size;
    int parent = 0;

    assert( *current_size < heap_size );
    heap[child++] = value;
    parent = child / 2;
    while ( parent >= 0 )
    {
        if ( heap[child] > heap[parent] )
        {
            swap_value( heap, child, parent );
            child = parent;
            parent /= 2;
        }
        else
            parent = -1;
    }
    *current_size += 1;
}

int remove_max_from_heap( int heap[], int *current_size )
{
    int result = 0;
    int child = 0;
    int parent = 0;

    if ( *current_size == 0 )
    {
        printf( "remove_max_from_heap: the heap is empty.
" );
        return -1;
    }

    result = heap[0];
    swap_value( heap, 0, *current_size - 1 );
    --*current_size;
    child = 1;
    while ( child <= *current_size - 1 )
    {
        if ( child < *current_size - 1
            && heap[child] < heap[child + 1] )
        {
            child += 1;
        }

        if ( heap[child] > heap[parent] )
        {
            swap_value( heap, child, parent );
            parent = child;
            child *= 2;
        }
        else
        {
            child = *current_size;
        }
    }

    return result;
}

void build_heap( int heap[], int current_size )
{
    int start = 0;

    while ( start < current_size - 1 )
    {
        insert_to_heap( heap, &start, start + 1, heap[start] );
    }
}

void heap_sort( int heap[], int current_size )
{
    int i = current_size - 1;
    int j = current_size;

    build_heap( heap, current_size );
    while ( j )
    {
        int data = remove_max_from_heap( heap, &j );
        heap[i] = data;
        --i;
    }
}

int main()
{
    int heap[] = { 78, 58, 87, 62, 92, 332, 55, 40, 75, 146 };
    int heap_size = sizeof(heap) / sizeof(int);
    int i = 0;

    heap_sort( heap, heap_size );
    while ( i < heap_size )
    {
        printf( "%d ", heap[i++] );
    }


    return 0;
}