常见排序算法--c++实现

冒泡排序

void bubble_sort(vector<int>& a) {
	int n = a.size();
	for (int i = 0; i < n; i++) {
		bool hasSwaped = false;
		for (int j = 0; j < n - i - 1; j++) {
			if (a[j] > a[j + 1]) {
				swap(a[j], a[j + 1]);
				hasSwaped = true;
			}
		}
		if (!hasSwaped) break;
		for (int i = 0; i < n; i++) {
			cout << a[i] << " ";
		}	
		cout << endl;
	}
}

插入排序

void insert_sort(vector<int>& a) {
	int n = a.size();
	for (int i = 1; i < n; i++) {
		if (a[i] < a[i - 1]) {
			int t = a[i];
			for (int j = i - 1; j >= 0; j--) {
				if (a[j] <= t) {
					a[j + 1] = t;
					break;
				} else {
					a[j + 1] = a[j];
				}
				// 如果没有找到插入的位置, 则在本组的第一个位置插入
				if (j == 0) a[j] = t;
			}

		}
	}
}
void binary_insert_sort(vector<int>& a) {
	int n = a.size();
	for (int i = 1; i < n; i++) {
		for (int j = 0; j <= i - 1; j++) {
			cout << a[j] << " ";
		}
		cout << endl;
		// if (a[i] > a[i - 1]) continue;
		// a[i]可以插入到[0...i]
		int l = -1, r = i;
		while (l + 1 < r) {
			int m = (l + r) / 2;
			if (a[m] <= a[i]) l = m;
			else r = m;
		}
		printf("%d will insert at %d\n", a[i], r);
		// r为a[i]的待插入位置
		// 将 [r...i-1]位置的元素向后移动一格
		int t = a[i];
		for (int j = i - 1; j >= r; j--) {
			a[j + 1] = a[j];
		}
		a[r] = t;
		printf("\n");
	}
}

选择排序

void select_sort(std::vector<int>& a) {
	int n = a.size();
	// 第1轮在[0, n - 1]中选一个最小值
	// 第2轮在[1, n - 1]中选一个最小值
	// ...
	/// 第n-1轮在[n - 2, n - 1]中选一个最小值
	for (int i = 0; i < n - 1; i++) {
		int x = i;
		for (int j = i + 1; j < n; j++) {
			if (a[j] < a[x]) {
				x = j;
			}
		}
		if (i != x) swap(a[i], a[x]);
	}
}

堆排序

#include <bits/stdc++.h>
using namespace std;
struct Heap {
	vector<int> heap;
	Heap() {
		heap.push_back(-1);
	}
	// 插入元素后, 向上调整
	void push(int val) {
		heap.push_back(val);
		up(heap.size() - 1);
	}
	// 返回堆顶元素
	int top() {
		if (empty()) return -1;
		return heap[1];
	}
	// 弹出堆顶元素
	void pop() {
		if (empty()) return;
		swap(heap[1], heap.back());
		heap.pop_back();
		down(1);
	}
	bool empty() {
		return heap.size() == 1;
	}
	void down(int k) {
		int n = heap.size() - 1;
		while (2 * k <= n) {
			int x = 2 * k;
			if (x + 1 <= n && heap[x + 1] < heap[x]) x++;
			if (heap[k] <= heap[x]) break;
			swap(heap[k], heap[x]);
			k = x;
		}
	}
	void up(int k) {
		while (k > 1 && heap[k] < heap[k / 2]) {
			swap(heap[k], heap[k / 2]);
			k /= 2;
		}
	}
};
int main() {
	ifstream fin("data.txt");
	int n; fin >> n;
	Heap h;
	for (int i = 1; i <= n; i++) {
		int t; fin >> t;
		h.push(t);
	}
	while (!h.empty()) {
		int x = h.top();
		cout << x << " ";
		h.pop();
	}	
    return 0;
}

希尔排序

void shell_sort(vector<int>& a) {
	int n = a.size();
	for (int d = n / 2; d >= 1; d /= 2) {
		for (int i = d; i < n; i++) {
			if (a[i] < a[i - d]) {
				int t = a[i];
				for (int j = i - d; j >= 0; j -= d) {
					if (a[j] <= t) {
						a[j + d] = t;
						break;
					} else {
						a[j + d] = a[j];
					}
					// 如果没有找到插入的位置, 则在本组的第一个位置插入
					if (j / d == 0) a[j] = t;
				}
			}
		}
		for (int i = 0; i < n; i++) {
			cout << a[i] << " ";
		}
		cout << endl;
	}
}

快速排序

void quick_sort(vector<int>& a, int l, int r) {
	if (l >= r) return;
	swap(a[l], a[l + rand() % (r - l + 1)]);
	int x = a[l];
	int i = l, j = r;
	while (i < j) {
		while (i < j && a[j] > x) j--;
		if (i < j) a[i++] = a[j];
		while (i < j && a[i] < x) i++;
		if (i < j) a[j--] = a[i];
	}
	a[i] = x;
	quick_sort(a, l, i - 1);
	quick_sort(a, i + 1, r);
}

归并排序

// 合并2个升序数组
vector<int> merge(vector<int> v1, vector<int> v2) {
	vector<int> ans;
	int n = v1.size(), m = v2.size();
	for (int i = 0, j = 0; i < n || j < m; ) {
		if (j >= m || (i < n && v1[i] <= v2[j])) {
			ans.push_back(v1[i++]);
		} else {
			ans.push_back(v2[j++]);
		}
	}
	return ans;
}
void merge_sort(vector<int>& a) {
	int n = a.size();
	if (n == 1) return;
	int m = n / 2;
	vector<int> v1 = vector<int>(a.begin(), a.begin() + m);
	vector<int> v2 = vector<int>(a.begin() + m, a.end());
	merge_sort(v1); merge_sort(v2);
	a = merge(v1, v2);
}

计数排序

// n数组大小, m是数组元素的值域范围 [0~m]
// res用来临时存放每个元素的最终位置
int n, m = 1e5;
void counting_sort(vector<int>& a) {
	int n = a.size();
	vector<int> cnt(m + 1);
	for (int i = 0; i < n; i++) {
		cnt[a[i]]++;
	}
	for (int i = 1; i <= m; i++) {
		cnt[i] += cnt[i - 1];
	}
	vector<int> res(n);
	for (int i = n - 1; i >= 0; i--) {
		res[cnt[a[i]] - 1] = a[i];
		cnt[a[i]]--; 
	}
	a.assign(res.begin(), res.end());
}

基数排序

// n 是数组大小, m 是数字的位数
// 默认可以给 10^9数进行排序
int n, m = 10, sa[N]; 
// sa[i] : 第i个数在一轮中排完序后在位置
void counting_sort(vector<int>& v) {
	vector<int> cnt(10);
	int n = v.size();
	vector<int> rank(n);
	for (int i = 0; i < n; i++) {
		cnt[v[i]]++;
	}
	for (int i = 1; i <= 9; i++) {
		cnt[i] += cnt[i - 1];
	}
	// ❗❗❗
	// 上一轮排完序后位置为i的数在a[]中的位置为sa[i]
	// 求这个数的现在的rank
	for (int i = n - 1; i >= 0; i--) {
		rank[sa[i]] = cnt[v[sa[i]]] - 1;
		cnt[v[sa[i]]]--;
	}
	// r[i] 这个位置的数是原来a[]中第i个数
	// 对排完序后第i个位置, 求在a[]中的位置
	for (int i = 0; i < n; i++) {
		sa[rank[i]] = i;
	}
	// ❗❗❗
}
void radix_sort(vector<int>& a) {
	int n = a.size();
	// 初始: 
	for (int i = 0; i < n; i++) {
		sa[i] = i;
	}
	// 除10相当于截取数字的最后一位(个位)
	// 除100相当于截去数字的最后两位...
	vector<int> v(n);
	for (int i = 1, x = 1; i <= m; i++, x *= 10) {
		// x : 取出每个数字的第x位的值
		// 按第x个关键字计数排序
		for (int j = 0; j < n; j++) {
			v[j] = a[j] / x % 10;
		}
		// 每次计数排序只看数字的第x位
		counting_sort(v);
	}	
	// sa[i] : 排完序后位置为i的数原来在a[]中的位置
	//  r[i] : a[]中, 第i个位置的数, 在排完序后的位置
	// sa[r[i]] = i;
	vector<int> temp(n);
	for (int i = 0; i < n; i++) {
		temp[i] = a[sa[i]];
	}
	a.assign(temp.begin(), temp.end());
}