优先队列 之 堆排序实现（堆排序思想）

/* 

 1、接上一篇文章，优先队列 之 插入排序 这里是用到了堆排序的思想，而非完全的堆排序的步骤；正如二分思想，他是一种思想，不要
    停留在一种方法上、一种数据结构上。

  2、poj 2833，因为优先队列是由最小（大）堆实现的，时间复杂度O（n*logn）----正好服务优先队列的要求，保证队首（栈顶）
元素的优先级最高，其他元素的优先级顺序不考虑。

  3、数据结构和算法的完美结合，第一次尝试到了两者合力是如此的完美,正如优先队列用到了：

（1）：元素出队列，相当于栈顶和最后一个元素交换后，向下调整的过程；（2）：元素入队列，相当于向队尾增加一个元素，向上调整的过程。

  4、下面并未体现出优先级的顺序，而是用数字的大校表示优先级，当然可以建立一个结构体struct { weight     key },再加上一个template<class T>写成模板类

*/

#include <iostream>
using namespace std;
const int maxn = 100;
void my_swap(int &a, int &b)
{
    int tmp;
    tmp = a;
    a = b;
    b = tmp;
}
//void heap_sort(int arr[],const int &len);
void heap_sort(int arr[],int &len);
void heap_down_adjust(int arr[],int i,int &len);
void heap_up_adjust(int arr[],int &len);
void heap_init(int arr[],int &len);
bool de_heap_queue(int arr[],int &len);
void en_heap_queue(int arr[],int &len,const int &key);
int main()
{
    int i,len,t_len;// 数组的有效长度
    int arr[maxn],tmp;
    len = 0;
    cout << "请输入一个序列(-1结束)：" << endl;
    while(cin >> tmp)
    {
        if(tmp == -1)
            break;
        arr[len] = tmp;
        len++;
    }
    t_len = len;
    heap_init(arr,len);//调用建立初始堆
    cout << "插入一个元素：" << endl;
    cin >> tmp;
    en_heap_queue(arr,len,tmp);
    cout << "按队列的优先顺序出队：" << endl;
    do
    {
        cout << "堆顶元素：" << arr[0] << " " << len << endl;
    }while(de_heap_queue(arr,len));

    return 0;
}

// 堆排序
void heap_sort(int arr[],int &len)
{
    int i;
    for(i=len/2-1; i>=0; --i)// 至于为什么是从i = len/2 -1开始，自己建立一个完全二叉树的数组即可发现规律。
    {
        heap_down_adjust(arr,i,len);
    }// 建立一个初试堆
    //以0 和 len-1为下标的元素交换，之后从0下标开始调整堆，直到剩下一个元素
    for(i=len-1; i>0; --i)
    {
        my_swap(arr[0],arr[i]);
        heap_down_adjust(arr,0,i);// i 代表当前的数组长度
    }

}
// 建立一个初始堆
void heap_init(int arr[],int &len)
{
    int i;
    for(i=len/2-1; i>=0; --i)// 至于为什么是从i = len/2 -1开始，自己建立一个完全二叉树的数组即可发现规律,len是数组长度。
    {
        heap_down_adjust(arr,i,len);
    }// 建立一个初试堆(大顶堆)
}
// 数组，调整位置，数组长度
void heap_down_adjust(int arr[],int i,int &len)
{
    int lc;// 左孩子
    for(; i*2+1<len; i=lc)
    {
        lc = i*2+1;// 从左孩子开始
        if(lc+1<len && arr[lc+1]>arr[lc])//如果右侧孩子大，加一
            lc++;
        if(arr[lc]>arr[i])//较大的孩子节点大于父节点
            my_swap(arr[lc],arr[i]);
        else
            break;//父节点是最大的无需向下调整
    }
}
// 数组，调整位置，数组长度,插入新元素，向上调整；比向下调整简单，
//因为他需要判断左右孩子的最大值与最后一个值（因为是最后一个元素和零号元素交换的）
void heap_up_adjust(int arr[],int i,int &len)
{
    int parent;
    for(i=len-1;i>0;i=parent)
    {
        parent = (i-1)/2;
        if(arr[i]>arr[parent])
            my_swap(arr[i],arr[parent]);
        else// 无需再向上调整
            break;
    }
}
// 删除优先队列的队首元素
bool de_heap_queue(int arr[],int &len)
{
    if(len<=1)
        return false;
    len--;// 相当于删除了，数组从0开始，所以Len-1才是最后一个元素
    my_swap(arr[0],arr[len]);
    heap_down_adjust(arr,0,len);
    return true;
}
//插入队尾元素
void en_heap_queue(int arr[],int &len,const int &key)
{
    arr[len] = key;
    len++;
    heap_up_adjust(arr,len,len);
}

改进之后的swap()函数，异或的好处，以及 位移 之 右移 >>（相当于除以2） 左移 << ( 相当于乘以2 )。

void my_swap(int &a, int &b)
{
        a = a ^ b;
b = a ^ b;
a = a ^ b;
}

/*

基本函数说明及复杂度分析如下：

　　heap_down_adjust() 从第一个不满足堆的结点s开始向下做调整，使得维护一个堆，删除栈顶元素或者建立初始堆。

　　--------log(n)

heap_up_adjust() 从最后一个结点s开始向上做调整，使得维护一个堆，插入新元素的过程。

　　--------log(n)

　　en_heap_queue() 从尾部增加一个叶子节点到堆中，因为原本是满足堆的，所以只需要从下至上不断跟父结点进行交换，直至已满足堆退出，调用的heap_up_adjust() 

　　--------log(n)

　　de_heap_queue() 把start跟end做交换，然后[start，end-1]从新做一次调整，使得[start,end-1]维护成一个堆，堆大小length随之-1，调用的heap_down_adjust() 。

　　--------log(n)

　　heap_init() 从第一个非终端结点开始->根节点不断做heap_adjust()，使之构成一个初始堆。

　　--------n / 2 * log(n)

　　heap_sort()  相当于重复n次de_heap_queue()操作，但length不改变。

　　--------n * log(n)

　 用类模板实现，参照 ：http://www.cnblogs.com/slave_wc/archive/2010/12/23/1915293.html

*/