经典排序算法

最近由于工作上的事情都处理的差不多，手头没啥任务；在就是一直对各种排序算法只有些模糊的概念，上学那会就没有

好好的学习和实际在机上操作过，所以在此特意整理了下这几个比较经典的排序算法，同时也在机上尝试过几次都没问题

了，希望对以后会有所帮助，若有不足之处，待改进！

别的也不想多说，直接上代码吧

/*function:交换两个数函数*/
void swap(int *num1, int *num2)
{
int temp;

temp = *num1;
*num1 = *num2;
*num2 = temp;
}

/*
冒泡排序算法
简单描述：在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两
个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。
冒泡排序是，算法时间复杂充0(n2)--[n的平方]
*/

void BobbleSort(int *array, int len)
{
int i, j ;

for(i=0; i<len; i++)
{
for(j=len-1; j>=i; j--)
{
if (array[i]>array[j])
{
swap(&array[i], &array[j]);
}
}
}
}

/*
选择排序算法
简单描述： 在要排序的一组数中，选出最小的一个数与第一个位置的数进行交换，然后在剩下
的数中再找最小的与第二个位置的数交换，如此循环到倒数第二个数和最后一个数比较为止
选择排序是不稳定的，算法复杂度0(n2)--[n的平方]
*/
void SelectSort(int *array, int len)
{
int i, j, k;
for(i=0; i<len; i++)
{
k = i;/*给记号赋值*/
for(j=i+1; j<len; j++)
{
if (array[k]>array[j])
{
k = j;/*是k总是指向最小元素*/
}
}
if (k != i)
{
swap(&array[k], &array[i]);
}
}
}

/*
插入排序算法
简单描述：插入法是一种比较直观的排序方法， 首先把数组头两个元素排好序，再依次把后面
元素插入适当的位置，把数组元素插完也就完成了排序
直接插入排序是稳定的。算法时间复杂度0(N2)--[N的平方]
*/
void InsertSort(int *array, int len)
{
int i, j, tmp;

for(i=1; i<len; i++)
{
j = i-1;
tmp = array[i]; /*tmp为要插入的元素*/
while(j>=0 && array[j]>tmp) /*从a[i-1]开始找比a[i]小的数，同时把数组元素向后移*/
{
array[j+1] = array[j];
j--;
}
array[j+1] = tmp;/*插入略小的数到数组中*/
}
}

/*
希尔排序算法
简单描述：首先是把相距k(k>=1)的那几个元素排好序，再缩小k的值（一般取其一半），再
排序，直到k=1时完成排序
希尔排序是不稳定的
*/
void ShellSort(int *array, int len)
{
int i,j, tmp, k;

k = len/2;/*间距值*/
while(k>=1)
{
for(i=k; i<len; i++)
{
tmp = array[i];
j = i-k;
while(j>=0 && array[j]>tmp)
{
array[j+k] = array[j];
j -= k;
}
array[j+k] = tmp;
}
k = k/2;/*缩小间距值*/
}
}

/*
快速排序算法
简单描述：是对冒泡排序的一种本质改进，基于思想是通过一趟扫描后，使得排序序列的长度
能大幅度地减少。在冒泡排序中，一次扫描只能确保最大数值的数移到正确位置，而待排序序
列的长度可能只减少1，快速排序通过一趟扫描，就能确保某个数（以它为基准点吧）的左边
各数都比它小，右边各数都比它大。然后又用同样的方法处理它左右两边的数，直到基准点
的左右只有一个元素为止。
快速排序可以用递归实现，也可以用栈化解递归实现
*/

void sort(int *array, int min, int len)
{
int left, right, middle;
int itmp;

left = min;
right = len;
middle = array[(min+len)/2];/*求中间值*/
do
{
while((array[left]<middle) && left<len)/*从左边扫描大于中间值的数*/
left++;
while((array[right]>middle) && right>min)/*从右边扫描大于中间值的数*/
right--;
if (left<=right)
{
/*itmp = array[left]	;
array[left] = array[right];
array[right] = itmp;*/
swap(&array[left], &array[right]);
left++;
right--;
}
}while(left<=right);

if (min<right)
{
sort(array, min, right);
}

if (len>left)
{
sort(array, left, len);
}
}

void QuickSort(int *array, int len)
{
sort(array, 0, len-1);
}

以下为提供测试算法程序，验证以上的代码的正确性：

#define MAX_LENGTH 20
void printArray(int *array)
{
int i;
for(i=0; i<MAX_LENGTH; i++)
{
if(array[i] != 0)
{
printf("%d ", array[i]);
}
}
printf("\n");
}

int main(int argc, char **argv)
{
int array[MAX_LENGTH] = {9,2,3,1,10,5,8,7,6,4};
printf("the array is:");
printArray(array);

//	BobbleSort(array, MAX_LENGTH); //冒泡排序
printf("After Bobble sort array is:");
printArray(array);

//	SelectSort(array, MAX_LENGTH); //选择排序
printf("After Select sort array is:");
printArray(array);

//	InsertSort(array, MAX_LENGTH); //插入排序
printf("After Insert sort array is:");
printArray(array);

ShellSort(array, MAX_LENGTH); //希尔排序
printf("After Shell  sort array is:");
printArray(array);

//	QuickSort(array,MAX_LENGTH); //快速排序
printf("After Quict  sort array is:");
printArray(array);
return 0;
}