各类排序的代码

最新推荐文章于 2022-03-27 18:29:08 发布

无声有色

最新推荐文章于 2022-03-27 18:29:08 发布

阅读量487

点赞数 1

文章标签：排序算法快速排序堆排序算法

本文链接：https://blog.csdn.net/weixin_43417464/article/details/111827763

版权

刚刚发布了一张四年级所做的草稿【哈哈】，好像是写能自己算二十四点的程序。

而现在呢？额。。。最大的不同就是我五年级啦。。。

归入正题，重要且常用的排序有以下几种：

1.冒泡排序（时间复杂度O(n^2)，有时会进化至O(n)）

2.桶排序（时间复杂度O(n)）

3.插入排序（时间复杂度O(n^2)）

4.快速排序（时间复杂度O(nlogn)，有时会退化至O(n^2)）、

5.归并排序（时间复杂度O(nlogn)）

6.堆排序

7.希尔排序

8.emmmmmmm STL：sort【哈哈】

sort不需要我多做解释吧。。。直接讲前七个。

上代码！！！

--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

#include<bits/stdc++.h>
using namespace std;
int a[100005]={0};
//sort(begin,end,greater<data-type>()) 降序
//归并算法(排序) O(nlog2n) 稳定
//辅助数组，存放两个子序列合并的结果
int temp[100005]={0};
//合并函数
int merge(int ls,int le,int rs,int re){
   //标记左序列的第一个未排序的元素
   int st=ls;
   //辅助数组的下标
   int x=ls;
   //合并数组 a[ls] a[rs] temp[]
   while(ls<=le&&rs<=re){
       //如果左序列剩余第一个元素更小
       if(a[ls]<a[rs]){
           temp[x]=a[ls];
           x++,ls++;
       }else{//否则，右序列剩余第一个元素更小
           temp[x]=a[rs];
           x++,rs++;
       }
   }
   //如果右序列先排序完，合并左序列剩余元素
   while(ls<=le){
       temp[x]=a[ls];
       x++,ls++;
   }
   //如果左序列先排序完，合并右序列剩余元素
   while(rs<=re){
       temp[x]=a[rs];
       x++,rs++;
   }
   //将辅助数组中的元素复制到原数组中
   for(int i=st;i<=re;i++){
       a[i]=temp[i];
   }
}
//拆分
void merge_sort(int l,int r){
   //如果只有一个元素，就不需要继续划分
   if(l<r){
       //找中间点
       int mid=(l+r)/2;
       //递归划分左序列
       merge_sort(l,mid);
       //递归划分右序列
       merge_sort(mid+1,r);
       //合并已经排序的部分
       merge(l,mid,mid+1,r);
   }
}
//---------------------------------------------------------------------------------------------------------------------------------------------------
//快速排序平均O(nlog2n),不稳定，极端情况下会退化成O(n*n)
void quick_sort(int l,int r){
   //第一步，选取基准值
   int key=a[(l+r)/2];
   //第二步，小于基准数的放左半区，大于基准数的放右半区
   int i=l,j=r;
   while(i<=j){
       while(a[i]<key)i++;
       while(a[j]>key)j--;
       if(i<=j){
           swap(a[i],a[j]);
           i++,j--;
       }
   }
   //第三步，再对左右区间重复一二步，直到各区间只有一个数
   if(l<j) quick_sort(l,j);
   if(i<r) quick_sort(i,r);
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
//直接插入排序稳定 O(n*n)
void InsertSortHard(int len){
   int i,j;
   int temp;
   for(i=1;i<len;i++){
       temp=a[i];
       for(int j=i-1;j>=0&&a[j]>temp;j--) a[j+1]=a[j];
       a[j+1]=temp;
   }
}
//整个序列分为有序区和无序区，取第一个元素作为初始有序区，然后第二个开始，依次插入到有序区的合适位置，直到排好序
void InsertSortEasy(int n){
   for(int i=1;i<=n;++i){
       for(int j=i;j>0;--j){
           if(a[j]<a[j-1]){
               int temp=a[i];
               a[j]=a[j-1];//站在第一个比自己“高的人“的后面
               a[j-1]=temp;
           }
       }
   }
}
//--------------------------------------------------------------------------------------------------------------------------------------------------
//冒牌排序稳定 O(n*n)
void BubbleSortSlower(int n){
   for(int i=0;i<n-1;i++){
       for(int j=0;j<n-i-1;j++){
           if(a[j]>a[j+1]){
               int temp=a[j];
               a[j]=a[j+1];
               a[j+1]=temp;
           }
       }
   }
}
//冒泡排序感觉非常好理解，第一个for循环是遍历所有元素，第二个for循环是每次遍历元素时都对无序区的相邻两个元素进行一次比较，若反序则交换
/*
但是还有更好的方法，如果第一次比较完没有交换即说明已经有序，不应该进行下一次遍历
还有已经遍历出部分有序的序列后，那部分也不用进行遍历，即发生交换的地方之后的地方不用遍历
*/
void BubbleSortFaster(int len){
   int i,temp;
   //记录位置，当前所在位置和最后发生交换的地方
   int current,last=len-1;
   while(last>0){
       for(i=current=0;i<last;++i){
           if(a[i]>a[i+1]){
               temp=a[i];
               a[i]=a[i+1];
               a[i+1]=temp;
               //记录当前的位置，如果没有发生交换current值即for循环初始化的0
               current=i;
           }
       }
       //若current=0即已经没有可以交换的元素了，即已经有序了
       last=current;
   }
}
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//堆排序 O(nlogn)
//调整成堆的函数
void Heapify(int first,int end){
   int father=first;
   int son=father*2+1;
   while(son<end){
       if(son+1<endl&&a[son]<a[son+1]) ++son;
       //如果父节点大于子节点则表示调整完毕
       if(a[father]>a[son]) break;
       else{
           //不然就交换父节点和子节点的元素
           int temp=a[father];
           a[father]=a[son];
           a[son]=temp;
           //父和子节点变成下一个要比较的位置
           father=son;
           son=2*father+1;
       }
   }
}
//正排序函数
void HeapSort(int len){
   int i;
   //初始化堆，从最后一个父节点开始
   for(i=len/2-1;i>=0;--i){
       Heapify(a,i,len);
   }
   //从堆中的取出最大的元素再调整堆
   for(i=len-1;i>0;--i){
       int temp=a[i];
       a[i]=a[0];
       a[0]=temp;
       //调整成堆
       Heapify(arr,0,i);
   }
}
//-----------------------------------------------------------------------------------------------------------------------------------------------
//希尔排序 O(nlogn)
int shsort(int s[], int n) /* 自定义函数 shsort()*/
{
int i,j,d;
d=n/2; /*确定固定增虽值*/
while(d>=1){
for(i=d+1;i<=n;i++) /*数组下标从d+1开始进行直接插入排序*/
{
s[0]=s[i]; /*设置监视哨*/
j=i-d; /*确定要进行比较的元素的最右边位置*/
while((j>0)&&(s[0]<s[j])){
s[j+d]=s[j]; /*数据右移*/
j=j-d; /*向左移d个位置V*/
}
s[j + d]=s[0]; /*在确定的位罝插入s[i]*/
}
d = d/2; /*增里变为原来的一半*/
}
   return 0;
}
//------------------------------------------------------------------------------------------------------------------------------------------------------------
//桶排序 O(n) 不稳定
int tongsort(int n){
   int temp[100001]={};
   for(int i=0;i<n;i++){
       temp[i]++;
   }
   for(int i=0;i<100001;i++){
       if(temp!=0){
           for(int j=0;j<temp[i];j++){
               cout<<i<<' ';
           }
       }
   }
}
int main(){
   return 0;
}