手撕常见的排序算法C++

常见的排序算法：

• 冒泡
• 选择排序
• 插入排序
• 插入排序优化
• 堆排序
• 归并排序
• 快速排序

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <list>
#include <algorithm>
#include <sstream>

using namespace std;

void printarr(int arr[], int n){
	for (int i = 0; i < n; ++i){
		cout << arr[i] << " ";
	}
	cout << endl;
}

void printvec(vector<int> arr, int n){
	for (int i = 0; i < n; ++i){
		cout << arr[i] << " ";
	}
	cout << endl;
}

/* 冒泡 */
void bubble_sort(int arr[], int n){
	for (int end = n - 1; end >= 0; --end){
		int sort_idx = 0;
		for (int begin = 1; begin <= end; ++begin){
			if (arr[begin - 1] > arr[begin]){
				swap(arr[begin - 1], arr[begin]);
				sort_idx = begin;
			}
		}
		end = sort_idx;
	}
}

void test_bubble_sort(){
	int arr[] = { 4, 3, 2, 1, 5, 6, 234, 657 };
	int n = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, n);
	cout << "bubble sort:" << endl;
	printarr(arr, n);
}

/* 选择 */
void selection_sort(int arr[], int n){
	for (int end = n - 1; end >= 0; --end){
		int max_idx = 0;
		for (int begin = 1; begin <= end; ++begin){
			if (arr[begin] > arr[max_idx]){
				max_idx = begin;
			}
		}
		swap(arr[max_idx], arr[end]);
	}
}

void test_selection_sort(){
	int arr[] = { 4, 3, 2, 1, 5, 6, 234, 657 };
	int n = sizeof(arr) / sizeof(arr[0]);
	selection_sort(arr, n);
	cout << "selection sort:" << endl;
	printarr(arr, n);
}

/* 插入 */
void insertion_sort(int arr[], int n){
	for (int end = 1; end < n; ++end){
		int cur = end;
		while (cur > 0 && arr[cur] < arr[cur - 1]){
			swap(arr[cur], arr[cur - 1]);
			cur--;
		}
	}
}

void test_insertion_sort(){
	int arr[] = { 4, 3, 2, 1, 5, 6, 234, 657 };
	int n = sizeof(arr) / sizeof(arr[0]);
	insertion_sort(arr, n);
	cout << "insertion sort:" << endl;
	printarr(arr, n);
}

/* 二分查找 */
int search(int arr[], int idx){
	int begin = 0;
	int end = idx;
	int val = arr[idx];

	while (begin < end)
	{
		int mid = (begin + end) >> 1;
		if (val < arr[mid]){
			end = mid;
		}
		else
		{
			begin = mid + 1;
		}
	}
	return begin;
}

/* 将数组的第src个元素插入到第des个元素位置 */
void insert(int arr[], int src, int des){
	int val = arr[src];
	for (int begin = src; begin > des; --begin){
		swap(arr[begin], arr[begin - 1]);
	}
	arr[des] = val;
}

/* 插入排序优化 */
void insertion_sort_opt(int arr[], int n){
	int end = n;
	for (int begin = 1; begin < end; ++begin){
		insert(arr, begin, search(arr, begin));
	}
}

void test_insertion_sort_opt(){
	int arr[] = { 4, 3, 2, 1, 5, 6, 234, 657 };
	int n = sizeof(arr) / sizeof(arr[0]);
	insertion_sort_opt(arr, n);
	cout << "insertion sort opt:" << endl;
	printarr(arr, n);
}

/* 堆排序 */
void heapify(int tree[], int n, int i){
	if (i >= n) return;

	int c1 = i * 2 + 1;
	int c2 = i * 2 + 2;
	int max_idx = i;

	if (c1 < n && tree[c1] > tree[max_idx]){
		max_idx = c1;
	}

	if (c2 < n && tree[c2] > tree[max_idx]){
		max_idx = c2;
	}

	if (max_idx != i){
		swap(tree[max_idx], tree[i]);
		heapify(tree, n, max_idx);
	}
}

void buid_heap(int tree[], int n){
	int last_node = n - 1;
	int parent = (last_node - 1) / 2;
	for (int begin = parent; begin >= 0; --begin){
		heapify(tree, n, begin);
	}
}

void heap_sort(int arr[], int n){
	buid_heap(arr, n);

	for (int begin = n - 1; begin >= 0; --begin){
		swap(arr[0], arr[begin]);
		heapify(arr, begin, 0);
	}
}

void test_heap_sort(){
	int arr[] = { 4, 3, 2, 1, 5, 6, 234, 657 };
	int n = sizeof(arr) / sizeof(arr[0]);
	heap_sort(arr, n);
	cout << "heap sort:" << endl;
	printarr(arr, n);
}

/* 归并排序 */
void merge(vector<int> &vec, int begin, int mid, int end){
	vector<int> copy(vec);

	int li = begin, le = mid;
	int ri = mid, re = end;
	int i = begin;

	while (li < le)
	{
		if (ri < re && copy[li] > copy[ri]){
			vec[i++] = copy[ri++];
		}
		else
		{
			vec[i++] = copy[li++];
		}
	}
}

void merge_sort(vector<int> &vec, int begin, int end){
	if (end - begin < 2) return;

	int mid = (begin + end) >> 1;
	merge_sort(vec, begin, mid);
	merge_sort(vec, mid, end);

	merge(vec, begin, mid, end);
}

void test_merge_sort(){
	vector<int> vec = { 4, 3, 2, 1, 5, 6, 234, 657 };
	merge_sort(vec, 0, vec.size());
	cout << "merge sort:" << endl;
	printvec(vec, vec.size());
}


/* 快速排序 */
int partition(vector<int> &vec, int begin, int end){
	swap(vec[begin], vec[begin + rand() % (end - begin)]); // 随机数，降低最坏情况
	int pivot = vec[begin];
	end--; // [begin, end)
	while (begin < end)
	{
		while (begin < end){
			if (pivot < vec[end]){
				end--;
			}
			else
			{
				vec[begin++] = vec[end];
				break;
			}
		}

		while (begin < end)
		{
			if (pivot > vec[begin]){
				begin++;
			}
			else
			{
				vec[end--] = vec[begin];
			}
		}
	}
	vec[begin] = pivot;
	return begin;
}

void quik_sort(vector<int> &vec, int begin, int end){
	if (end - begin < 2) return;

	int pivot = partition(vec, begin, end);
	quik_sort(vec, begin, pivot);
	quik_sort(vec, pivot + 1, end);
}

void test_quik_sort(){
	vector<int> vec = { 4, 3, 2, 1, 5, 6, 234, 657 };
	quik_sort(vec, 0, vec.size());
	cout << "quik sort:" << endl;
	printvec(vec, vec.size());
}

int main()
{
	test_bubble_sort();
	test_selection_sort();
	test_insertion_sort();
	test_insertion_sort_opt();
	test_heap_sort();
	test_merge_sort();
	test_quik_sort();

	system("pause");
	return 0;
}

运行结果：