堆排序

2013-07-23 22:37:12

 

注意几点：

1. 堆的性质虽然借助树的概念来定义的，但实际实现用数组即可，数组的下标可表征父节点与左右子树的关系；
2. 数组下标从1开始时，下标为i的结点的左子树的下标为 2i，右子树下标为2i + 1;数组下标从0开始时，下标为i的结点的左子树的下标为 2i + 1，右子树下标为2i + 2;
3. 注意循环结束条件；
4. 下面的代码中输入数组是利用随机数产生函数rand()得到的，用srand()函数，可给rand()提供seed，这样每次运行时就会得到不同的随机数序列；但要注意其使用方法

 

代码：

#include <iostream>
#include <cassert>
#include <time.h>
using namespace std;

typedef int DataType;
const int MaxSize = 100000000;

//显示数组元素，lengthOfArray为数组中元素个数
void DisplayArray(const DataType arrayToDiaplay[],const size_t lengthOfArray)
{
    assert(NULL != arrayToDiaplay);

    for (size_t index = 0;index < lengthOfArray;++index)
    {
        cout<<arrayToDiaplay[index]<<"\t";
    }

    cout<<endl;
}

 //判断在最大下标为lengthOfHeapArray（为数组中元素个数-1）的数组中，下标为positionToAdjust的元素是否有左子树
 bool IsHasLeftChild(const size_t lengthOfHeapArray,const size_t positionToAdjust)
 {
     size_t indexOfLeftChild = 2 * positionToAdjust + 1;

     return (indexOfLeftChild > lengthOfHeapArray) ? false : true;
 }

 //判断在最大下标为lengthOfHeapArray（为数组中元素个数-1）的数组中，下标为positionToAdjust的元素是否有右子树
 bool IsHasRightChild(const size_t lengthOfHeapArray,const size_t positionToAdjust)
 {
     size_t indexOfRightChild = 2 * positionToAdjust + 2;

     return (indexOfRightChild > lengthOfHeapArray) ? false : true;
 }

  //数组下标以1开始时，下标为i的结点的左子树下标为2i,左子树下标为2i+1
 //数组下标以0开始时，下标为i的结点的左子树下标为2i+1,左子树下标为2i+2
 //调用函数要保证positionToAdjust是小于
 void HeapAdjust(DataType heapArray[],const size_t lengthOfHeapArray,const size_t positionToAdjust)
 {
    DataType leftChildIndex = 2 * positionToAdjust + 1;
    DataType rightChildIndex = 2 * positionToAdjust + 2;

    size_t positionOfMax = positionToAdjust;   //只用positionOfMax记录最大数的下标即可

    if ( !IsHasLeftChild(lengthOfHeapArray,positionToAdjust)     //若为叶节点，直接返回
        && !IsHasRightChild(lengthOfHeapArray,positionToAdjust) )
    {
        return;
    }
         
    if ( IsHasLeftChild(lengthOfHeapArray,positionToAdjust)   
        && heapArray[leftChildIndex] > heapArray[positionOfMax])
    {
        //max = heapArray[leftChildIndex];
        positionOfMax = leftChildIndex;
    }

    if ( IsHasRightChild(lengthOfHeapArray,positionToAdjust) 
        && heapArray[rightChildIndex] > heapArray[positionOfMax])
    {
        //max = heapArray[rightChildIndex];
        positionOfMax = rightChildIndex;
    }

    if ( positionOfMax == positionToAdjust )    //结点大于左子树与右子树，不需调整
    {
        return;
    }
    else
    {
        //swap(heapArray[positionToAdjust],max);
        swap(heapArray[positionToAdjust],heapArray[positionOfMax]);
        HeapAdjust(heapArray,lengthOfHeapArray,positionOfMax);
    }
 }

 //堆排序,lengthOfHeapArray为数组的最大下标为（为数组中元素个数-1）
 void HeapSort(DataType heapArray[],const size_t lengthOfHeapArray)
 {
    assert(NULL != heapArray);
    //size_t index;  //使用size_t类型，下面的for循环不能结束0 - 1 = 2^32 - 1
    int index;
    
    for (index = (lengthOfHeapArray - 1)/2;index >= 0;--index)
    {
        HeapAdjust(heapArray,lengthOfHeapArray,index);
    }

    for (index = lengthOfHeapArray;index > 0;--index)
    {
        swap(heapArray[0],heapArray[index]);
        HeapAdjust(heapArray,index - 1,0);  //不是HeapAdjust(heapArray,lengthOfHeapArray,0);
    }
 }

 //产生在[lowBound,upperBound - 1]区间的随机数
 int RandomIntGenerate(int lowBound, int upperBound)
 {    
     return (lowBound + (RAND_MAX * rand() + rand()) % (upperBound - lowBound + 1) );
 }

 //测试“脚手架”
void TestDriver()
{    
    DataType *unsortedArray = new int[MaxSize];
    size_t lengthOfUnsortedArray = 0;
    int MinRandomInt;
    int MaxRandomInt;
    size_t i;
    int timeStart = 0;
    double timeCostAverage = 0;

    DataType *heapArray = unsortedArray;
    //size_t lengthOfHeapArray = lengthOfUnsortedArray;  //若lengthOfUnsortedArray未初始化，不能将其赋给其他变量，否则报错
    size_t *lengthOfHeapArray = &lengthOfUnsortedArray;

    cout<<"please enter the length Of UnsortedArray,MinRandomInt and MaxRandomInt :"<<endl;
    cin>>lengthOfUnsortedArray>>MinRandomInt>>MaxRandomInt;
    
    srand((unsigned) time(NULL));   //随机数产生的seed
    for (i = 0;i < lengthOfUnsortedArray;++i)  //准备待排序数组
    {
        //srand((unsigned) time(NULL));   //随机数产生的seed,不能放在循环体内，否则unsortedArray将会是全部相同的数
        unsortedArray[i] = RandomIntGenerate(MinRandomInt,MaxRandomInt);
    }

    /*cout<<"the unsorted array is :"<<endl;
    DisplayArray(unsortedArray,lengthOfUnsortedArray);*/
    timeStart = clock();

    HeapSort(heapArray,*lengthOfHeapArray - 1);
    
    timeCostAverage = 1e9 * ( clock() - timeStart ) / ( CLOCKS_PER_SEC * lengthOfUnsortedArray );
    cout<<"the average time cost per data is : "<<timeCostAverage<<" ns"<<endl;

    for (i = 0;i < lengthOfUnsortedArray - 1;++i)  //检查排序是否正确
    {
        if (unsortedArray[i] > unsortedArray[i + 1])
        {
            cout<<"sort bug i = "<<i<<endl;
        }
    }

    //cout<<"the sorted array is :"<<endl;
    //DisplayArray(unsortedArray,lengthOfUnsortedArray);

    //cout<<endl;
        
    delete [] unsortedArray;
}

//使用脚手架的测试程序
int main(void)
{
    TestDriver();
    return 0;
}

输入10个元素时，运行结果为：

please enter the length Of UnsortedArray,MinRandomInt and MaxRandomInt :
10 0 100
the unsorted array is :
20      34      24      36      5       43      6       92      75      82

the average time cost per data is : 0 ns
the sorted array is :
5       6       20      24      34      36      43      75      82      92

请按任意键继续. . .

可通过增加输入个数，测试时间性能，此处不再给出，后面在与其他算法进行比较。