十大经典排序算法

【AI智能体】Codex 浏览器操作自动化任务实战操作详解 阅读详情

排序可以说是套路最多的基本算法了,今天来了兴致,那就总结一下这十大排序算法吧。

冒泡法:

这可以算是知名度最高的算法之一了吧,可以说不会这个算法都不好意思说自己写过代码。冒泡排序是最简单的排序之一了,其大体思想就是通过与相邻元素的比较和交换来把小的数交换到最前面。这个过程类似于水泡向上升一样,因此而得名。不多说了,直接上代码:

#include<iostream>  
#include<algorithm>  
using namespace std;  
#define LEN 6  
  
int a[]={10,9,11,6,20,17};  
  
int main()  
{  
    for(int i=0;i<LEN-1;i++)  
    {  
        for(int j=i+1;j<LEN;j++)  
        {  
            if(a[i]>a[j])  
                swap(a[i],a[j]);  
        }  
    }  
      
    for(int i=0;i<LEN;i++)  
        cout<<a[i]<<" ";  
    cout<<endl;  
    return 0;  
}   

选择排序:

冒泡排序的孪生兄弟吧,它和冒泡不一样的地方是,它没冒泡那么“愣头青”,而是更成熟的“谋定而后动”,找到了目标再进行交换。

#include<iostream>  
#include<algorithm>  
using namespace std;  
#define LEN 6  
  
int a[]={10,9,11,6,20,17};  
  
int main()  
{  
    int k;  
    for(int i=0;i<LEN-1;i++)  
    {  
        k=i;  
        for(int j=i+1;j<LEN;j++)  
        {  
            if(a[k]>a[j])  
                k=j;  
        }  
        if(k!=i)  
            swap(a[k],a[i]);  
    }  
      
    for(int i=0;i<LEN;i++)  
        cout<<a[i]<<" ";  
    cout<<endl;  
    return 0;  
} 

插入排序:

打过扑克的人应该都熟悉这个算法,抽到一张牌,将它插到合适位置,这就是这个算法的思想。

#include<iostream>  
#include<algorithm>  
using namespace std;  
#define LEN 6  
  
int a[]={10,9,11,6,20,17};  
  
int main()  
{  
      
    int index,temp;  
    for(int i=1;i<LEN;i++)  
    {  
        //一步步慢慢向前进   
        index=i; temp=a[i];  
        while(index>0 && temp<a[index-1])  
        {  
            swap(a[index],a[index-1]); --index;  
        }  
    }  
      
    for(int i=0;i<LEN;i++)  
        cout<<a[i]<<" ";  
    cout<<endl;  
    return 0;  
}  

快速排序:

快速排序一听名字就觉得很高端,在实际应用当中快速排序确实也是表现最好的排序算法。快速排序虽然高端,但其

实其思想是来自冒泡排序,冒泡排序是通过相邻元素的比较和交换把最小的冒泡到最顶端,而快速排序是比较和交换

小数和大数,这样一来不仅把小数冒泡到上面同时也把大数沉到下面。

举个栗子:对5,3,8,6,4这个无序序列进行快速排序,思路是右指针找比基准数小的,左指针找比基准数大的,交换之。

5,3,8,6,4 用5作为比较的基准,最终会把5小的移动到5的左边,比5大的移动到5的右边。

5,3,8,6,4 首先设置i,j两个指针分别指向两端,j指针先扫描(思考一下为什么?)4比5小停止。然后i扫描,8比5大停止

。交换i,j位置。

5,3,4,6,8 然后j指针再扫描,这时j扫描4时两指针相遇。停止。然后交换4和基准数。
4,3,5,6,8 一次划分后达到了左边比5小,右边比5大的目的。之后对左右子序列递归排序,最终得到有序序列。


#include<iostream>  
#include<algorithm>  
using namespace std;  
#define LEN 6  
  
int a[]={10,9,11,6,20,17};  
  
void quickSort(int l,int r)  
{  
    if(l>=r)  
        return;  
    int i=l,j=r,x=a[l];//以第一个数为基准  
    while(i<j)  
    {  
        while(i<j && a[j]>=x)//从右向左找第一个小于x的数  
            j--;  
        if(i<j)  
            a[i++]=a[j];  
        while(i<j && a[i]<=x)//从左向右找第一个大于x的数  
            i++;  
        if(i<j)  
            a[j--]=a[i];  
    }   
    a[i]=x;  
    quickSort(l,i-1);  
    quickSort(i+1,r);  
}   
  
int main()  
{  
    quickSort(0,LEN-1);  
    for(int i=0;i<LEN;i++)  
        cout<<a[i]<<" ";  
    cout<<endl;  
    return 0;  
}   

堆排序:

通过建立大根堆或者小根堆进行排序。想升序排序就使用大顶堆,反之使用小顶堆。(因为每次都将堆顶元素放到

末尾)


#include<iostream>  
#include<algorithm>  
using namespace std;  
#define LEN 6  
  
int a[]={10,9,11,6,20,17};  
  
//以大根堆为例   
void buildHeap(int id, int maxid)  
{  
    int left=id<<1|1;  
    int right=left+1;  
    if(left<=maxid)  
    {  
        buildHeap(left, maxid);  
        if(a[id]<a[left])  
            swap(a[id],a[left]);  
    }  
    if(right<=maxid)  
    {  
        buildHeap(right, maxid);  
        if(a[id]<a[right])  
            swap(a[id],a[right]);  
    }  
      
}   
  
void heapSort()  
{  
    int len=LEN-1;  
    while(len)  
    {  
        buildHeap(0,len);  
        swap(a[0],a[len]);  
        --len;  
    }  
}  
  
int main()  
{  
    heapSort();  
    for(int i=0;i<LEN;i++)  
        cout<<a[i]<<" ";  
    cout<<endl;  
    return 0;  
}   

希尔排序:

希尔排序是插入排序的一种高效率的实现,也叫缩小增量排序。简单的插入排序中,如果待排序列是正序时,时间

复杂度是O(n),如果序列是基本有序的,使用直接插入排序效率就非常高。希尔排序就利用了这个特点。基本思想

是:先将整个待排记录序列分割成为若干子序列分别进行直接插入排序,待整个序列中的记录基本有序时再对全体

记录进行一次直接插入排序。

#include<iostream>  
#include<algorithm>  
using namespace std;  
#define LEN 6  
  
int a[]={10,9,11,6,20,17};  
  
void insertSort(int l,int r)  
{  
    int index,temp;  
    for(int i=l+1;i<=r;i++)  
    {  
        //一步步慢慢向前进   
        index=i; temp=a[i];  
        while(index>l && temp<a[index-1])  
        {  
            swap(a[index],a[index-1]); --index;  
        }  
    }  
}   
  
//分三级增量 分别为3 2 1   
int gap=3;   
void shell_sort()  
{  
    for(int i=gap;i>=1;i--)  
    {  
        for(int j=0;j+i<LEN;j++)  
        {  
            insertSort(j,j+i);  
        }  
    }  
}  
  
int main()  
{  
    shell_sort();  
    for(int i=0;i<LEN;i++)  
        cout<<a[i]<<" ";  
    cout<<endl;  
    return 0;  
}  

归并排序:

归并排序是另一种不同的排序方法,因为归并排序使用了递归分治的思想,所以理解起来比较容易。其基本思想

是,先递归划分子问题,然后合并结果。把待排序列看成由两个有序的子序列,然后合并两个子序列,然后把子

序列看成由两个有序序列。。。。。倒着来看,其实就是先两两合并,然后四四合并。。。最终形成有序序列。

空间复杂度为O(n),时间复杂度为O(nlogn)。

还是上张图吧:




#include<iostream>  
#include<algorithm>  
using namespace std;  
#define LEN 6  
  
int a[]={10,9,11,6,20,17};  
  
void merge(int l1,int r1,int l2,int r2)  
{  
    int cou=0;  
    int temp[LEN]; //临时数组   
    int i,j;  
    for(i=l1,j=l2;i<=r1&&j<=r2;)  
    {  
        if(a[i]<a[j])  
            temp[cou++]=a[i++];  
        else  
            temp[cou++]=a[j++];  
    }  
    while(i<=r1)  
        temp[cou++]=a[i++];  
    while(j<=r2)  
        temp[cou++]=a[j++];  
    cou=0;  
    for(int i=l1;i<=r2;i++)  
    {  
        a[i]=temp[cou++];  
    }  
}  
  
void mergeSort(int l,int r)  
{  
    if(l==r)  
        return;  
    int mid=(l+r)/2;  
    mergeSort(l,mid);  
    mergeSort(mid+1,r);  
    merge(l,mid,mid+1,r);  
      
}   
  
int main()  
{  
    mergeSort(0,LEN-1);  
    for(int i=0;i<LEN;i++)  
        cout<<a[i]<<" ";  
    cout<<endl;  
    return 0;  
}  

计数排序:

如果在面试中有面试官要求你写一个O(n)时间复杂度的排序算法,你千万不要立刻说:这不可能!虽然前面基于比

较的排序的下限是O(nlogn)。但是确实也有线性时间复杂度的排序。,只不过有前提条件,就是待排序的数要满足

一定的范围的整数,而且计数排序需要比较多的辅助空间。其基本思想是,用待排序的数作为计数数组的下标,统

计每个数字的个数。然后依次输出即可得到有序序列。

#include<iostream>  
#include<algorithm>  
#include<cstring>  
using namespace std;  
#define LEN 6  
#define MAX 20  
  
int a[]={10,9,11,6,20,17};  
  
int counter[MAX+1]; //计数数组   
  
int main()  
{  
    memset(counter,0,sizeof(counter));//数组清零  
    for(int i=0;i<LEN;i++)  
    {  
        counter[a[i]]++;  
    }   
       
      
    for(int i=0;i<=MAX;i++)  
    {  
        for(int j=0;j<counter[i];j++)  
            cout<<i<<" ";  
    }  
    cout<<endl;  
    return 0;  
}   

桶排序:

假设有一组长度为N的待排关键字序列K[1....n]。首先将这个序列划分成M个的子区间(桶) 。然后基于某种映射函

数 ,将待排序列的关键字k映射到第i个桶中(即桶数组B的下标i) ,那么该关键字k就作为B[i]中的元素(每个桶B[i]

都是一组大小为N/M的序列)。接着对每个桶B[i]中的所有元素进行比较排序(可以使用快排)。然后依次枚举输出

B[0]....B[M]中的全部内容即是一个有序序列。bindex=f(key)   其中,bindex 为桶数组B的下标(即第bindex个桶),

 k为待排序列的关键字。桶排序之所以能够高效,其关键在于这个映射函数,它必须做到:如果关键字k1<k2,那

么f(k1)<=f(k2)。也就是说B(i)中的最小数据都要大于B(i-1)中最大数据。很显然,映射函数的确定与数据本身的特

点有很大的关系。

#include<iostream>  
#include<algorithm>  
using namespace std;  
#define LEN 6  
  
int a[]={10,9,11,6,20,17};  
  
int bucket[3][LEN];   
  
int main()  
{  
    int temp;  
    memset(bucket,0,sizeof(bucket));  
    for(int i=0;i<LEN;i++)  
    {  
        temp=a[i]/10;  
        int index=++bucket[temp][0];  
        bucket[temp][index]=a[i];  
    }  
      
    for(int i=0;i<3;i++)  
    {  
        if(bucket[i][0])  
            sort(bucket[i]+1, bucket[i]+1+bucket[i][0]);//这里耍个赖皮 桶里的排序方法可自行选择   
    }  
      
    for(int i=0;i<3;i++)  
    {  
        for(int j=1;j<=bucket[i][0];j++)  
        {  
            cout<<bucket[i][j]<<" ";  
        }  
    }  
    cout<<endl;  
    return 0;  
}   

基数排序:

基数排序又是一种和前面排序方式不同的排序方式,基数排序不需要进行记录关键字之间的比较。基数排序是一种借

助多关键字排序思想对单逻辑关键字进行排序的方法。所谓的多关键字排序就是有多个优先级不同的关键字。比如说

成绩的排序,如果两个人总分相同,则语文高的排在前面,语文成绩也相同则数学高的排在前面。。。如果对数字进

行排序,那么个位、十位、百位就是不同优先级的关键字,如果要进行升序排序,那么个位、十位、百位优先级一次

增加。基数排序是通过多次的收分配和收集来实现的,关键字优先级低的先进行分配和收集。

我选择了队列这个数据结构,因为我觉得队列比较合适,但实现起来并不让我满意,如果大牛们有指教,非常欢迎!

#include<iostream>  
#include<algorithm>  
#include<queue>   
#include<cstring>  
using namespace std;  
#define LEN 6  
  
int a[]={10,9,11,6,20,17};  
queue<int> que[10];  
int counter[10];  
//获取这个整数有几位   
int getNumberOfInt(int a)  
{  
    int cou=0;  
    while(a)  
    {  
        ++cou; a/=10;  
    }  
    return cou;  
}  
  
//获取整数a的第n位数   
int getNum(int a,int n)  
{  
    for(int i=0;i<n-1&&a;i++)  
    {  
        a/=10;  
    }   
    return a%10;  
}  
  
int main()  
{  
    int maxN=0;  
    int temp;  
    memset(counter,0,sizeof(counter));  
    //计算得出最多循环几轮   
    for(int i=0;i<LEN;i++)  
        maxN=max(maxN,getNumberOfInt(a[i]));  
      
    //第一轮先入队列  
    for(int i=0;i<LEN;i++)  
    {  
        temp=a[i]%10;  
        que[temp].push(a[i]);  
    }   
      
    for(int k=2;k<=maxN;k++)  
    {  
        for(int ii=0;ii<10;ii++)  
            counter[ii]=que[ii].size();//统计该队列原本个数   
          
        for(int i=0;i<10;i++)  
        {  
            for(int j=0;j<counter[i];j++)  
            {  
                int t=que[i].front();  
                int index=getNum(t,k);  
                que[index].push(t);  
                que[i].pop();   
            }  
        }  
    }  
      
      
    for(int i=0;i<10;i++)  
    {  
        while(!que[i].empty())  
        {  
            cout<<que[i].front()<<" "; que[i].pop();  
        }  
    }  
    cout<<endl;  
    return 0;  
}  




出现 Connection Failed [MySQL][ODBC Driver]Access denied for user ‘root‘@x(using password:YES)解决方法 Connection Failed [MySQL][ODBC 8.0(w) Driver]Access denied for user 'root'@xxxx (using password:YES) 阅读详情

相关推荐

【YOLO 系列】基于YOLO V8的智能车载交通标志识别系统【python源码+Pyqt5界面+数据集+训练代码】

本文详细介绍了基于YOLO V8构建智能车载交通标志识别系统的完整流程。从环境搭建、数据集准备、模型训练到PyQt5图形界面开发,提供了Python源码和实战代码,帮助开发者快速实现高精度、实时的交通标志检测应用,提升驾驶辅助系统的开发效率。

wdx012345的博客 968

常用十大排序算法

列举了常见的十大内部排序算法:插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序,计数排序,桶排序。

qq_51664685的博客 15万+

【人工智能AI】是什么?

人工智能(Artificial Intelligence),英文缩写为AI。它是研究、开发用于模拟延伸和扩展人的智能的理论方法技术及应用系统的一门新的技术科学。(百度百科)人工智能的基本原理:机器从「特定的」大量数据中总结规律,形成某些「特定的知识」,然后将这种「知识」应用到现实场景中去解决实际问题。在这个基本原理的基础上,有3个特征:1、人工智能本质上是一种工具2、人工智能技能只能解决特定的问题,而不是什么都能做3、人工智能属于归纳逻辑,可以告诉你是什么,但是不能告诉你为什么。

KJCZ.AK的博客 2万+

六种常见的排序算法

常见的六种排序算法

qq_46721967的博客 7793

从零到一:手把手教你用STM32F103C8T6打造个人专属开发板(附立创EDA工程与源码)

本文详细介绍了如何使用STM32F103C8T6微控制器从零开始设计和制作个人专属开发板。内容涵盖硬件选型、原理图设计、PCB布局、功能验证等全流程,并提供了立创EDA工程文件和源码,帮助开发者深入理解STM32开发板的硬件架构与设计要点。

weixin_26802933的博客 287

告别手动拖拽!PyQt5/PyQt6 QTableView列宽自适应窗口的三种实战方案(附性能对比)

本文详细介绍了PyQt5/PyQt6中QTableView列宽自适应窗口的三种实战方案,包括Stretch模式、resizeEvent手动计算和ResizeToContents模式,并附有性能对比。帮助开发者解决窗口大小变化时列宽不变的常见问题,提升用户体验和开发效率。

weixin_42538752的博客 236

十大排序算法(Top 10 Sorting Algorithms)

十种常见排序算法可以分为两大类: 比较类排序:通过比较来决定元素间的相对次序,由于其时间复杂度不能突破O(nlogn),因此也称为非线性时间比较类排序。 非比较类排序:不通过比较来决定元素间的相对次序,它可以突破基于比较排序的时间下界,以线性时间运行,因此也称为线性时间非比较类排序。......

果冻の技术星球 1万+

Gartner DSG数据安全治理 架构及解读

目录背景:架构图: 解释:英文解释:(自上而下)平衡业务与风险、威胁、合规之间的关系(5个维度之间的平衡)优先处理数据集制定安全策略实施安全工具策略配置同步从上到下,从需求调研开始实施数据安全治理。千万不要跨过数据摸底、治理优先级分析、制定治理整体策略,而直接从技术工具开始对数据安全进行治理。 先明确选择需要治理的对象,优先选择重要数据进行数据安全治理工作。可以通过数据梳理、分类分级等手段,完成数据资产盘点和筛选,在纷杂的数据中理清头绪。

锦慈的技术博客 7220

十大经典排序算法总结整理

参考文章: 十大经典排序算法最强总结:https://www.cnblogs.com/guoyaohua/p/8600214.html 排序算法总结:https://www.runoob.com/w3cnote/sort-algorithm-summary.html 术语说明 内排序:所有排序操作都在内存中完成; 外排序:由于数据太大,因此把数据放在磁盘中,而排序通过磁盘和内存的数...

ytusdc的博客 6955

华为OD机试新系统真题【迷宫相遇】

华为OD机试 新系统真题【迷宫相遇】,提供C语言、Java、C++、Python、Go、JavaScript源码实现,并提供完整思路讲解,以及在线OJ模拟做题。华为OD机试真题【迷宫相遇】多语言题解。

qq_45776114的博客 774

浪涌抗扰度部分解读

8.3 测试仪器: 8.3.1浪涌发生器(对于连接到对称通信线的接口采用10/700us的组合波发生器;对于其他情况采用1.2/50us(8/20us)组合波发生器,输出极性正负可调、移相范围0-360°可调,最大重复率至少每分钟1次,开路输出电压0.5-4kV,电源线的话有效效输出阻抗为2Ω,通信线的话有效输出阻抗为40Ω) 8.3.2 耦合/去耦网络 8.3.3 参考接地平板 8...

喵叫兽的博客 2506

十大常用经典排序算法总结!!!

爆肝整理!堪称全网最详细的十大常用经典排序算法总结!!! 写在开头,本文经过参考多方资料整理而成,全部参考目录会附在文章末尾。很多略有争议性的细节都是在不断查阅相关资料后总结的,具有一定普适性。 总表: 相关解释: 稳定:如果原本序列中a在b前面且a=b,排序后a仍在b前面,顺序不变; 不稳定:如果原本序列中a在b前面且a=b,排序后a可能在b后面,顺序可能发生改变; 内排序:所有排序操作均在内存中完成; 外排序:由于数据量太大,将其放入磁盘中,排序过程中需要磁盘与内存之间的数据传输;

Jing Sir的博客 5万+

EMC辐射整改常用的4种整改方法

例如,产品设计研发工程师们根据需求,设计出效果良好的滤波电路,置入产品I/O(输入/输出)接口的前级,可使因传导而进入系统的干扰噪声消除在电路系统的入口处;通过选择元器件和合理安排的电路系统,使干扰的影响减少。有些频率点是通过电路板上走线分布参数所决定的,通过前述方法不大有用,此类整改通过在走线中增加小的电感、电容、磁珠来改变电路参数结构,使其移到限值要求较高的频率点上。电线电缆的分类整理在电子设备中,线间耦合是一种重要的途径,也是造成干扰的重要原因,因为频率的因素,可大体分为高频耦合与低频耦合。

学海无涯的专栏 3125

一文搞掂十大经典排序算法

一文搞掂十大经典排序算法 今天整理一下十大经典排序算法。 1、冒泡排序 ——越小的元素会经由交换慢慢“浮”到数列的顶端 算法演示 算法步骤 比较相邻的元素。如果第一个比第二个大,就交换它们两个; 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对,这样在最后的元素应该会是最大的数; 针对所有的元素重复以上的步骤,除了最后一个; 重复步骤1~3,直到排序完成。 算法实现 def bubbleSort(arr): for i in range(1, len(arr)): f

不才伟才的博客 1万+

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

十大经典排序算法总结

十大经典排序算法总结

凡的博客 4809

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox(带书签),MATLAB统计学习工具

【数据结构】十大经典排序算法总结与分析

十大经典排序算法总结与分析,以及一些排序中相关内容的补充

2301_80191662的博客 2761

visio安装包

Microsoft Office Visio 是一款专业的制图软件。利用经过更新的形状、协作工具和数据链接图表,创建专业级图表以简化复杂的信息。

十大经典排序算法总结(Java实现+动画)

最近在梳理《数据结构与算法》的内容,在网上看了几篇不错的文章,现在根据自己的理解重新整理一下十大经典排序算法。实际生产中,最好的算法一定是结合数据集本身的特点(大小,长度,是否已经基本有序等等)来选择的,不要拘泥于算法本身。 我参考的文章有:https://www.cnblogs.com/guoyaohua/p/8600214.html,https://blog.youkuaiyun.com/liang_g...

meibenxiang的博客 5万+

python的十大经典排序算法

十大经典排序算法 该文章参照菜鸟教程,也有自己的部分理解。 一、简介 排序算法是《数据结构与算法》中最基本的算法之一。 排序算法可以分为内部排序和外部排序,内部排序是数据记录在内存中进行排序,而外部排序是因排序的数据很大,一次不能容纳全部的排序记录,在排序过程中需要访问外存。常见的内部排序算法有:插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。用一张图概括: 关于时间复杂度: 平方阶 (O(n2)) 排序 各类简单排序: 直接插入、直接选择和冒泡排序。 线性对

胖大xian 4294
上一篇: TCP的那些事儿(2)
下一篇: 数据库用seq语句从创建数据库到给表添加约束条件(改进)
戴着眼镜看不清
博客等级 码龄10年 1189粉丝 111原创
评论 8
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值