常用排序模板

插入排序new

int arr[10]={3,1,2,8,7,5,9,4,6,0};
for(int i = 1; i < 10; i++){
       int t = arr[i], j = i-1; //先保存i位置上的值 然后值后移
	while(j >= 0 && arr[j] > t){ 
		arr[j+1] = arr[j];
		j--;
	}
	arr[j+1] = t;
}

归并排序new

int arr[N], tmp[N];
void mergesort(int l, int r){
	if(l >= r) return;
	int mid = l + r >> 1;
	mergesort(l, mid), mergesort(mid+1, r);
	int k = 0, i = l, j = mid + 1;
	while(i <= mid && j <= r){  //注意这里是等号
		if(arr[i] < arr[j]) tmp[k++] = arr[i++];
		else tmp[k++] = arr[j++];
	}
	while(i <= mid) tmp[k++] = arr[i++]; //同理这里的等号
	while(j <= r) tmp[k++] = arr[j++];  //等号
	
	for(int i = l, j = 0; i <= r; i++, j++){
		arr[i] = tmp[j];
	}
}

快速排序new

void quickSort(int l, int r){
	if(l >= r) return;
	int x = arr[l+r>>1], i = l - 1, j = r + 1;
	while(i < j){ //注意这里别写成了l和r 这里千万不能写等于 否则会出错
		while(arr[++i] < x);
		while(arr[--j] > x);
		if(i < j) swap(arr[i], arr[j]); //注意这里有个条件判断
	}
	quickSort(l, j);
	quickSort(j+1, r);	
}

冒泡排序

void bubbleSort(int arr[], int n){
	for(int i = 0; i < n - 1; i++){
		for(int j = 1; j < n - i; j++){
			if(arr[j-1] > arr[j]) swap(arr[j-1], arr[j]);
		}
	}
}

插入排序

void insertSort(int arr[], int n){
	for(int i = 1; i < n; i++){
		int tmp = arr[i];
		int j = i;
		while(j >= 0 && arr[j] >= tmp) arr[j] = arr[--j];
		arr[j + 1] = tmp;
	}
}

选择排序

void selectSort(int arr[], int n){
	for(int i = 0; i < n; i++){
		int k = i;
		for(int j = i+1; j < n; j++){
			if(arr[k] > arr[j]) k = j;
		}
		swap(arr[i], arr[k]);
	}
}

堆排序

建议去B站看正月点灯笼的视频

void heapify(int arr[], int n, int i){
	if(i >= n) return ;
	int l = 2 * i + 1;
	int r = 2 * i + 2;
	int max = i;
	if(l < n && arr[l] > arr[max]) max = l;
	if(r < n && arr[r] > arr[max]) max = r;
	if(max != i){
		swap(arr[i], arr[max]);
		heapify(arr, n, max); //max代表的就是左右孩子的下标 
	}
}
void heapSort(int arr[], int n){
	int last_node = n - 1;
	int parent = (last_node - 1) / 2;
	
	for(int i = parent; i >= 0; i--){ //调整堆 
		heapify(arr, n, i);
	}
	for(int i = n - 1; i >= 0; i--){
		swap(arr[0], arr[i]);
		heapify(arr, i, 0); //0~i之间的数进行调整 
	} 
} 

快速排序

int partition(int arr[], int L, int R){
	int tmp = arr[L];
	while(L < R){
		while(L < R && arr[R] > tmp) R--;
		arr[L] = arr[R];
		while(L < R && arr[L] <= tmp) L++;
		arr[R] = arr[L]; 
	}
	arr[L] = tmp;
	return L;
} 
void quickSort(int arr[], int L, int R){
	if(L < R){
		int mid = partition(arr, L, R);
		quickSort(arr, L, mid - 1); //对左子区间递归 
		quickSort(arr, mid + 1, R); //对右子区间递归 
	}
}

归并排序

注意$i$和$j$的下标判断是取等号

void merge(int arr[], int L1, int R1, int L2, int R2){
	int t[R2-L1 + 2], id  = 0;
	int i = L1, j = L2;
	while(i <= R1 && j <= R2){
		if(arr[i] < arr[j]){
			t[id] = arr[i];
			id++, i++;
		}else{
			t[id] = arr[j];
			id++, j++;
		}
	}
	while(i <= R1) t[id] = arr[i], id++, i++;
	while(j <= R2) t[id] = arr[j], id++, j++;
	for(int k = 0; k < id; k++){
		arr[L1 + k] = t[k];
	}
}
void mergeSort(int arr[], int L, int R){
	if(L < R){
		int mid = (L + R) >> 1;
		mergeSort(arr, L, mid);
		mergeSort(arr, mid + 1, R);
		merge(arr, L, mid, mid + 1, R);
	}
}

主函数

int main(){
	int arr[]={1,7,5,3,6,4,2,0,0};
	int n = 9;
//	bubbleSort(arr, n);
//	insertSort(arr, n);
//	selectSort(arr, n);
//	mergeSort(arr, 0, n - 1); //左右边界 
//	heapSort(arr, n);
	quickSort(arr, 0, n - 1);
	for(auto x: arr){
		cout<<x<<" ";
	}
	return 0;
}