排序之交换排序

什么是交换排序

1，冒泡排序

基本代码模版

for (int i = 0; i < x.size(); i++;
	for (int j = 1; j < x.size()-i; j++)
		if (x[j-1] > x[j]) swap(x[j-1], x[j]);

 基本思想：

通过无序区中相邻元素关键字的比较和外置的交换使关键字最小的元素如气泡般逐渐上浮至水面。

//排序
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
//冒泡，默认O(n^2)
void bubble_sort(vector<int> x)
{
	for (int i = 0; i < x.size(); i++)
	{
		for (int j = 1; j < x.size()-i; j++)
		{
			if (x[j-1] > x[j]) swap(x[j-1], x[j]);
		}
	}
	cout << "Bubble_sort ; ";
	for (auto x : x) cout << x << " ";
	cout << endl;
}
//优化冒泡,设置标志位，一旦没有交换，则冒泡完成
void Pbuble_sort(vector<int> x)
{
	bool flag = true;
	int len = x.size();
	while (flag)
	{
		flag = 0;
		
			for (int j = 1; j < len; j++)
			{
				if (x[j] <x[j-1]) swap(x[j], x[j-1]);
				flag = 1;
			}
			len--;
	}
	cout << "Pbuble_sort : ";
	for (auto x : x) cout << x << " ";
	cout << endl;
}
int main()
{
	vector<int> a({ 1,3,5,2,4,6,88,0,2,5,6,7,8,99,11 });
	bubble_sort(a);
	Pbuble_sort(a);
	cout << endl;
	for (auto x : a) cout << x << " ";
}

所以冒泡排序最好时间复杂度为O(n)，最坏和平均为O(n2)。

2,快速排序

基本思想：

每趟快排使表的一个元素放入适当位置，将表一分为二，对子表按递归方式继续这种划分，直到划分的子表长为1或0；

1，确定基准，可以为任意一个数

2，调整区间

3，递归处理左右两段

快排模版

#include<iostream>
using namespace std;
int n;
const int N = 1e6+10;
int q[N];
void quick_sort(int q[],int l,int r)
{
	if (l >= r) return;
	int i = l-1,j = r+1,t = q[l+r>>1];//在两个边界左右两侧一格，这样移动起来才能指向真正的边界
	while (i < j)//双指针算法
	{
		do i++; while (q[i] < t);
		do j--; while (q[j] > t);
		if (i < j) swap(q[i], q[j]);
	}
	quick_sort(q, l, j);
	quick_sort(q, j + 1,r);

}
int main()
{
   
    scanf("%d", &n);

    for (int i = 0; i < n; i ++ ) scanf("%d", &q[i]);

    quick_sort(q, 0, n - 1);

    for (int i = 0; i < n; i ++ ) printf("%d ", q[i]);

    return 0;
 
    
}

快速排序的平均时间复杂度为O(nlog2n)  

平均所需栈空间为O(log2n)。

3，简单选择排序

#include<iostream>
using namespace std;
void selectSort(int arr[], int len)
{
	int i, j;
	int min; //待排序数组中最小值的下标
	int tmp;
	for (i = 0; i < len - 1; ++i)//i = 0,第一次待排数组为所有数
	{   
		min = i;
		for (j = i + 1; j < len; ++j)
		{
			if (arr[j] < arr[min])
			{
				min = j;//
			}
		}
		//将arr[i]与arr[min]交换位置
		swap(arr[i],arr[min]);
	}
}
void selectShow(int arr[], int len)
{
	for (int i = 0; i < len; ++i)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}
int main()
{
	int arr[] = {59,26,245,21,6,10,16};
	int len = sizeof(arr) / sizeof(arr[0]);
	selectShow(arr, len);
	selectSort(arr, len);
	selectShow(arr, len);
	return 0;
}

简单选择排序的最好、最坏和平均时间复杂度为O(n2)。

4，堆排序

最后的堆排要等一下