常见排序总结
冒泡排序
它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成
选择排序
首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
插入排序
它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
归并排序
将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序
快速排序
通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序
堆排序
构建堆，每次取最大值排序
代码如下
常见排序总结
#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("*********
")
#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)<<"]
"
#define debug2(x,y) cout<<"["<<#x<<" "<<(x)<<" "<<#y<<" "<<(y)<<"]
"
#define debug3(x,y,z) cout<<"["<<#x<<" "<<(x)<<" "<<#y<<" "<<(y)<<" "<<#z<<" "<<z<<"]
"
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 ? '
' : ' ');
}
for(int i = 0; i < n; i++) {
printf("%d%c", a[i], i == n - 1 ? '
' : ' ');
}
return 0;
}