常见排序总结

常见排序总结

冒泡排序

它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成

选择排序

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

插入排序

它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

归并排序

将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序

快速排序

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

堆排序

构建堆，每次取最大值排序

代码如下

常见排序总结

#include <set>
#include <map>
#include <stack>
#include <cmath>
#include <queue>
#include <cstdio>
#include <string>
#include <bitset>
#include <vector>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long LL;
typedef pair<int, int> pii;
typedef unsigned long long uLL;
#define ls rt<<1
#define rs rt<<1|1
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
#define bug printf("*********\n")
#define FIN freopen("input.txt","r",stdin);
#define FON freopen("output.txt","w+",stdout);
#define IO ios::sync_with_stdio(false),cin.tie(0)
#define debug1(x) cout<<"["<<#x<<" "<<(x)<<"]\n"
#define debug2(x,y) cout<<"["<<#x<<" "<<(x)<<" "<<#y<<" "<<(y)<<"]\n"
#define debug3(x,y,z) cout<<"["<<#x<<" "<<(x)<<" "<<#y<<" "<<(y)<<" "<<#z<<" "<<z<<"]\n"
const int maxn = 3e5 + 5;
const int INF = 0x3f3f3f3f;
const int mod = 1e9 + 7;
const double Pi = acos(-1);
LL gcd(LL a, LL b) {
	return b ? gcd(b, a % b) : a;
}
LL lcm(LL a, LL b) {
	return a / gcd(a, b) * b;
}
double dpow(double a, LL b) {
	double ans = 1.0;
	while(b) {
		if(b % 2)ans = ans * a;
		a = a * a;
		b /= 2;
	} return ans;
}
LL quick_pow(LL x, LL y) {
	LL ans = 1;
	while(y) {
		if(y & 1) {
			ans = ans * x % mod;
		} x = x * x % mod;
		y >>= 1;
	} return ans;
}
void bubble_sort(int a[], int n) {
	for(int i = 0; i < n - 1; i++) {
		for(int j = 0; j < n - i - 1; j++) {
			if(a[j] > a[j + 1]) {
				swap(a[j], a[j + 1]);
			}
		}
	}
}
void select_sort(int a[], int n) {
	for(int i = 0; i < n; i++) {
		int minIndex = i;
		for(int j = i + 1; j < n; j++) {
			if(a[j] < a[minIndex]) {
				minIndex = j;
			}
		}
		swap(a[i], a[minIndex]);
	}
}

void insert_sort(int a[], int n) {
	for(int i = 1; i < n; i++) {
		int index = i - 1;
		int val = a[i];
		while(index >= 0 && a[index] > val) {
			a[index + 1] = a[index];
			index--;
		}
		a[index + 1] = val;
	}
}
int division(int a[], int l, int r) {
	int i = l + 1;
	int j = r;
	int now = a[l];
	while(i <= j) {
		while(a[i] < now) i++;
		while(a[j] > now) j--;
		if(i < j) {
			swap(a[i++], a[j--]);
		} else {
			i++;
		}
	}
	swap(a[j], a[l]);
	return j;
}
void quick_sort(int a[], int l, int r) {
	if(l > r) return;
	int mid = division(a, l, r);
	quick_sort(a, l, mid - 1);
	quick_sort(a, mid + 1, r);
}
int b[maxn];
void merge_sort(int a[], int l, int r) {
	if(l == r) return;
	int mid = (l + r) >> 1;
	merge_sort(a, l, mid);
	merge_sort(a, mid + 1, r);
	int i = l;
	int j = mid + 1;
	int pos = 0;
	while(i <= mid && j <= r) {
		if(a[i] < a[j]) {
			b[pos++] = a[i++];
		} else {
			b[pos++] = a[j++];
		}
	}
	while(i <= mid) {
		b[pos++] = a[i++];
	}
	while(j <= mid) {
		b[pos++] = a[j++];
	}
	for(int i = 0; i < pos; i++) {
		a[i + l] = b[i];
	}
}
int len;
void insert(int a[], int i) {
	int left = i * 2 + 1;
	int right = i * 2 + 2;
	int MaxIndex = i;
	if(left < len && a[left] > a[MaxIndex]) {
		MaxIndex = left;
	}
	if(right < len && a[right] > a[MaxIndex]) {
		MaxIndex = right;
	}
	if(MaxIndex != i) {
		swap(a[i], a[MaxIndex]);
		insert(a, MaxIndex);
	}
}
void heap_sort(int a[], int n) {
	len = n;
	for(int i = len / 2; i >= 0; i--) {
		insert(a, i);
	}
	for(int i = n - 1; i > 0; i--) {
		swap(a[0], a[i]);
		len--;
		insert(a, 0);
	}
}
void init() {

}
int main() {
#ifndef ONLINE_JUDGE
	FIN
#endif
	int a[] = {9, 8, 7, 6, 6, 5, 4, 2, 1};
	int n = sizeof(a) / sizeof(int);
	for(int i = 0; i < n; i++) {
		printf("%d%c", a[i], i == n - 1 ? '\n' : ' ');
	}
	for(int i = 0; i < n; i++) {
		printf("%d%c", a[i], i == n - 1 ? '\n' : ' ');
	}
	return 0;
}