比较常用的排序算法总结

常用的排序

1. 冒泡排序
2. 选择排序
3. 插入排序
4. 桶排序
5. 希尔排序
6. 归并排序
7. 快速排序
8. 基数排序
9. 堆排序

第一 冒泡排序
由于简单直接上代码

for(int i=1;i<=n;i++){
	for(int j=i+1;j<=n;j++){
		if(a[i]>a[j]) swap(a[i],a[j]);//当前的数大于后面的数，交换
 	}
}

第二 选择排序
每次找到数组中最大或最小的数，将他与前面的数交换

for(int i=1;i<n;i++){
	mina=-1;//更新
	for(int j=i;j<=n;j++){
		if(a[j]<mina){
			mina=a[j];//更新
			der=j;//记录j的位置
		}
		swap(a[i],a[der]);//交换
	}
}

第三 插入排序

从当前位置向前看，如果前面的数比他大，就向后移，最后找到比他小的或者到数组最开始，赋值给该位置

for(int i=1;i<n;i++){
	temp=a[i];
	int j;
	for(j=i;j>0;j--){
		if(temp<a[j-1])   a[j]=a[j-1];
		else break;
	}
	a[j]=temp;
}

第四 桶排序
按照道理，桶排序不能简单地认为只是一种排序算法，因为他的运用范围很广
原理：将数字作为他的下标，记录该数字是否出现或者出现的次数（去重)

for(int i=1;i<=n;i++)  tong[a[i]]++;//累计a[i]出现的次数
for(int i=1;i<=N;i++){//N代表数的范围，不是n
	if(tong[i]) cout<<i;//去重
}

第五 希尔排序
又称为最小增量排序
关键思想：分组思想

1. 先取定一个小于n的整数d作为第一个增量，把表的全部记录分成d组
2. 所有距离为d1的倍数的记录放在同一组中，在各组内进行直接插入排序
3. 然后取第二个增量d2<d1
4. 重复上述的分组和排序，直至增量d＝1，即所有记录放在同一组中进行直接插入排序为止

for (gap = len / 2; gap > 0; gap /= 2) {  
    	for (i = 0; i < gap; ++i) { 
	        for (j = i + gap; j < len; j += gap) { 
	            temp = a[j];  
	            k = j - gap; 
	            while (k >= 0 && a[k] > temp) {
	                a[k + gap] = a[k]; 
	                k -= gap;
	            }
	            a[k + gap] = temp; 
	        }
	    }
    }

第六 归并排序
主要是用递归来实现，将一个数组分成左右两个部分，对左右两个部分分别排序，最后合并到一个数组内

void Merget_sort(int l,int r){
	if(l==r) return ;
	else{
		int mid=(l+r)/2;
		Merget_sort(l,mid);
		Merget_sort(mid+1,r);
		int i=l,j=r;
		int k=l;
		while(i<=mid&&j>=mid+1){
			if(a[i]>a[j]){
				b[k++]=a[j];
				j--;
			}
			else{
				b[k++]=a[i];
				i++;
			}
		}
		while(i<=mid) b[k++]=a[i++];
		while(j>=mid+1) b[k++]=a[j--];
		for(i=l;i<=r;i++) a[i]=b[i];
	}
} 

第七 快速排序
快速排序是通过比较关键码、交换记录，

1. 以某个记录为界(该记录称为支点)，将待排序列分成两部分

2. 一部分所有记录的关键码大于等于支点记录的关键码，另一部分所有记录的关键码小于支点记录的关键码

速度的快慢取决于关键字在数组中的相对大小

void  qsort(int l,int r){
	int base=a[l];
	int i=l,j=r;
	while(i<j){
		while(a[i]<=base&&i<j) i++;
		while(a[j]>=base&&j>i) j--;
		if(i<j) swap(a[i],a[j]);
	}
	a[l] = a[i];
	a[i] = base;
	qsort(l,i-1);
	qsort(i+1,r);
}

后面两个排序方法，由于篇幅问题，下次给出