排序！！！

直接插入排序：

基本思想：我们平时玩扑克牌时，摸牌阶段的排序就用到了插入排序的思想

1. 当插入第n个元素时，前面的n-1个数已经有序
2. 用这第n个数与前面的n-1个数比较，找到要插入的位置，将其插入（原来位置上的数不会被覆盖，因为提前保存了）
3. 原来位置上的数据，依次后移

具体实现：

①单趟的实现（将x插入到 [0,end] 的有序区间）

即一般情况下的插入，我们随机列举了一些数字，待插入的数字分为两种情况

（1）待插入的数字是在前面有序数字的中间数，直接比较将x赋值给end+1位置

（2）x是最小的一个数，end就会到达-1的位置，最后直接将x赋值给end+1位置

代码实现：

#include<bits/stdc++.h>

using namespace std;

void InsertSort(int a[],int l)
{
    int temp;
    int j;
    for(int i=1;i<l;i++)
    {
        if(a[i]<a[i-1])
        {
            temp=a[i];
            for(j=i-1;j>=0&&temp<a[j];j--)
            {
                a[j+1]=a[j];
            }
            a[j+1]=temp;

        }
        for(int k=0;k<l;k++)
            cout<<a[k]<<" ";
        cout<<endl;

    }
}


int main()
{
    int a[10]={2,5,8,3,6,9,1,4,7};
    int b[10]={1,2,3,4,5,6,7,8,9};
    int len=9;
    InsertSort(a,len);
    return 0;
}

桶排序：

将出现的数字装进对应的桶里，最后对桶进行统计，是否有数字或者是否存在多个数字

int n;
cin>>n;
    int ans[11]={};
    int num;
    for(int i=1;i<=n;i++){
        cin>>num;
        ans[num]++;
    }
    for(int i=1;i<=10;i++){ //外层循环实现数字依次增加进行排序
        for(int j=1;j<=ans[i];j++){//内层循环实现顺序输出桶值有更新的
                                  //桶编号
            cout<<i<<" ";
        }
    }

缺点：

1浪费空间

2.不能完成整体信息的排序

冒泡排序：相邻两个元素进行比较排序，直到后面没有元素为止

#include<iostream>
using namespace std;
int main(){
    //冒泡排序
    int n;
    cin>>n;
    int a[n+1]={};
    for(int i=1;i<=n;i++){
        cin>>a[i];
    } 
    for(int i=1;i<=n-1;i++){   //重复冒泡n-1次 
        for(int j=1;j<=n-i;j++){   //从第一位开始比较
                          //直到最后一个尚未归位的数 
             if(a[j]>a[j+1]){
                swap(a[j],a[j+1]);
             } 
        } 
    }
    for(int i=1;i<=n;i++){
        cout<<a[i]<<" ";
    }
    
    
    return 0;
} 

（最最重要的排序）

快速排序：利用递归的思想

思路：数组划分（从一个数组的第一个数开始，运用指针的识别，将数组分为大于第一个数和小于第一个数的两个数组）

#include <iostream>
using namespace std;
const int N = 1000010;
int q[N];
void quick_sort(int q[], int l, int r){
    if (l >= r) return;
    int i = l - 1, j = r + 1, x = q[l+r>>1];
    while (i < j){
        do i ++ ; while (q[i] < x);
        do j -- ; while (q[j] > x);
        if (i < j) swap(q[i], q[j]);
    }
    quick_sort(q, l, j);
    quick_sort(q, j + 1, r);
}
int main(){
    int n;
    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;
}

选择排序：

代码实现： 

#include<iostream>
using namespace std;
void selectsort(int a[],int n){
    for(int i=1;i<n;i++){  //从第一位开始，最后一位不用比 
        for(int j=i+1;j<=n;j++){ 
            if(a[i]>a[j]){
                swap(a[i],a[j]);
            }
        }
    }   
    return;
}
int main(){
    int a[1001]={},n;
    cin>>n;
    for(int i=1;i<=n;i++){
        cin>>a[i];
    }
    selectsort(a,n);
    for(int i=1;i<=n;i++){
        cout<<a[i]<<" "; 
    } 
    cout<<endl;
    return 0;
} 

归并排序

归并排序是一种基于分治思想的排序算法。其核心思路是将一个待排序的序列不断拆分成若干个子序列，直到每个子序列都只有一个元素为止，然后再将这些子序列两两合并，使之成为一个有序的大序列，最终得到一个有序的序列。

具体来说，归并排序的实现流程如下：

1. 将待排序序列不断拆分，直到每个子序列都只包含一个元素；
2. 将相邻的两个子序列进行合并，合并后保证这两个子序列内部是有序的；
3. 不断重复步骤2，直到所有的子序列都被合并成一个有序的序列。

在实现过程中，通常采用递归的方式进行拆分和合并。具体而言，拆分时使用二分法将序列分成两个子序列，然后递归地对这两个子序列进行拆分，直到每个子序列都只有一个元素为止；合并时则定义一个辅助数组，将两个有序的子序列依次比较大小，将较小的元素放入辅助数组中，直到两个子序列中的所有元素都被放入辅助数组中，然后再将辅助数组中的元素复制回原序列中。

归并排序的时间复杂度为O(nlogn)，空间复杂度为O(n)。由于其稳定性和效率较高的优点，归并排序广泛应用于各种场合中。

动画演示：

代码实现：

#include<bits/stdc++.h>
using namespace std;
const int N=1e6+10;
int q[N],tmp[N];
int n;
void merge_sort(int q[],int l,int r){
	if(l>=r) return;
	int mid=l+r>>1;
	merge_sort(q,l,mid);
	merge_sort(q,mid+1,r);
	int k=0,i=l,j=mid+1;
	while(i<=mid&&j<=r){
		if(q[i]<q[j])  tmp[k++]=q[i++];
		else tmp[k++]=q[j++];
		
 	}
	while(i<=mid) tmp[k++]=q[i++];
	while(j<=r)  tmp[k++]=q[j++];
	for(int i=l,k=0;i<=r;k++,i++) q[i]=tmp[k];
}
int main(){
	cin>>n;
	for(int i=0;i<n;i++){
		cin>>q[i];
	}
	merge_sort(q,0,n-1);
	for(int i=0;i<n;i++){
		cout<<q[i]<<" ";
	}
	
	
	return 0;
}