算法——8种排序算法的总结(冒泡排序、快速排序、简单插入排序、希尔排序、简单选择排序、二路归并排序、基排序、桶排序)

常见的排序算法可以分为两大类：

• 非线性时间比较类排序：通过元素比较来决定它们的相对次序，它的时间复杂度不能突破O(nlogn)。
• 线性时间非比较类排序：不通过比较决定元素的相对次序，它可以突破比较排序的时间下界，以线性时间运行。

以下依次介绍：冒泡排序、快速排序、简单插入排序、希尔排序、简单选择排序、二路归并排序、基排序、桶排序。

冒泡排序

重复走访要排序的数列，每次比较相邻的两个元素，如果顺序错误就交换它们的顺序，直到没有再需要交换的元素。这样每一次比较完之后最大的数都会“沉”到下面。

代码实现：

#include <stdio.h>
int arr[10000];
void BubbleSort(int length){//冒泡排序 
	int i,j;
	int tempt;
	for(i=0;i<length;i++){//外层循环控制比较趟数
		for(j=0;j<length-1-i;j++){//内层循环控制每趟比较的次数
			if(arr[j]>arr[j+1]){//交换顺序 
				tempt=arr[j];
				arr[j]=arr[j+1];
				arr[j+1]=tempt;	
			}
		}
	}
}
int main(void){
	int i;
	int length;
	int N;
	scanf("%d",&N); //输入待排序数组的长度
	for(i=0;i<N;i++){
		scanf("%d",&arr[i]);
	}
	length=N;
	BubbleSort(length);
	for(i=0;i<length;i++){
		printf("%d ",arr[i]);
	}
	return 0;
}

快速排序

通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

代码实现：

#include <stdio.h>
int arr[10000];
void QuickSort(int arr[],int low,int high){
	if(low<high){
		int i=low;
		int j=high; 
		int key=arr[low];//选择一个基准
		while(i<j){
		//比基准大的元素放在基准的右边，比基准小的放在左边
				while(arr[j]>=key && j>i){
					j--;
				}
				if(j>i){
					arr[i++]=arr[j];
				}
				while(arr[i]<=key && i<j){
					i++;
				}
				if(i<j){
					arr[j]=arr[i];
				}
			}
		arr[i]=key;
		QuickSort(arr,low,i-1);
	    QuickSort(arr,i+1,high);
	}
}
int main(){
	int N;
	int length;
	scanf("%d",&N);
	length=N;
	int i,j;
	for(i=0;i<length;i++){
		scanf("%d",&arr[i]);
	}
	QuickSort(arr,0,length-1);
	for(i=0;i<length;i++){
		printf("%d ",arr[i]);
	}	
	return 0;
}

以上两种方法都属于交换排序

简单插入排序

构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

代码实现：

#include <stdio.h>
int arr[10000];
void InsertSort(int arr[],int length){
	int i,j;
	for(i=1;i<length;i++){
		j=i-1;
		int tempt;
		tempt=arr[i];
		while(j>=0 && arr[j]>tempt){
			arr[j+1]=arr[j];
			j--; 
		}
		arr[j+1]=tempt;
	}
}

int main(){
	int N;
	int length;
	scanf("%d",&N);
	length=N;
	int i,j;
	for(i=0;i<length;i++){
		scanf("%d",&arr[i]);
	}
	InsertSort(arr,length);
	for(i=0;i<length;i++){
		printf("%d ",arr[i]);
	}	
	return 0;
}

希尔排序

每趟排序，根据计算的的增量将待排序序列分割成若干相应长度的子序列，对子序列分别进行直接插入排序

代码实现：

#include <stdio.h>
int arr[1000];
void ShellSort(int arr[],int length){
	int i,j,m;
	int gap;//希尔增量 
	int tempt;
	for(gap=length/2;gap>0;gap=gap/2){//每次排序后进行分组 
		for(i=0;i<gap;i++){
			for(j=i+gap;j<length;j=j+gap){//单独一次的插入排序
				if(arr[j]<arr[j-gap]){
					tempt=arr[j];
					m=j-gap;
					while(m>=0 && arr[m]>tempt){
						arr[m+gap]=arr[m];
						m=m-gap;
					}
					arr[m+gap]=tempt;
				}
			}
		}
	}
}

int main(){
	int length;
	int N;
	scanf("%d",&N);
	length=N;
	int i,j;
	for(i=0;i<length;i++){
		scanf("%d",&arr[i]);
	}
	ShellSort(arr,length);
	for(i=0;i<length;i++){
		printf("%d ",arr[i]);
	}	
	return 0;
}

以上两种属于插入排序

简单选择排序

首先在未排序序列中找到最小(或最大)元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小(或最大)元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

代码实现：

#include <stdio.h>
int arr[10000];
void SelectionSort(int arr[],int length){
	int i,j,m,tempt;
	for(i=0;i<length-1;i++){
		m=i;
		for(j=i+1;j<length;j++){
			if(arr[j]>arr[m]){//最终结果从大到小排序
				m=j;
			}
		}	
		if(m!=i){
			tempt=arr[i];
			arr[i]=arr[m];
			arr[m]=tempt;
		}
	}
} 

int main(){
	int N;
	int length;
	scanf("%d",&N);
	length=N;
	int i,j;
	for(i=0;i<length;i++){
		scanf("%d",&arr[i]);
	}
	SelectionSort(arr,length);
	for(i=0;i<length;i++){
		printf("%d ",arr[i]);
	}	
	return 0;
}

二路归并排序

采用分治法，将整个输入序列分成两个长度相等的子序列，先使每个子序列有序，再将两个排序好的子序列合并成最终的排序序列。

代码实现：

#include<stdio.h>
void merge(int arr[],int start,int mid,int end){
	int result[50];
	int k=0;
	int i=start;
	int j= mid + 1;
	while(i<=mid && j<=end){
		if(arr[i]<arr[j]){
			result[k++]=arr[i++];
		}
		else{
			result[k++]=arr[j++];
		}
	}
	if(i==mid+1){
		while(j<=end){
			result[k++]=arr[j++];
		}
	}
	if(j==end+1){
		while(i<=mid){
			result[k++]=arr[i++];
		}
	}
	for(i=start,j=0;j<k;i++,j++){
		arr[i]=result[j];
	} 
}

void mergeSort(int arr[],int start,int end){
	if (start>=end){//如果为空序列就返回为空 
		return;
	} 
	int mid=(start+end)/2;
	mergeSort(arr,start,mid);
	mergeSort(arr,mid+1,end);
	merge(arr,start,mid,end);

}

 int main(){
	int i;
	int N;
	int arr[1000];
	scanf("%d",&N); 
	for(i=0;i<N;i++){
		scanf("%d",&arr[i]);
	}
	mergeSort(arr,0,N);
	for(i=0;i<N;i++){
		printf("%d ",arr[i]);
	}
	return N;
}

基排序

这里采用最低位优先，也可以采用最高位优先

1. 序列中元素位数最大为多少就需要排几趟，例如：最大为3位数，则需要排三趟。
2. 假设待排序列中有m个数，我们就需要10个m长度的数组arr[m]用来暂存这些需要排的数,例如：第1趟，个位数为0的会被分配到第一个数组里，个位数为1的数会被分配到第二个数组里。
3. 取出元素时按照先进先出的原则，依次从第一个到第10个（0~9）数组中取出，循环n趟结束

代码实现：

#include<stdio.h>
#include<stdio.h>
#include<stdlib.h>   
#define RADIX 10    
#define BASE 10     

int getNum(int num,int pos){
	int temp = 1;
	for (int i=0;i<pos-1;i++){ 
		temp*=10;
    } 
	return (num/temp)%10;
}
 
void RadixSort(int* p, int m){
	int *Array[RADIX];    
	for (int i=0;i<10;i++){//0~9
		Array[i]=(int *)malloc(sizeof(int)*(m+1));
		Array[i][0]=0; //数组初始化 
	}
	for (int pos=1;pos<=BASE;pos++){
		for (int i=0;i<m;i++)    {
			int num=getNum(p[i],pos);
			int index=++Array[num][0];
			Array[num][index]=p[i];
		}
		for(int i=0,j=0;i<RADIX;i++){
			for(int k=1;k<=Array[i][0];k++){
				p[j++]=Array[i][k];
			}	
			Array[i][0]=0; //复位
		}
	}
}

int main(){   
	int N;
    scanf("%d",&N);
    int arr[N];
    for(int s=0;s<N;s++){
    	scanf("%d",&arr[s]);
	}  
    RadixSort(arr,N);
    for(int i=0;i<N;i++){
		printf("%d ",arr[i]);
	}
    return 0;
}

桶排序

1. 利用函数映射关系
2. 设置一个定量的数组当作空桶；
3. 遍历输入数据，并且把数据一个一个放到对应的桶里去；
4. 对每个不是空的桶进行排序；从不是空的桶里把排好序的数据拼接起来。

代码实现：

#include<stdio.h>
int max(int* arr,int N){//找出待排数组中最大的元素 
	int max1=arr[0];
	for(int i=1;i<N;i++){
		if(arr[i]>max1){
			max1=arr[i];
		}
	}
	return max1;
}

void BucketSort(int arr[],int N){
	int i,j;
	int maxlen=max(arr,N)+1;
	int tmp[maxlen];//空桶大小 
	for(i=0;i<maxlen;i++){//空桶初始化 
		tmp[i]=0;
	}
	for(i=0;i<N;i++){//寻访序列，把元素放到对应的桶中 
		tmp[arr[i]]++;
	}
	for(i=0,j=0;i<maxlen;i++){
		while(tmp[i]!=0){
			arr[j]=i;
			j++;
			tmp[i]--;
		}
	}
}

int main(){
	int i;
	int N;
	int arr[1000];
	scanf("%d",&N); 
	for(i=0;i<N;i++){
		scanf("%d",&arr[i]);
	}
	BucketSort(arr,N);
	for(i=0;i<N;i++){
		printf("%d ",arr[i]);
	}
	return 0;
}