排序算法小結

    1.冒泡排序：
這個大家都比較熟悉，實現也簡單。但它的複雜度爲O（n*n），看情況使


用。
常見實現(以從小到大爲例)：

for(int i = starti; i <=limiti; i++)
		for(int j = startj; j <=limitj; j++){
			if(data[i] > data[j])
				int temp = data[j];
				data[j] = data[i];
				data[i] = temp;
	}

     2.快速排序：
快速排序，隨便從數組中選定一個基準數，從左向右找出所有比它大的，從


右向左找出所有比它小的，交換兩個數的位置，最後形成，基準數兩邊分別是比它小


的和比它大的兩個區間，再對區間進行遞歸此過程。每次相當於基準數固定了它的位


置。（代碼實現的過程要將基準數換到任意一端，具體看代碼實現）。
快速排序的速度比冒泡排序快的原因，冒泡排序每次只比較相鄰的兩個數，


且第二趟的比較僅比第一趟少了一次。而快速排序第一趟就將區間分爲兩半，固定第


二個數的區間比第一趟少了很多，第三趟比第二趟少很多，所以快於冒泡。
常見實現（以從小到大爲例）：可以從兩頭，用兩個指針相對走,也有下面


這種，兩種差不多。

int partition(int *data, int start, int end)
{
	index = rand(start, end);
	swap(&data[index], &data[index]);
	
	int small = start -1;
	for(index = start; index<=end; ++index){
		if(data[index] <=data[end]){
			small++;
			if(small!=index){
				swap(&data[samll], &data[index]		


			}
		}
	}
	small++;
	swap(&data[samll], &data[end]);
	return samll;
}
	(上面這是一趟的遍歷，整個實現可以用遞歸,也可以改爲循環，下面是遞歸)
	void quicksort(int *data, int start, int end)
	{
		if(start==end)
			return ;
		int index = partition(data, start, end);
		if(index>start)
			quicksort(data, start, index -1);
		if(index<end)
			quicksort(data, index+1, end);
	}

    3.插入排序
數據序列已經有序，需要插入若干數據後使數據仍有序。時間複雜度爲O


(n*n)。每一步僅將一個待排序的記錄，按其關鍵碼值的大小出入到文件中適當的位置


上，直到全部插入完爲止。
分了直接插入、間接插入、二分插入。
代碼實現（來自網絡）：

	int i = 0;
    	int j = 0;
    	int tmp = 0;
    	for(i = 1;i<n;i++){
		tmp = num[i]; 
		j = i-1;
		while(j>=0&&tmp<num[j]){
			num[j+1] = num[j];
			j--;
		}
		num[j+1] = tmp;
	}

    4.歸併排序
速度僅次於快速排序，是穩定排序算法，時間複雜度爲O（N*logN）。
將序列分爲兩個子序列，把子序列化爲有序的序列，創建一個新的空組，將


兩個子序列中的數依次放入空數組中成爲新的有序序列，此過程不斷遞歸。
代碼實現（來自網絡）：

//將有二個有序數列a[first...mid]和a[mid...last]合併。  
void mergearray(int a[], int first, int mid, int last, int temp[])  
{  
    int i = first, j = mid + 1;  
    int m = mid,   n = last;  
    int k = 0;  
      
    while (i <= m && j <= n)  
    {  
        if (a[i] <= a[j])  
            temp[k++] = a[i++];  
        else  
            temp[k++] = a[j++];  
    }  
      
    while (i <= m)  
        temp[k++] = a[i++];  
      
    while (j <= n)  
        temp[k++] = a[j++];  
      
    for (i = 0; i < k; i++)  
        a[first + i] = temp[i];  
}  
void mergesort(int a[], int first, int last, int temp[])  
{  
    if (first < last)  
    {  
        int mid = (first + last) / 2;  
        mergesort(a, first, mid, temp);    //左邊有序  
        mergesort(a, mid + 1, last, temp); //右邊有序  
        mergearray(a, first, mid, last, temp); //再將二個有序數列合併  
    }  
}  
  
bool MergeSort(int a[], int n)  
{  
    int *p = new int[n];  
    if (p == NULL)  
        return false;  
    mergesort(a, 0, n - 1, p);  
    delete[] p;  
    return true;  
}  

    5.選擇排序
類似冒泡排序，先假設第一個爲最小元素，遍歷，找到最小的就將兩個位置


替換，保證第一個是最小的，第二趟從第二個開始，再第三趟。時間複雜度同冒泡。
代碼實現：

for(int i = start; i<end; i++)
			for(int j = i+1; i<=end; i++){
				if(data[j]<data[i])
					swap(&data[i], &data[j]);
		}