基本排序算法C++编程实现（ACM格式）

引言

本文针对常用高频排序算法的相关原理，手撕ACM格式

算法分类

比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此也称为非线性时间比较类排序
非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此也称为线性时间非比较类排序

冒泡排序

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

选择排序

void selectSort(vector<int> n)
{
	int min;
	for (int i = 0; i < n.size(); i++)
	{
		min = i;
		for (int j = i; j < n.size(); j++)
		{
			if (n[min] > n[j]) min = j;
		}
		swap(n[i],n[min]);
	}
}

插入排序

void insertSort(vector<int> nums)
{
	for (int i = 1; i < nums.size(); i++)
	{
		for (int j = i - 1; j >= 0 && nums[j] > nums[j + 1]; j--)
		{
			swap(nums[j], nums[j + 1]);
		}
	}
}

快速排序

当需要排序的元素较多时，程序运行时间很长，因此产生了快速排序算法：

1. 在数组中选一个基准数（通常为数组第一个）

2. 将数组中小于基准数的数据移到基准数左边，大于基准数的移到右边

3. 对于基准数左、右两边的数组，不断重复以上两个过程，直到每个子集只有一个元素，即为全部有序

具体实现步骤如下：

例如有一需要排序的数组为：23,45,17,11,13,89,72,26,3,17,11,13（从小到大排序）：

1. 选取数组第一个数23为基准数，存入temp变量中
2. 定义两个指针 i 和 j，i 最开始指向数组第一个元素，j 最开始指向数组最后一个元素
3. 指针 i 从左向右移动，指针 j 从右向左移动
4. 先移动 j 指针，直到遇到小于等于基准数temp的数arr[j]，将arr[j]填入arr[i]中
5. 再移动 i 指针，直到遇到大于等于基准数temp的数arr[j]，将arr[i]填入arr[j]中
6. 将基准数temp赋值给arr[i]
7. 分别将基准数左边和右边的数组按照以上方法进行聚合，直到每个子集只有一个元素，即排序完成

void quickSort(int begin, int end, vector<int>& n)
{
	if (begin < end)
	{
		int temp = n[begin];
		int L = begin;
		int R = end;
		while (L < R)
		{
			while (L < R && n[R] >= temp)
			{
				R--;
			}
			n[L] = n[R];
			while (L < R && n[L] <= temp)
			{
				L++;
			}
			n[R] = n[L];
		}
		n[L] = temp;
		quickSort(begin, L - 1, n);
		quickSort(L + 1, end, n);
	}
	else
		return;
}

整体代码

#include<iostream>
#include<vector>
using namespace std;

void bubbleSort(vector<int> n)
{
	for (int i = 0; i < n.size(); i++)
	{
		for (int j = 0; j < n.size() - 1 - i; j++)
			if (n[j] > n[j + 1])
			{
				swap(n[j], n[j + 1]);
			}
	}
	cout << "冒泡排序： ";
	for (int i = 0; i < n.size(); i++)
	{
		cout << n[i] << ' ';
		if (i == n.size() - 1) cout << endl;
	}
}

void selectSort(vector<int> n)
{
	int min;
	for (int i = 0; i < n.size(); i++)
	{
		min = i;
		for (int j = i; j < n.size(); j++)
		{
			if (n[min] > n[j]) min = j;
		}
		swap(n[i],n[min]);
	}
	cout << "选择排序： ";
	for (int i = 0; i < n.size(); i++)
	{
		cout << n[i] << ' ';
		if (i == n.size() - 1) cout << endl;
	}
}

void insertSort(vector<int> nums)
{
	for (int i = 1; i < nums.size(); i++)
	{
		for (int j = i - 1; j >= 0 && nums[j] > nums[j + 1]; j--)
		{
			swap(nums[j], nums[j + 1]);
		}
	}
	cout << "插入排序： ";
	for (int i = 0; i < nums.size(); i++)
	{ 
		cout << nums[i] << ' ';
		if (i == nums.size() - 1) cout << endl;
	}
}

void quickSort(int begin, int end, vector<int>& n)
{
	if (begin < end)
	{
		int temp = n[begin];
		int L = begin;
		int R = end;
		while (L < R)
		{
			while (L < R && n[R] >= temp)
			{
				R--;
			}
			n[L] = n[R];
			while (L < R && n[L] <= temp)
			{
				L++;
			}
			n[R] = n[L];
		}
		n[L] = temp;
		quickSort(begin, L - 1, n);
		quickSort(L + 1, end, n);
	}
	else
		return;
}

int main()
{
	vector<int> n;
	vector<int> nn;
	int num;
	while (cin >> num)
	{
		n.push_back(num);
		if (cin.get() == '\n')
			break;
	}
	nn = n;
	bubbleSort(n);//冒泡排序
	selectSort(n);//选择排序
	insertSort(n);//插入排序
	quickSort(0, n.size()-1, n);//快速排序
	cout << "快速排序： ";
	for (int i = 0; i < n.size(); i++)
	{
		cout << n[i] << ' ';
		if (i == n.size() - 1) cout << endl;
	}
	system("pause");
	return 0;
}