常用的排序算法汇总

1 冒泡排序

基本思想：两两比较待排序的数，发现反序时交换，直到没有反序为止。

时间复杂度：O(n2)

空间复杂度：O(1)

void BuruebbleSort(int* ary, int length)
{
	int i,j,temp;
	for (i=0; i<length-1; i++)
	{
		for (j=length-1; j>i; j--)
		{
			if(ary[i] > ary[j])
			{
				temp = ary[i];
				ary[i] = ary[j];
				ary[j] = temp;
			}
		}
	}
}

2 快速排序

基本思想：在待排序数列中任选出一个数作为基准，用这个基准数将数列划分为左右两个子区，使得左子区的数都不大于基准数，

而右子区的数都不小于基准数，至此完成第一次划分。如果左子区域不为空，则对它进行同样的划分，直至为空为止。

时间复杂度：O(n*log2n)

空间复杂度：O(log2n)~O(n)

public static void QUICKSORT(int[] N,int left,int right)
{
    //数组元素如果不大于一个就无需排序。
    if (left < right){
        int p = PARTITION(N, left, right);  //第一次划分
        QUICKSORT(N, left, p-1);    //递归处理左子区
        QUICKSORT(N, p+1, right);   //递归处理右子区
    }     
}
//划分
public static int PARTITION(int[] R, int left,int right)
{
    int i = left;
    int j = right;
    int temp = R[i];
    while (i != j){
        //从左往右扫描，查找第一个比基准数小的数
        while ((R[j] >= temp) && (i<j)){ 
            j--; 
        }
        if (i < j){ 
            //交换找到的数和基准数，由于基准数还需交换多次，所以暂时不用将temp->R[j]
            R[i] = R[j];
            i++;
        }
		
        while ((R[i] <= temp) && (i < j)){ 
            i++; 
        }
        if (i< j){ 
            R[j] = R[i];
            j--;
        }
    }
    //定位基准数
    R[i] = temp;
    return i;    
}

3 直接选择排序

基本思想：每次从无序数组中选出一个最小的出来，放到已排好序的数组的最后。

时间复杂度：O(n2)

空间复杂度：O(1)

public static void SELECTSORT(int[] R)
{   
    for (int i = 0; i < R.Length-1; i++)
    {
        int index = i;
        for (int j = i + 1; j < R.Length; j++)
        {
            if (R[j] < R[index])
            {
                index = j;
            }
        }
        //交换R[i]和R[index]
         if (index != i)
        {
            int t = R[i]; R[i] = R[index]; R[index] = t;
        }
    }    
}

4 插入排序

基本思想：首先将数组的第一个数sortArray[0]看成是有序的，然后从第二个元素开始和它前面的元素进行比较，如果比前面的某一个数打，

就交换。由于前面的元素是有序的，所以就使用序的元素的个数逐渐增大，知道等于n。

时间复杂度：O(n2)

空间复杂度：O(1)

public void Sort(int[] sortArray)
{
    int j = 0;
    int key = 0;   // key为哨兵 
    for (int i = 1; i < sortArray.Length; i++)     //[0..i-1]已经排好的有序列 
    {
        if (sortArray[i] < sortArray[i - 1])
        {
            key = sortArray[i];
            j = i - 1;
            while (j >= 0 && key < sortArray[j]) //当sortArray[i] ≥sortArray[j] 时终止 
            { 
                sortArray[j + 1] = sortArray[j];
                j--;
            }     
            sortArray[j + 1] = key;  //插入到j的后面 
        } 
    } 
}

5 希尔排序

基本思想：通过一个逐渐减小的增量使一个数组逐渐趋近于有序从而达到排序的目的。

时间复杂度：O

空间复杂度：O(1)

public void SortShell(int [] list)
 {
     int i;
     for(i=1;i<=list.Length/9;i=3*i+1);
     for(;i>0;i/=3)
     {
         for(int i=i+1;i<=list.Length;i+=inc)
        {
            int t=list[i-1];
            int j=i;
            while((j>inc)&&(list[j-inc-1]>t))
            {
                list[j-1]=list[j-inc-1];
                j-=inc;
            } 
            list[j-1]=t;
        } 
    } 
}

6 堆排序

基本思想：记录区的分为无序区和有序区前后两部分；用无序区的数建大根堆，得到的根（最大的数）和无序区的最后一个数交换，

也就是将该根归入有序区的最前端；如此重复下去，直至有序区扩展至整个记录区。

时间复杂度：O(n*log2n)

空间复杂度：O(1)