几种排序算法（面试时经常要考的）

第一种：冒泡排序法

算法思想：首先将第一个记录的关键字与第二个记录的关键字进行比较，若为逆序，则交换这两个记录的值，然后比较第二个记录和第三个记录的关键字，以此类推，直至第n-1个和第n个记录的关键字比较过为止；至此第一趟冒泡排序完成，对前n-1个记录的关键字按照第一趟的冒泡排序排序，依次循环，直到最后缩到第一个为止

程序源码：

void SelectSort(int data[],int n)
{
	int i , j , temp;
	for( i = 0;i<n;i++)
		for(j = 0;j<n-i-1;j++)
		{
			if(data[j]>data[j+1])
			{
				temp = data[j];
				data[j] = data[j+1];
				data[j+1] = temp;
			}
		}
}

第二种：简单排序法

算法思想：通过n-i次关键字之间的比较，从n-i+1个记录中选出最小关键字的记录，并和第i个记录进行交换，当i=n时所有记录有序排列

程序源码：

void SelectSort(int data[] , int n)
{
	int i,j,k,temp;
	for(i = 0;i<n-1;i++)
	{
		k = i;
		for(j=i+1;j<n;j++)
			if(data[j]<data[k])
				k = j;
			if(k!=i)
			{
				temp = data[i];
				data[i] = data[k];
                data[k] = temp;
			}
	}
}

第三种：希尔排序法,又称“缩小增量排序法”

算法思想：先将整个待排记录分成若干序列，然后分别进行直接插入排序，待整个序列中的记录基本有序时，再对全体记录进行一次直接插入排序。

程序源码：

void ShellSort(int data[],int n)
{
	int *delta , k,i,t,dk,j;
	k = n;
	/*从k=n开始，重复k=k/2运算，直到k=0，所得k值的序列作为增量序列存入delta*/
	delta = (int*)malloc(sizeof(int)*(n/2));
	i = 0;
	do
	{
		k = k/2;
		delta[i++] = k;
	}while(k>0);
	i = 0;
	while((dk=delta[i])>0)
	{
		for(k=delta[i];k<n;k++)
			if(data[k]<data[k-dk])/*将元素data[k]插入有序增量子表中*/
			{                     
				t = data[k];      /*备份待插入的元素，空出一个元素位置*/
				for(j = k-dk;j>=0&&t<data[i];j-=dk)
					data[j+dk] = data[j];/*寻找插入位置的同时元素后移*/
				data[j+dk] = t;/*找到插入位置，插入元素*/
			}
			++i;                /*取下一个增量值*/
	}
}

第四种：快速排序法

算法思想：通过一趟排序将待排的记录分割成独立的两个部分，其中一部分记录的关键字不大于（或不小于）另一部分记录的任意关键字，然后再分别对着两部分记录继续进行排序，以达到整个序列有序

程序源码：

void QuickSort(int data[],int low , int high)
{
 int i,prvotkey,j;
 if(low<high)
 {
        prvotkey = data[low];//以数组的第一个元素作为基本元素进行划分
  i = low;
  j = high;
  while(i<j)//从数组两端交替的向中间扫描
  {
   while(i<j&&data[j]>=prvotkey)
    j--;
   if(i<j)
   data[i++] = data[j];//比基准元素小的移到低下标段
   while(i<j&&data[i]<=prvotkey)
    i++;
   if(i<j)
    data[j--] = data[i];//比基准元素大的移到高下标段
  }

  data[i] = prvotkey;  //移动基准元素到正确位置
        QuickSort(data , low , i-1);//对前半个子表递归排序
  QuickSort(data , j+1 , high);//对后半个子表递归排序
 }

这几种算法中，希尔排序法虽然从代码上看好像比较繁琐，但是实际上时间复杂度最低，运行速度最快，时间复杂度为O(n^1.3);