堆排序和优先级队列

堆排序和优先级队列

　　堆排序：和合并排序一样，时间复杂度为O(nlgn);同时和插入排序一样，在原序列中进行；这样堆排序集合了合并排序和插入排序的优点。

　　堆排序的另一个特点是利用了"堆"这种数据结构. 堆数据结构还不止在堆排序中有用,还可以构成一个有效的优先队列.

　　堆: 是一种数据结构,也是一种数组对象,如图 1-1所示: 

图 1-1 最大堆(图片来源《算法导论》)

　　如上图1-1 所示, 可以被看成一棵完全二叉树,二叉树的的每个节点和数组中存放该节点的那个元素对应.在使用"堆"数据机构的时候,其实并不需求真正构建一棵完全二叉树, 数据的存储依然是在一个数组中,操作也在数组中,只是数组中数据的存放,位置关系如完全二叉树所示,我们在构造堆的时候其实是在构建数组中数据的关系. 上图所示一个最大堆(父节点大于两个子节点), 最小堆同理.

　　由于我们将数组中的数据关系对应成了一块完全二叉树,所以对数组的各种操作时间复杂度也应该和完全二叉树操作向对应,即O(nlgn). 下文所以的堆即代指"最大堆"。

　　堆排序

　　根据堆的性质,父节点大于子节点,那么根节点一定是最大的,继而数组中第一个数据也应该是最大的. 根据冒泡排序和选择排序的原理, 如果将每次数组中的第一个元素和最后一个元素进行交换,再让第一个到倒数第二个形成的新数组重新形成最大堆,再次将新数组第一个和最后一个交换;需要重新建堆的数组长度不断减小.如此循环下去,最后原数组成了一个有小到大的有序序列.

　　根据上面的论述,如何让无序的元素,构建成一个符合(最大/最小)堆性质的堆才是关键.

　　保持堆(最大堆)性质原理: 将父节点和两个子节点进行比较,找到那个最大;如果父节点最大,该节点符合最大堆性质;如何是两个子节点中某个最大,将最大子节点和父节点位置进行交换; 在查看新的子节点作为父节点是否符合最大堆的性质,以此循环.

　　代码如下:

//子节点和父节点在数组中位置的对应关系(数组从0开始)
int parent(int i)
{
    return (int)((i-1)/2); 
}
//父节点和左子节点在数组中的位置对应关系
int Left(int i)
{
    return 2*i+1;
}
//父节点和右子节点在数组中的位置对应关系
int Right(int i)
{
    return 2*i+2;
}

//保持最大堆性质，循环控制的形式
void MaxHeapify(int A[], int  i,int length)
{
    int left,right,largest;
    left=Left(i);
    right=Right(i);

    largest=length;

    while(largest!=i){

    if(left<length && A[left]>A[i]) 
        largest=left;
    else
        largest=i;
    if(right<length && A[right]>A[largest])
        largest=right;
        int temp;
        temp=A[largest];
        A[largest]=A[i];
        A[i]=temp;        
    }

}

//保持最小堆性质,递归的形式
void MinHeapify(int A[], int  i,int length)
{
    int left,right,minmun;
    left=Left(i);
    right=Right(i);

    if(left<length && A[left]<A[i]) 
        minmun=left;
    else
        minmun=i;
    if(right<length && A[right]<A[minmun])
        minmun=right;

    if(minmun!=i)
    {
        int temp;
        temp=A[minmun];
        A[minmun]=A[i];
        A[i]=temp;

        MaxHeapify(A,minmun,length);
    }

}

　　建堆以及堆排序算法: 

　　堆排序的基本原理就是对一个无序数组建立堆关系,再利用堆的性质不断重数组中查找最值元素.

　　建堆的代码如下:

void BuildMaxHeapify(int A[], int length)
{
    int i;
    for(i=(int)((length-1)/2);i>=0;i--)
        MaxHeapify(A,i,length);
}

　　堆排序的算法代码如下: 

void Heapsort(int A[],int Length)
{
    int i;
    int temp;
    BuildMaxHeapify(A,Length);

    for(i=Length;i>=1;i--)
    {
        MaxHeapify(A,0,i);

        temp=A[i-1];
        A[i-1]=A[0];
        A[0]=temp;

    }

}

　　优先级队列

　　优先级队列分为最大优先级队列和最小优先级队列.(应用举例摘于《算法导论》)

　　最大优先级队列应用：其一,一台分时计算机上进行作业调度,如何从具有优先级标示的队列中选择优先级最高的任务.

　　最小优先级队列应用: 其一, 被用在基于事件驱动的模拟器中. 在这种应用中，队列中的各项是要模拟的事件，每一个都有一个发生时间作为关键字。事件模拟按照各事件的发生时间的顺序进行，因为模拟某一事件可能导致稍后对其他事件的模拟。模拟程序都使用EXTRACT-MIN来选择下一个事件，而使用INSERT将一个新事件插入队列中。

　　最大优先级队列提取操作代码如下:

int HeapExtractMax(int A[], int length)
{
    int max;

    if(length<1)
        printf("the heap underflow!
");
    else
    {
        max=A[0];
        A[0]=A[length-1];

        MaxHeapify(A,0,length);
    }

    return max;
}

　　最大优先级队列提高或减小优先级操作代码如下:

void HeapIncreaseKey(int A[],int i,int key)
{
    int temp;
    
    if(key<A[i])
    {
        printf("The new key can not be smaller than current key!
");
    }
    else
    {
        while(i>=0 && A[parent(i)]<key)
        {
            temp=A[parent(i)];
            A[parent(i)]=key;
            key=temp;

            i=parent(i);
        }
    }
}

//减小某一元素的关键字
void  HeapDecreaseKey(int A[],int i,int key,int length)
{
    int temp;

    if(key>A[i])
    {
        printf("The new key can not be bigger than current key!
");
    }
    else
    {
        while(i<length && (key<A[Left(i)] || key<(Right(i))))
        {
            if(key<A[Left(i)])
            {
                temp=A[Left(i)];
                A[Left(i)]=key;
                    key=temp;

                    i=Left(i);
            }
            else
            {
                temp=A[Right(i)];
                A[Right(i)]=key;
                    key=temp;

                    i=Right(i);
            }

        }
    }
    
}

　　最大优先级队列插入新元素操作代码如下:

void MaxHeapInsert(int A[],int key,int length)
{
    length=length+1;
    A[length-1]=-1;//假设数组内的整数全部大于0
    
    HeapIncreaseKey(A,length-1,key);
}