排序——数据结构C++

排序——数据结构C++

排序算法可以分为内部排序和外部排序。
内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。
常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。

1.插入排序

插入排序:每次将一个排序元素按照关键字大小插入到已排序的序列中。
平均时间复杂度:O(n^2) ，空间复杂度O(1)。

inline void insert_sort(vector<int>&nums)
{
    for(int i=0;i<n;i++)
    {
        int tmp=nums[i];   //存储当前值
        int j=i-1;
        while(j>=0&&nums[j]<tmp) 
        {
            nums[j+1]=nums[j];
            j--;          /*一个个后移*/
        }
        nums[j+1]=tmp;
    }
}

2.冒泡排序

冒泡排序：依次比较相邻两数，直至比较最后两位数，最多比较n-1轮
结束条件：一趟排序未发生元素变换。
平均时间复杂度:O(n^2) ，空间复杂度O(1)。

inline void Bubble_sort(vector<int>nums)
{
    for(int i=0;i<n-1;i++)
    {
        bool flag=false;
        for(int j=0;j<n-i-1;j++)
        {
            if(nums[j]<nums[j+1])
            {
                flag=true;
                swap(nums[j],nums[j+1]);
            }
        }
        if(!flag) break;
    }
}

3.选择排序

选择排序：比如从小到大排序，每次在未排序的元素中找最小的那个，放在第一位，剩余的n-1个元素找到最小的放在第二位，以此类推，直至排序完成。
平均时间复杂度:O(n^2) ，最好情况也是O(n^2)，空间复杂度O(1)。

inline void select_sort(vector<int>&nums)
{
    for(int i=0;i<n;i++)
    {
        int tmpmi=i;
        for(int j=i+1;j<n;j++)
        {
            if(nums[j]>nums[tmpmi]) tmpmi=j;
        }
        swap(nums[i],nums[tmpmi]);
    }
}

4.希尔排序

希尔排序：插入排序的优化，区别在插入排序每次只间隔一个元素，而希尔排序间隔gap个元素，但最后一趟仍为真正的插入排序。适用于大规模乱序。
平均时间复杂度O(n^1.3)，

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

5.快速排序

快速排序：从队列中取出一个数作为基准数，将比这个数大的放在右边，
比这个数小的放在左边，再对左右区间重复第二步，直到各区间只有一个数
平均时间复杂度:O(nlogn)，空间复杂度O(logn)
最坏情况：基准值刚好取到最大值或者最小值，快速排序退化为冒泡排序，时间复杂度为O(n^2)。

inline void quick_sort(vector<int>&nums,int l,int r)
{
    if(l>=r) return;

    int i=l-1,j=r+1,x=nums[l+r>>1];
    while(i<j)
    {
        do i++; while(nums[i]>x);
        do j--; while(nums[j]<x);
        if(i<j) swap(nums[i],nums[j]);
    }
    quick_sort(nums,l,j),quick_sort(nums,j+1,r);
}

6.归并排序

将已有序的子序列合并，得到完全有序的序列。即每一段区间划分成logn层，每一个子序列有序，再使得子序列区间有序。
若将两个有序表合成一个有序表，称为二路归并排序。
平均时间复杂度:O(nlogn)，空间复杂度O(n)。

void merge_sort(vector<int>&nums,int l,int r)
{
    if(l>=r) return ;
    int tmp[r+1];
    int mid=l+r>>1;
    merge_sort(nums,l,mid);
    merge_sort(nums,mid+1,r);

    int cnt=0,i=l,j=mid+1;
    while(i<=mid&&j<=r)
        if(nums[i]>=nums[j]) tmp[cnt++]=nums[i++];
        else tmp[cnt++]=nums[j++];

    while(i<=mid) tmp[cnt++]=nums[i++];
    while(j<=r)   tmp[cnt++]=nums[j++];

    for(int i=l,j=0;i<=r;i++,j++) nums[i]=tmp[j];
}

7.计数排序（桶排序）

计数排序：通过统计数组中相同元素出现的次数，然后通过统计的结果将序列回收到原来的序列中。适用于数据范围较小的场景
平均时间复杂度O(n+k)，空间复杂度O(k)

void count_sort(int nums[])
{
	int mi=*min_element(nums,nums+n);
	int mx=*max_element(nums,nums+n);
	int rng=mx-mi+1;
	vector<int>count(rng,0);
	
	for(int i=0;i<n;i++) 
		count[nums[i]-mi]++; //统计每个数出现的次数 
		
	//写回原数组 
	int cnt=0;
	for(int i=0;i<rng;i++)
	{
		while(count[i]--)
			nums[cnt++]=i+mi;
	}
}

8.堆排序

堆排序原理：将各个父节点与其自己的孩子结点进行对比，然后交换的过程，其中堆是一个完全二叉树。堆排序的实质是一种选择排序。
算法思想：建立堆，调整堆，及交换堆顶元素和堆的最后一个元素。
平均时间复杂度O(nlogn)，空间复杂度O(1)。

//如何手写一个堆？完全二叉树 5个操作
//1. 插入一个数         heap[ ++ size] = x; up(size);
//2. 求集合中的最小值   heap[1]
//3. 删除最小值         heap[1] = heap[size]; size -- ;down(1);
//4. 删除任意一个元素   heap[k] = heap[size]; size -- ;up(k); down(k);
//5. 修改任意一个元素   heap[k] = x; up(k); down(k);
/*
向下 
以下二叉树经过以下步骤转换为大堆：

选出孩子节点中大的值大的与父结点比较，如孩子节点大于父结点则交换，如小于则停止。
持续向下比较，比较到叶子结点或者孩子结点小于父结点则停止。
*/
#include<bits/stdc++.h>
using namespace std;
const int N=10010;
//表示第i个结点存储的值
int h[N],siz;
void down(int u)
{
	int t=u;
	if(u*2<=siz&&h[u*2]<h[t]) t=u*2;
	if(u*2+1<=siz&&h[u<<1|1]<h[t]) t=u*2+1;
	if(t!=u)
	{
		swap(h[u],h[t]);
		down(t);
	}
}
void up(int u)
{
	while(u/2 &&h[u]<h[u/2])
	{
		swap(h[u],h[u/2]);
		u>>=1;
	}
}
int main()
{
	int n,m;
	scanf("%d%d",&n,&m);
	for(int i=1;i<=n;i++) scanf("%d",&h[i]);
	siz=n;
	for(int i=n/2;i;i--) down(i); //把堆初始化为小根堆，从倒数第二行开始,把数字大的下沉 
	
	while(m--)
	{
		printf("%d ",h[1]);
		h[1]=h[siz];
		siz--;
		down(1);
	}
	return 0;
}

9.基数排序

桶排序的扩展。简单来说，就是把一组序列中位数最多的作为基，每次比较从个位排（只看个位上的大小排成一个序列），然后十位、百位，直到排到位数最多的那一位，最终有序。
平均时间复杂度O(d(n+r))，空间复杂度O(n+r)。

void RadixSort(int a[], int n){
    const int RADIX = 10;//DADIX表示为十进制数 
    int maxval = a[0], minval = a[0], base[10];//base数组存的是十进制数的位权 
    vector< vector<int> > bucket(RADIX);//相当于定义10个桶 

    base[0] = 1;//个位的权值为 1 
    for(int i = 1; i < 10; i ++) base[i] = base[i - 1] * 10;//初始化权值 
    
    for(int i = 0; i < n; i ++){
        maxval = max(maxval, a[i]);//求出所有元素的最大值 
        minval = min(minval, a[i]);
    }

    //将所有元素右移(即映射到非负数区域) 
    if(minval < 0){
        for(int i = 0; i < n; i ++){
            a[i] -= minval;
        }
        maxval -= minval;
    }

    int dnum = ceil(log10(maxval + 1));//求出最大的位数,比如38为2位 

    for(int d = 0; d < dnum;  d ++)
    {
        for(int i = 0; i < n; i ++)
		{
            int t = (a[i] / base[d]) % RADIX;//取出该位数值,即对应的桶号 
            bucket[t].push_back(a[i]);
        }

        for(int i = 0, j = 0, k = 0; i < n; )
		{
            if(k < bucket[j].size())     //k为桶中的第k号元素 
                a[i ++] = bucket[j][k ++];  //依次将桶中元素存入数组(已按当前位有序) 
            else 
				j ++, k = 0;
        }
        for(auto &v : bucket) v.clear();//将桶中元素清零, 开始下一趟排序 
    }

    //还原之前的元素序列,即将元素整体再左移回去 
    if(minval < 0)
	{
        for(int i = 0; i < n; i ++)
            a[i] += minval;
    }
}

离散化模板

//离散化预处理
inline void solve()
{
    //排序
    sort(a + 1,a + n + 1);
    //去重
    for(int i = 1;i <= n;++i)
    {
        if(i == 1 || a[i] != a[i-1])
            b[++m] = a[i];
    }
}

//二分查找 x映射为那个1~m之间的整数
inline int query(int x)
{
    return lower_bound(b + 1,b + m + 1,x) - b;
}