排序算法小结

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