C++快速，选择，插入，冒泡，归并排序

今日闲来无事，写个C++排序

首先，我们要知道排序方法多种多样，是列举不完的，因此这里写几个常用方法：自带函数，选择，插入，冒泡

2021.11.10:添加快排

2021.11.11:添加归并

一、其实C++自带一个排序函数：sort，头文件为algorithm，sort用法此处不做详解

二、选择排序

三、插入排序

四、冒泡排序

五、快速排序

六、归并排序

1.sort写法：

#include<iostream>
#include<algorithm>
#include<cstdio>
using namespace std;
#define n 10//这里就是要排序元素个数
int a[n];
int main(void){
	for(int i=0;i<n;i++)
		scanf("%d",&a[i]);
	sort(a,a+n);
	for(int i=0;i<n;i++)
        printf("%d ",a[i]);
}

这个看上去是很简单，但是不是这篇文章主要目的，所以简单带过

1.选择排序：

有n个元素需要排序，我们先找到其中最小的，然后放到第一个的位置，再找到第二小的，放到第二个位置，即找到第n小的放到第n个位置。

我们可以只开一个数组然后将不同的数进行交换，也可以开两个相同大小的数组，一个放置未排序的数，然后每次找到这个数组的最小数，依次放到另一个数组，第一个数组每找到一个最小数，就将这个数清0，防止重复

下面讲解开多开一个数组的情况

#include<iostream>
#include<cstdio>
using namespace std;
const int N = 2e5 + 10;
int a[N],b[N];//a放置原数组，因为是全局变量，b自动初始化0 
void s_sort(int n){
	for(int i=0;i<n;i++){//每次循环将a中的元素存放一个到b 
		int ju;
		for(int j=0;j<n;j++)
			if(a[j]!=0){//将b的下一个数赋值成a中第一个不为0的数 
				b[i]=a[j];
				ju=j;//后面比较判断可以直接从ju开始 
				break;
			}
		for(int j=ju+1;j<n;j++){//判断
			if(a[j]==0)
				continue;//这个位置没数了 
			if(b[i]>a[j]){//在这个位置不是最小的 
				b[i]=a[j];
				ju=j;//记录，方便清0 
			}
		}
		a[ju]=0;//这个位置的数已经被存放了 
	}
	return;
}
int main(void){
	int n;
	cin>>n;
	for(int i=0;i<n;i++)
		scanf("%d",&a[i]);
	s_sort(n);
	for(int i=0;i<n;i++)
		printf("%d ",b[i]);
}
/*
有n个元素需要排序，我们先找到其中最小的，然后放到第一个的位置
再找到第二小的，放到第二个位置
即找到第n小的放到第n个位置。
*/

3.插入排序：

我们把数组分成已排序，未排序两个部分，初始已排序只有a[0]，然后每次把无序部分的第一个数放入有序部分，放入的时候按照检索位置放置，直至无序部分没有数

我们每一次把无序数与有序数判断，都只用循环有序数次，同时后移的时候有序数最后一个数的下一个数，也就是无序数的第一个数会被清掉，所以要先保存

#include<iostream>
#include<cstdio>
using namespace std;
const int N = 2e5 + 10;//排序元素个数
int a[N];
void in_sort(int n){
	for(int i=1;i<n;i++){//因为是放入无序部分，所以只有n-1个 
		for(int j=0;j<i;j++){//将无序的第一个数与有序每个数比较 
			if(a[i]<a[j]){//无序数比这个有序数小 
				int m=a[i];//先记录这个无序数，避免后移时把它清掉 
				for(int k=i;k>j;k--)
					a[k]=a[k-1];//将有序数后移一位 
				a[j]=m;//把无序数放进去 
				break;
			}
		}
	}
	return;
}
int main(void){
	int n;
	cin>>n;
	for(int i=0;i<n;i++)
		scanf("%d",&a[i]);//输入
	in_sort(n);
	for(int i=0;i<n;i++)
		printf("%d ",a[i]);
}
/*
我们把数组分成已排序，未排序两个部分
初始已排序只有a[0]
然后每次把无序部分的第一个数放入有序部分
放入的时候按照检索位置放置，直至无序部分没有数
*/

事实上如果仔细观察，就会发现插入排序和选择排序的时间复杂度是一样的，几乎毫无优势

4.冒泡排序：

类似插入，一样分为有序与无序，但是有序的部分在右边，同时最初有序部分为0，每次把无序最大的一个数移动到有序的第一个元素的左边，直到无序部分没有元素

实际实现方法是，每次比较相邻的两个数，如果前面比后面大，就交换。明显，我们会经常交换，那我们就会使用到swap函数，也可以避免出现精度损失

#include<iostream>
#include<cstdio>
using namespace std;
const int N = 2e5 + 10;
int a[N];
void bu_sort(int n){
	for(int i=n-1;i>0;i--)//每次把无序组的最大值都移到i的位置 
		for(int j=0;j<i;j++)//依次比较相邻元素 
			if(a[j]>a[j+1])
				swap(a[j],a[j+1]);
	return;
}
int main(void){
	int n;
	cin>>n;
	for(int i=0;i<n;i++)
		scanf("%d",&a[i]);
	bu_sort(n);
	for(int i=0;i<n;i++)
		printf("%d ",a[i]);
}
/*
类似插入，一样分为有序与无序
但是有序的部分在右边，同时最初有序部分为0
每次把无序最大的一个数移动到有序的第一个元素的左边
直到无序部分没有元素
*/

5.快速排序:

分为三个步骤(假定数组q ，从l 到 r)

1.确定一个边界点x，边界点可以任意取，x = [l], x = [r] , x= [(l + r) / 2]

2.根据x的大小把整个数组分成两个区间，大于x的和小于x的

3.将两个区间不断递归，从而排序

平均时间复杂度O(nlogn)，最坏时间复杂度O(n^2)

需要注意的是分区间的时候有两种思路：

1.开两个数组a[],b[]，比x小的就放入a，比x大的就放入b，但这样会浪费空间

2.双指针思路i,j，i从左端往右扫，j从右端往左扫，i碰到比x大的就停下，j碰到比x小的就停下，当两个同时停下的时候就交换i j的值，如果i j 重合就代表已经扫完了，就结束递归

递归的思路是，我们每次递归中间值都改变，每次都将两个区间根据x分出，直到最后不能再分，x就改变了

#include<iostream>
#include<cstdio>
using namespace std;
const int N = 1e5 + 100;
int q[N];
void q_sort(int q[], int l, int r){
	if(l >= r)//l == r也可以 
		return;//结束条件 区间里只有一个数或没有数 
	int x = q[(l + r) / 2] , i = l - 1 , j = r + 1;//边界 左指针 右指针
/* 
i - 1 与 j + 1是因为后面写do while  
注意
1: 装逼套路  q[(l + r) / 2] = q[l + r >> 1]
2: 边界点可以随便取，但如果 x = q[l] 在数据针对的情况下 会退化到o(n^2) 
*/
	while(i < j){//左右指针未重合
		do
			i++;
		while(q[i] < x);//找到第一个左区间内大于x的数
		do
			j--;
		while(q[j] > x);//找到第一个右区间内小于x的数
		if(i < j)
			swap(q[i],q[j]);
	}
	q_sort(q,l,j);//左区间 
	q_sort(q,j + 1,r);//右区间 
/*
只是对区间分成两部分，也可以写i 但如果写i 上面就是 i-1，下面是i
同时x不能取 l 不然会有边界问题
并且，因为我用的j，因此上面的x不能取到 x = q[r] 
*/
}
int main(void){
	int n;
	cin>>n;
	for(int i = 0 ; i < n; i++)
		scanf("%d",&q[i]);//多个数用scanf输入 
	q_sort(q,0,n - 1);//初始边界是 0  n-1
	for(int i = 0 ; i < n; i++)
		printf("%d ",q[i]);
}

6.归并排序：

总共分为三步：

1.把数组按中间值分成左右两部分

2.把左右两部分分别排序

3.将两部分合并

时间复杂度O(nlogn)

实现的关键在于如何优化第三步

1.开一个额外的数组b作为排序好的数组

2.双指针i j   i作为左边的指针，j作为右边的指针

3.每次两个指针对应的位置的值进行比较，较小值赋给b

4.赋给b的指针向后移动一位，直到有一个指针移动完

5.将没有移动完的部分剩余的值直接给b

#include<iostream>
#include<cstdio>
using namespace std;
const int N = 1e5 + 100;
int a[N],b[N];
void m_sort(int a[],int l,int r){
	if(l >= r)
		return;//左右边界重合，没有值
	int x = l + r >> 1;//装逼小套路:(l + r) / 2
	m_sort(a,l,x);
	m_sort(a,x + 1,r);//左右两区间排序
	int k = 0, i = l, j = x + 1;//k代表b数组里面个数 
	while(i <= x && j <= r)//把排序好的两部分数组放入b数组 
		if(a[i] <= a[j])
			b[k++] = a[i++];//<=> b[k] = a[i] , k++ , i++ 
		else
			b[k++] = a[j++];
	while(i <= x)
		b[k++] = a[i++];
	while(j <= r)
		b[k++] = a[j++];//两部分数组有一部分没有放完，直接全部放入b 
	for(i = l, j = 0; i <= r; i++,j++)
		a[i] = b[j];//重新赋值回去 
}
int main(void){
	int n;
	cin>>n;
	for(int i = 0; i < n; i++)
		scanf("%d",&a[i]);
	m_sort(a,0,n - 1);
	for(int i = 0; i < n; i++)
		printf("%d ",a[i]);
}

我会不断学习，也会不断更新此博客