数据结构面试之十一——排序2(归并、快速、堆排序）

template <typename T>
void MergeSort(T a[], int N)
{
int*pTmpArray = new int
; //临时存储空间.转存用!
if(pTmpArray== NULL)
{
cout<< "Allocate Error!" << endl;
}
intfirst = 0;
intlast = N-1;
Dirvied(a,first,last,pTmpArray);
delete[]pTmpArray;
}

//合并数组
template <typename T>
void MergeArray(T a[], int first, int mid, int last, int tempArr[])
{
inti = first;
intj = mid+1;
intm = mid;
intn = last;
intk = 0;

//两数组都非空
while(i<= m && j <= n)
{
if(a[i]< a[j])
{
tempArr[k++]= a[i++];
}
else
{
tempArr[k++]= a[j++];
}
}

//以下两循环代表有一个数组已空。
while(i<= m)
{
tempArr[k++]= a[i++];
}
while(j<= n)
{
tempArr[k++]= a[j++];
}
//临时存储的元素转存到a数组中.
for(i = 0; i < k; i++)
{
a[first+i]= tempArr[i];  //注意此处的起点.
}
}

//分解[递归函数]
template <typename T>
void Dirvied(T a[], int first, int last,int tempArr[])
{
intmid;
if(first< last)
{
mid= (first + last)/2;
Dirvied(a,first,mid,tempArr);//左半部分.
Dirvied(a,mid+1,last,tempArr);//右半部分.
MergeArray(a,first,mid,last,tempArr);
}
}

//取枢轴，并按枢轴划分[左侧小于枢轴元素，右侧大于枢轴元素]
template <typename T>
int Partition(T a[], int left, int right)
{
swap(a[left],a[(left+right)/2]);//交换,取中间元素为枢轴元素.
T  pivot = a[left];             //暂存枢轴元素,用于比较
while(left< right)
{
while(left< right && a[right] >= pivot)
{
--right;
}
a[left]= a[right];           //[左]存储比枢轴元素小的值；

while(left< right && a[left] <= pivot)
{
++left;
}
a[right]= a[left];           //[右]存储比枢轴元素大的值；
}
a[left]= pivot;                 //存放枢轴的新位置
return left;
}

//递归函数
template <typename T>
void QuickCurve(T a[], int left, intright)
{
intpivotPos = 0;
if(left < right)
{
pivotPos= Partition (a,left,right); //获取枢轴分割后的位置，用以划分左右。
QuickCurve(a,left,pivotPos-1);  //右边界-1
QuickCurve(a,pivotPos+1,right);//左边界+1
}
}

//快排
template <typename T>
void QuickSort(T a[], int N)
{
QuickCurve(a,0,N-1);//left=0, right=N-1
}

template<typename T>
void heapAdjust(T arr[], int i, int N)
{
intj;
inttemp = arr[i];    //临时存储需要节点信息.
j= i*2+1;         //左孩子节点

while(j< N)
{
if(j+1< N && arr[j+1] < arr[j])
{
j++;                //取左右孩子中的小值.
}
if(arr[j]>= temp)
{
break;             //小顶堆，如果出现孩子节点值大，则终止循环.
}
//找寻是否存在孩子节点的孩子节点.
arr[i]= arr[j];
i= j;
j= 2*i + 1;
}//endwhile
arr[i]= temp; //存储新的位置.
}

//堆排序.
template<typename T>
void heapSort(T arr[], int N)
{
//构建小顶堆，初始是凌乱的，调整后成一个小顶堆
for(int i = N-1; i >= 0; i--)
{
heapAdjust(arr,i/2,N-1);//比较的位置从中间开始.
}

for(int  i = N-1; i >= 0; i--)
{
swap(arr[i],arr[0]);
heapAdjust(arr,0,i);  //终止的大小为i,每次只调整根节点即可。
}
}