学习堆排序

自己写代码调用了一下STL的堆，然后自己也写了一个，还不确定自己的写法是不是和STL的一眼，目前只是非常朴素的实现了而已，有时间比较一下，看看差别：

（似乎make_heap的方式不一样，我是一个一个insert的）

#include <vector>
#include <algorithm>

using namespace std;


// 向上调整
void adjust_up(int* ptr_begin, int idx);
// 插入新元素
void heap_insert(int* ptr_begin, int*& ptr_end, int ele);
// 返回顶元素
int heap_peek(int* ptr_begin, int*& ptr_end);
// 向下调整
void adjust_down(int* ptr_begin, int* ptr_end, int idx);
// 堆排序
void heap_sort(int* ptr_begin, int* ptr_end);

inline void print_v(vector<int>& v)
{
    vector<int>::iterator iter;
    for (iter = v.begin(); iter != v.end(); iter++)
    {
        printf("%d ", *iter);
    }
    printf("
");
}
inline void print_arr(int* ptr_begin, int* ptr_end)
{    
    for(int* iter = ptr_begin; iter != ptr_end; iter++)
        printf("%d ", *iter);
    printf("
");
}
int main()
{
    int arr[10] = {14,16,1,9,27,4,3,5,8,31};
    vector<int> v(arr, arr+(sizeof(arr)/sizeof(int)));
    print_v(v);
    make_heap(v.begin(), v.end());        //建立一个最大堆，亦即：一个完全二叉树，一个用数组存放的完全二叉树
    printf("result of make_heap:	");
    print_v(v);
    pop_heap(v.begin(), v.end());        //把堆顶元素（最大的元素）放到vector尾部，可以通过v.back()取出
    printf("result of pop_heap:	");
    print_v(v);
    make_heap(v.begin(), v.end());
    printf("result of make_heap:	");
    print_v(v);

    v.push_back(2);                        //放到vector的最后
    printf("result of push_back:	");
    print_v(v);
    push_heap(v.begin(), v.end());        //把vector最后一个元素插入到整个heap中
    printf("result of push_heap:	");
    print_v(v);
    pop_heap(v.begin(), v.end());        //把堆顶元素（最大的元素）放到vector的最后
    printf("result of pop_heap:	");
    print_v(v);

    // 用自己写的方法
    int my_heap[100];
    int* end_of_heap = my_heap;
    int len = sizeof(arr)/sizeof(int);
    for(int i = 0; i < len; i++)
    {
        heap_insert(my_heap, end_of_heap, arr[i]);
    }

    printf("my function:
");
    printf("insert into the heap:	");
    print_arr(my_heap, end_of_heap);                    
    heap_insert(my_heap, end_of_heap, 2);                            //插入新元素后的堆
    printf("result of heap_insert:	");
    print_arr(my_heap, end_of_heap);                    
    
    // 循环取出堆顶元素
    while (my_heap != end_of_heap)
    {
        printf("top of heap :	%d
", heap_peek(my_heap, end_of_heap));    //取出堆顶元素
        printf("result of heap_peek:	");
        print_arr(my_heap, end_of_heap);    
    }

    // 堆排序
    int* end_of_arr = arr + sizeof(arr)/sizeof(int);
    heap_sort(arr, end_of_arr);
    printf("堆排序结果:	");
    print_arr(arr, end_of_arr);


    getchar();
    return 0;
}

// 堆排序
void heap_sort(int* ptr_begin, int* ptr_end)
{
    // 不知道真的堆排序是不是这么写的，感觉不应该这样，有时间的话看一下
    int* ptr_tmp = ptr_begin;
    while (ptr_tmp != ptr_end)
    {
        heap_insert(ptr_begin, ptr_tmp, *ptr_tmp);
    }
    while(ptr_begin != ptr_tmp)
    {
        heap_peek(ptr_begin, ptr_tmp);
    }
}

// 将尾部元素上移
void adjust_up(int* ptr_begin, int idx)
{
    if(idx <= 0)
        return;
    int parent_idx = (idx+1)/2 - 1;
    if(ptr_begin[parent_idx] < ptr_begin[idx])
    {
        swap(ptr_begin[parent_idx], ptr_begin[idx]);
        adjust_up(ptr_begin, parent_idx);
    }
}

// 插入新元素
void heap_insert(int* ptr_begin, int*& ptr_end, int ele)
{
    int idx = ptr_end - ptr_begin;
    *ptr_end++ = ele;
    adjust_up(ptr_begin, idx);    
}

// 返回顶元素
int heap_peek(int* ptr_begin, int*& ptr_end)
{
    int tmp = *ptr_begin;
    *ptr_begin = *(--ptr_end);
    *ptr_end = tmp;
    adjust_down(ptr_begin, ptr_end, 0);
    return tmp;
}

// 将首元素下移
void adjust_down(int* ptr_begin, int* ptr_end, int idx)
{
    int len = ptr_end - ptr_begin;
    if(idx >= len)
        return;
    int tmp = *ptr_begin;
    int left_idx = (idx+1)*2 - 1;
    int right_idx = (idx+1)*2;
    if (left_idx >= len)
    {
        return;
    }else if(right_idx >= len)
    {
        if (ptr_begin[idx] < ptr_begin[left_idx])
        {
            swap(ptr_begin[idx], ptr_begin[left_idx]);
            adjust_down(ptr_begin, ptr_end, left_idx);
        }
    }else
    {
        if (ptr_begin[left_idx] > ptr_begin[right_idx])
        {
            if (ptr_begin[idx] < ptr_begin[left_idx])
            {
                swap(ptr_begin[idx], ptr_begin[left_idx]);
                adjust_down(ptr_begin, ptr_end, left_idx);
            }
        } 
        else
        {
            if (ptr_begin[idx] < ptr_begin[right_idx])
            {
                swap(ptr_begin[idx], ptr_begin[right_idx]);
                adjust_down(ptr_begin, ptr_end, right_idx);
            }
        }
    }
}