本文已参与「新人创作礼」活动，一起开启掘金创作之路。

文章目录

• 插入排序
• • 直接插入排序--稳定
  • 折半插入排序--稳定
  • 希尔排序--不稳定
• 交换排序
• • 冒泡排序--稳定
  • 快速排序--不稳定
• 选择排序
• • 直接选择排序--不稳定
  • 堆排序--不稳定
• 归并排序 --稳定
• 基数排序--稳定

插入排序

直接插入排序–稳定

最好情况O(n)
平均情况O(n2)
最坏情况O(n2)

void insertsort(Elemtype a[], int n){
	int i, j;
	for(int i = 2; i<=n; i++){
		if(a[i] < a[i-1]){
			a[0] = a[i];
			for(int j = i-1; a[0] < a[j]; --j){
				a[j+1] = a[j];
			}
			a[j+1] = a[0];
		}
	}
}

折半插入排序–稳定

O(n2)
比较次数：O(nlog2n)

void insertsort(Elemtype a[], int n){
	int i, j;
	int low, high, mid;
	for(int i = 2; i<=n; i++){
		if(a[i] < a[i-1]){
			a[i] = a[0];
			low = 1;
			high = i-1;
			while(low <= high){
				mid = (low + high) / 2;
				if(a[0] < a[mid])  high = mid - 1;
				else low = mid + 1;
			}
			for(int j = i-1; j>=high+1; j--){
				a[j+1] = a[j];
			}
			a[high+1] = a[0];
		}
	}
}

希尔排序–不稳定

增量系列：d1=n/2   di+1=di/2(向下取整)

void shellsort(Elemtype a[], int n){
	for(int dk = n/2; dk>=1; dk=dk/2){
		for(int i = dk+1; i<=n; i++){
			if(a[i] < a[i-dk]){
				a[0] = a[i];
				for(int j = i-dk; j>0&&a[j]>a[0]; j-=dk){
					a[j+dk] = a[j]; 
				}
				a[j+dk] = a[0];
			}
		}
	}
}

交换排序

冒泡排序–稳定

最好情况：O(n) :比较次数n-1 移动0次
最坏情况：O(n2) :需进行n-1趟 第i趟比较n-i次
平均情况：O(n2)

void bubblesort(Elemtype a[], int n){
	for(int i = 0; i<n-1; i++){
		int flag = false;
		for(int j = n-1; j>i; j--){
			if(a[j] < a[j-1]){
				swap(a[j], a[j-1]);
				flag = true;
			}
		}
		if(flag == false)
		
	}
}

快速排序–不稳定

最坏情况：O(n2)
最好情况：O(nlog2n)
空间复杂度：

• 最好情况：O(log2n)
• 最坏情况：O(n)
• 平均情况：O(log2n)

int partition(Elemtype a[], int low, int high){
	Elemtype p = a[low];
	while(low < high){
		while(high>low && a[high]>=p) high--;
		a[low] = a[high];
		while(low<high && a[low]<=p) low++;
		a[high] = a[low];
	}
	a[low] = p;
	
	return low;
}

void quicksort(Elemtype a[], int low, int high){
	if(low < high){
		int mid = partition(a, low, high);
		quicksort(a, low, mid-1);
		quicksort(a, mid+1, high);
	}
}

选择排序

直接选择排序–不稳定

平均O(n2) : 移动次数n(n-1)/2

void selectsort(Elemtype a[], int n){
	 int i, j;
	 for(i = 0; i<n-1; i++){
	 	int min = i;
	 	for(j = i+1; j<n; j++){
		 	if(a[j] < a[min]) min = j;
		 }
		 if(min != i)  swap(a[min], a[i]);
	 }
}

堆排序–不稳定

时间复杂度O(nlog2n) ：建堆时间O(n)，共需n-1次向下调整

void buildmaxHeap(Elemtype a[], int len){
	for(int i = len/2; i>0; i--)
		headAdjust(a, i, len);
}

void headAdjust(Elemtype a[], int k, int len){
	a[0] = a[k];
	for(int i = 2*k; i<=len; i*=2){
		if(i<len && a[i] < a[i+1])
			i++;
		if(a[0] >= a[i])  break;
		else {
			a[k] = a[i];
			k = i;
		} 
	}
	a[k] = a[0];
}

void heapsort(Elemtype a[], int len){
	buildmaxHeap(a, len);
	for(int i = len; i>0; i--){
		swap(a[i], a[1]);
		headAdjust(a, 1, i-1);
	}
}

归并排序 --稳定

时间复杂度：O(nlog2n) :每趟O(n),供需log2n趟(向下取整)
空间复杂度：O(n)

Elemtype *b = (Elemtype*)malloc((n+1)*sizeof(Elemtype));
void merge(Elemtype a[], int low, int mid, int high){
	int i, j, k;
	for(k = low; k<=high; k++){
		b[k] = a[k];
	}
	
	for(i = low, j = mid+1, k = i; i<=mid && j<=high; k++){
		if(b[i] < b[j])
			a[k] = b[i++];
		else
			a[k] = b[j++];
	}
	
	while(i <= mid)
		a[k++] = b[i++];
	while(j <= high)
		a[k++] = b[j++];
} 

void mergeSort(Elemtype a, int low, int high){
	if(low < high){
		int mid = (low+high) / 2;
		mergeSort(low, mid);
		mergeSort(mid+1, high);
		merge(a, low, mid, high);
	}
}

基数排序–稳定

时间复杂度O(d(n+r)) ：需进行d趟分配与收集，一趟分配需O(n),一趟收集需O®
high){
if(low < high){
int mid = (low+high) / 2;
mergeSort(low, mid);
mergeSort(mid+1, high);
merge(a, low, mid, high);
}