【11】排序

1. 排序的基本概念
	(1) 内排序和外排序
	(2) 算法的稳定性
2. 插入排序
	(1) 直接插入排序
		a. 时间复杂度
			[1] 最好情况：O(n)
			[2] 平均情况：O(n^2)
			[3] 最坏情况：O(n^2)
		b. 辅助空间复杂度
			O(1)
		c. 稳定
	(2) 折半插入排序
		a. 时间复杂度
			[1] 最好情况：O(n)
			[2] 平均情况：O(n^2)
			[3] 最坏情况：O(n^2)
		b. 辅助空间复杂度
			O(1)
		c. 稳定
3. 冒泡排序（bubble sort）
	(1) 时间复杂度
		a. 最好情况：O(n)
		b. 平均情况：O(n^2)
		c. 最坏情况：O(n^2)
	(2) 空间复杂度
		O(1)
	(3) 稳定
4. 简单选择排序
	(1) 时间复杂度
		a. 最好情况：O(n^2)
		b. 平均情况：O(n^2)
		c. 最坏情况：O(n^2)
	(2) 空间复杂度
		O(1)
	(3) 不稳定
5. 希尔排序（shell sort）
	(1) 时间复杂度
		O(n^(3/2))
	(2) 空间复杂度
		O(1)
	(3) 不稳定
6. 快速排序
	(1) 时间复杂度
		a. 最好情况：O(nlogn)
		b. 平均情况：O(nlogn)
		c. 最坏情况：O(n^2)
	(2) 空间复杂度
		O(logn)
	(3) 不稳定
7. 堆排序
	(1) 时间复杂度
		a. 最好情况：O(nlogn)
		b. 平均情况：O(nlogn)
		c. 最坏情况：O(nlogn)
	(2) 空间复杂度
		O(logn)
	(3) 不稳定
8. 二路归并排序（merge sort）
	(1) 时间复杂度
		a. 最好情况：O(nlogn)
		b. 平均情况：O(nlogn)
		c. 最坏情况：O(nlogn)
	(2) 空间复杂度
		O(n)
	(3) 稳定

插入排序对部分有序的序列效率很高

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N = 100010; 
int n, sz;
int q[N], w[N]; 
//直接插入排序 
void insert_sort(){
	for(int i = 1; i < n; i++){
		int t = q[i], j = i;
		while(j && q[j - 1] > t){
			q[j] = q[j - 1];
			j --;
		}
		q[j] = t;
	}
}
//折半插入排序
void binary_insert_sort(){
	for(int i = 1; i < n; i++){
		if(q[i - 1] <= q[i]) continue;
		int t = q[i];
		int l = 0, r = i - 1;
		while(l < r){
			int mid = l + r >> 1;
			if(q[mid] > t) r = mid;
			else l = mid + 1;
		}
		for(int j = i - 1; j >= r; j --)
			q[j + 1] = q[j];
		q[r] = t;
	}
} 
void bubble_sort(){
	for(int i = 0; i < n - 1; i++){
		bool has_swap = false;
		for(int j = n - 1; j > i; j--){
			if(q[j] < q[j - 1]){
				swap(q[j], q[j - 1]);
				has_swap = true;
			}
		}
		if(!has_swap) break;
	}
}
//简单选择排序 
void select_sort(){
	for(int i = 0; i < n - 1; i++){
		int k = i;
		for(int j = i + 1; j < n; j++)
			if(q[j] < q[k])
				k = j;
		swap(q[i], q[k]);
	}
}
//希尔排序 
void shell_sort(){
	for(int d = n / 3; d; d = d == 2 ? 1 : d / 3){
		for(int start = 0; start < d; start ++){
			for(int i = start + d; i < n; i += d){
				int t = q[i], j = i;
				while(j > start && q[j - d] > t){
					q[j] = q[j - d];
					j -= d;
				}
				q[j] = t;
			}
		}
	}
}
//快速排序 
void quick_sort(int l, int r){
	if(l >= r) return;
	int i = l - 1, j = r + 1, x = q[(l + r) / 2];
	while(i < j){
		do i++; while(q[i] < x);
		do j--; while(q[j] > x);
		if(i < j) swap(q[i], q[j]); 
	}
	quick_sort(l, j);
	quick_sort(j + 1, r);
}
void down(int u){
	int t = u;
	if(u * 2 <= sz && q[u * 2] > q[t]) t = u * 2;
	if(u * 2 + 1 <= sz && q[u * 2 + 1] > q[t]) t = u * 2 + 1;
	if(u != t){
		swap(q[u], q[t]);
		down(t);
	}
}
//堆排序，下标从1开始
void heap_sort(){
	sz = n;
	for(int i = n / 2; i; i --) down(i);
	for(int i = 0; i < n - 1; i ++){
		swap(q[1], q[sz]);
		sz --;
		down(1);
	}
}
//归并排序
void merge_sort(int l, int r){
	if(l >= r) return;
	int mid = l + r >> 1;
	merge_sort(l, mid), merge_sort(mid + 1, r);
	int i = l, j = mid + 1, k = 0;
	while(i <= mid && j <= r)
		if(q[i] <= q[j]) w[k++] = q[i++];
		else w[k++] = q[j++];
	while(i <= mid) w[k++] = q[i++];
	while(j <= r) w[k++] = q[j++];
	for(i = l, j = 0; j < k; i++, j++) q[i] = w[j];
} 
int main(){
	scanf("%d", &n);
	for(int i = 0; i < n; i++) scanf("%d", &q[i]);
//	insert_sort();
//	binary_insert_sort();
//	bubble_sort();
//	select_sort();
//	shell_sort();
//	quick_sort(0, n - 1);
//	heap_sort();
	merge_sort(0, n - 1);
	for(int i = 0; i < n; i++) printf("%d ", q[i]);
	return 0;
}