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;
        }
    }    
}
 

基本思想：首先將陣列的第一個數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的後面 
        } 
    } 
}

基本思想：通過一個逐漸減小的增量使一個數組逐漸趨近於有序從而達到排序的目的。

時間複雜度：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;
        } 
    } 
}

基本思想：記錄區的分為無序區和有序區前後兩部分；用無序區的數建大根堆，得到的根（最大的數）和無序區的最後一個數交換，

也就是將該根歸入有序區的最前端；如此重複下去，直至有序區擴充套件至整個記錄區。

時間複雜度：O(n*log2n)

空間複雜度：O(1)