堆排序

堆排序（Heap Sort）就是利用堆（假设利用大顶堆）进行排序的方法。它的基本思想是，将待排序的序列构造成一个大顶堆。此时整个序列的最大值就是堆顶的根节点。将它移走（其实就是将其与堆数组的末尾元素交换，此时末尾元素就是最大值），然后将剩余的n-1个序列重新构成一个堆，这样就会得到n个元素中的次大值。如此反复执行，便能得到一个有序序列了。

核心代码

#define LEFT  (2*nRootID+1)
#define RIGHT (2*nRootID+2)

void Adjust(int arr[], int len, int nRootID)
{
    assert(arr!=NULL && len>0);

    while(1)
    {
        //两个孩子
        if(RIGHT < len)
        {
            //左比右大
            if(arr[LEFT] > arr[RIGHT])
            {
                //左比父亲大
                if(arr[LEFT] > arr[nRootID])
                {
                    //交换
                    arr[LEFT] = arr[LEFT] ^ arr[nRootID];
                    arr[nRootID] = arr[LEFT] ^ arr[nRootID];
                    arr[LEFT] = arr[LEFT] ^ arr[nRootID];

                    //被交换位置作为新的调整位置
                    nRootID = LEFT;
                    continue;
                }
                else
                {
                    break;
                }
            }
            else
            {
                //右比父亲大
                if(arr[RIGHT] > arr[nRootID])
                {
                    //交换
                    arr[RIGHT] = arr[RIGHT] ^ arr[nRootID];
                    arr[nRootID] = arr[RIGHT] ^ arr[nRootID];
                    arr[RIGHT] = arr[RIGHT] ^ arr[nRootID];

                    //被交换位置作为新的调整位置
                    nRootID = RIGHT;
                    continue;
                }
                else
                {
                    break;
                }
            }
        }
        //一个孩子
        else if(LEFT < len)
        {
            //左比父亲大
            if(arr[LEFT] > arr[nRootID])
            {
                //交换
                arr[LEFT] = arr[LEFT] ^ arr[nRootID];
                arr[nRootID] = arr[LEFT] ^ arr[nRootID];
                arr[LEFT] = arr[LEFT] ^ arr[nRootID];

                //被交换位置作为新的调整位置
                nRootID = LEFT;
                continue;
            }
            else
            {
                break;
            }
        }
        //没有孩子
        else
        {
            break;
        }
    }
}

void HeapSort(int arr[], int len)
{
    int i;

    assert(arr!=NULL && len>0);

    //建堆
    //从最后一个父亲节点开始调整
    for(i=len/2-1; i>=0; --i)
    {
        //调整
        Adjust(arr, len, i);
    }

    //排序
    for(i=len-1; i>0; --i)
    {
        //堆顶和最后位置交换
        arr[i] = arr[i] ^ arr[0];
        arr[0] = arr[i] ^ arr[0];
        arr[i] = arr[i] ^ arr[0];

        //调整
        Adjust(arr, i, 0);
    }
}

函数Adjust()代码的优化

void Adjust2(int arr[], int len, int nRootID)
{
    int nMax;

    assert(arr!=NULL && len>0);

    for(nMax=LEFT; nMax<len; nMax=LEFT)
    {
        //两个孩子
        if(RIGHT < len)
        {
            if(arr[RIGHT] > arr[LEFT])
            {
                nMax = RIGHT;
            }
        }

        //最大值和父亲进行比较
        if(arr[nMax] > arr[nRootID])
        {
            //交换
            arr[nMax] = arr[nRootID] ^ arr[nMax];
            arr[nRootID] = arr[nRootID] ^ arr[nMax];
            arr[nMax] = arr[nRootID] ^ arr[nMax];

            //被交换位置作为新的调整位置
            nRootID = nMax;
        }
        else
        {
            break;
        }
    }
}

算法分析：

　　最好时间复杂度：O(nlog2(n))

　　平均时间复杂度：O(nlog2(n))

　　最坏时间复杂度：O(nlog2(n))

　　　　空间复杂度：O(1)

　　　　　　稳定性：不稳定