6种经典排序算法整理

以下整理了几个比较经典的排序算法，同时也在机上尝试过几次都没问题了，希望对以后会有所帮助，若有不足之处，待改进！

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

/*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=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; jarray[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=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=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) && leftmiddle) && 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 (minleft)
	{
		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;
}