写个堆排序，快速排序等一些排序算法

堆排序

堆的存储数据结构就是一个数组，根据当前元素的index，可以计算出其父节点和子节点的index。

首先要建立一个堆，具体过程是按照完全二叉树的方式不断插入新元素，并同时向上调整堆。

然后做堆排序，具体过程是取出堆顶元素，和最后一个元素交换，同时做堆的向下调整。

如果是大顶堆，每次都取出堆顶元素和最后一个元素交换，最后就能得到一个从小到到的排序。

代码如下：

//大顶堆:按从小到大顺序输出
template <class T>
void insertBigHeap(T *arr, int i, int from, int end)
{
int hFrom = 0;
int hEnd = end - from;
int hIndex = i - from;
int hParentIndex = (hIndex - 1)/2;

if( !(i >= from && i <= end) )
{
printf("build heap condition error. when insertSmallHeap..");
return;
}

if(hIndex == hFrom)//fisrt element for insert.
{
return;
}
else
{
while(hIndex > 0)
{
if(arr[from + hIndex] <= arr[from + hParentIndex])
{
break;
}
swap(&arr[from + hIndex], &arr[from + hParentIndex]);
hIndex = hParentIndex;
hParentIndex = (hIndex - 1)/2;
}
}
}

template <class T>
void buildBigHeap(T *arr, int size, int from, int end)
{
int i;

for(i=from; i<=end; i++)
{
insertBigHeap(arr, i, from, end);
}
}

/*

arr为数组

size为数组大小

from为数组中起始位置

end为数组中结束位置

*/
template <class T>
void bigHeapSorting(T *arr, int size, int from, int end)
{
int hIndex = 0;
int hChild = 2*hIndex + 1;
int hEnd = end - from;

if((arr == NULL) || (from > end) || (end >= size))
{
printf("build heap condition error. when buildSmallHeap..");
return;
}

buildBigHeap(arr, size, from, end);

while(from < end)
{
for(int x=from; x<=end; x++)
{
printf("---%d", arr[x]);
}
printf("\n");
swap(&arr[from], &arr[end]);
printf("------arr[%d] = %d\n", end, arr[end]);

while(hChild <= hEnd -1)
{
if((hChild + 1 <= hEnd - 1) && (arr[from + hChild + 1] >= arr[from + hChild]))
{
hChild++;
}
if((arr[from + hIndex] >= arr[from + hChild]))
{
break;
}
swap(&arr[from + hIndex], &arr[from + hChild]);
hIndex = hChild;
hChild = 2*hIndex + 1;
}

hIndex = 0;
hChild = 2*hIndex + 1;
end--;
hEnd = end - from;
}

}

快速排序：

在一个数组中取出第一个元素作为元素的分割，使得其左边的元素都小于它，其右边的元素都大于它。

方法是在数组的两端定义出相应的指针，前面的指针向后扫描找到比标杆元素小的则向后移动，否则立刻与标杆调换。后面的指针向前移动直到遇到比标杆小的元素发生调换。

这样直到这两个指针重逢，就会以标杆为分界线，划分出一小一大的两头。

最后在对这两头做同样的递归处理，就完成了快速排序。

代码：

//快速排序
template <class T>
T * quickSorting(T *arr, int size, int from, int end)
{
int i = from, j = end;
T temp = arr[i];

if((arr == NULL) || (end >= size))
{
printf("%s", "sorting condition error.");
return NULL;
}

if(from >= end)//只有一个元素，或者from大于end
{
return arr;
}

while(i < j)
{
while((temp <= arr[j]) &&  (i < j)) j--;
swap(&arr[i], &arr[j]);
while((temp >= arr[i]) &&  (i < j)) i++;
swap(&arr[i], &arr[j]);
}

if(i == j)
{
quickSorting(arr, size, from, i-1);
quickSorting(arr, size, i+1, end);
}

return arr;
}