算法---排序汇总

最新推荐文章于 2024-07-24 16:36:45 发布
最新推荐文章于 2024-07-24 16:36:45 发布
阅读量718 收藏
点赞数
分类专栏： C++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/star267/article/details/8127159
版权
C++ 同时被 2 个专栏收录
13 篇文章 0 订阅
订阅专栏
算法
10 篇文章 0 订阅
订阅专栏


冒泡排序法

 冒泡排序法的基本思想是：对待排序记录关键字从后往前（逆序）进行多遍扫描，当发现相邻两个关键字的次序与排序要求的规则不符时，就将这两个记录进行交换。这样，关键字较小的记录将逐渐从后面向前面移动，就象气泡在水中向上浮一样，所以该算法也称为气泡排序法。

程序如下：

//冒泡排序法
//可以进行优化，定义个标志位，排序完成后，无需进行后面的操作
//2012,10,28
#include <iostream>
#include <stdlib.h>
#include<time.h>
#include<stdexcept>
using namespace std;

const int ARRAYLEN=25;
//创建一个随机数组，a保存生成的数据，n为数组元素的数量,min ,max 为生成随机数的范围
int CreateData(int arr[],int n,int min,int max)
{
    int i,j,flag;
    srand(time(NULL));
    if((max-min+1)<n)
        return 0; //最大数与最小数之差小于产生数组的数量，生成数据不成功
    for(i=0;i<n;i++)
    {
        do
        {
            arr[i]=(max-min+1)*rand()/(RAND_MAX+1)+min;
            flag=0;
            for(j=0;j<i;j++)
            {
                if(arr[i]==arr[j])
                    flag=1;
            }
        }while(flag);
    }
    return 1;
}
//核心就是个数据交换
void BubbleSort(int a[],int n)
{
    int i,j,t;
    for(i=0;i<n-1;i++)
    {
        for(j=n-1;j>i;j--)
        {
            if(a[j-1]>a[j])
            {
                t=a[j-1];
                a[j-1]=a[j];
                a[j]=t;
            }
        }
        cout<<"第 "<<i+1<<" 遍排序: ";
        for(j=0;j<n;j++)
            cout<<a[j]<<"  ";
        cout<<endl;
    }
}
//test test
int main()
{
    int i,a[ARRAYLEN]={0};
    if(!CreateData(a,ARRAYLEN,1,300))
        throw runtime_error("cannot creat the random array");
    cout<<"原数据:";
    for(i=0;i<ARRAYLEN;i++)
        cout<<a[i]<<"  ";
    cout<<endl;
    BubbleSort(a,ARRAYLEN);
    cout<<endl;
    return 0;
}

快速排序法

  快速排序使用分治策略来把待排序数据序列分为两个子序列，具体步骤为：

（1）从数列中挑出一个元素，称该元素为“基准”。

（2）扫描一遍数列，将所有比“基准”小的元素排在基准前面，所有比“基准”大的元素排在基准后面。

（3）通过递归，将各子序列划分为更小的序列，直到把小于基准值元素的子数列和大于基准值元素的子数列排序。

//快速排序
//递归，分治思想
//2012,10,28
#include<iostream>
#include<time.h>
#include<stdlib.h>
#include<stdexcept>
using namespace std;
const int ARRAYLEN=10;
//创建一个随机数组，a保存生成的数据，n为数组元素的数量,min ,max 为生成随机数的范围
int CreateData(int arr[],int n,int min,int max)
{
    int i,j,flag;
    srand(time(NULL));
    if((max-min+1)<n)
        return 0; //最大数与最小数之差小于产生数组的数量，生成数据不成功
    for(i=0;i<n;i++)
    {
        do
        {
            arr[i]=(max-min+1)*rand()/(RAND_MAX+1)+min;
            flag=0;
            for(j=0;j<i;j++)
            {
                if(arr[i]==arr[j])
                    flag=1;
            }
        }while(flag);
    }
    return 1;
}
//将数组分割
int Division(int a[],int left, int right)
{
    int base=a[left];    //基准元素
    while(left<right)
    {
        while(left<right && a[right]>base)
            --right;     //从右向左找第一个比基准小的元素
        a[left]=a[right];
        while(left<right && a[left]<base )
            ++left;      //从左向右找第一个比基准大的元素
        a[right]=a[left];
    }
    a[left]=base;
    return left;
}
//递归调用
void QuickSort(int a[],int left,int right)
{
    int i,j;
    if(left<right)
    {
        i=Division(a,left,right);   //分割
        QuickSort(a,left,i-1);     //将两部分分别排序
        QuickSort(a,i+1,right);
    }
}
int main()
{
    int i,a[ARRAYLEN]={0};
    if(!CreateData(a,ARRAYLEN,1,1000))
        throw runtime_error("can not creat random array");
    cout<<" 生成数据:  "<<endl;
    for(i=0;i<ARRAYLEN;i++)
        cout<<a[i]<<"  ";
    cout<<endl;
    QuickSort(a,0,ARRAYLEN-1);
    cout<<"after sorted:"<<endl;
    for(i=0;i<ARRAYLEN;i++)
        cout<<a[i]<<"  ";
    cout<<endl;
    return 0;
}


简单选择排序法

             选择排序（Selection Sort）的基本思想：对n个记录进行扫描，选择最小的记录，将其输出，接着在剩下的n-1个记录中扫描，选择最小的记录将其输出，……不断重复这个过程，直到只剩一个记录为止。

//选择排序法
//选出最值，让他当排头，依次往后，从剩下的数种选出最值，排队
//2012,10,28
#include<iostream>
#include<time.h>
#include<stdexcept>
using namespace std;
const int ARRAYLEN=10;
//创建一个随机数组，a保存生成的数据，n为数组元素的数量,min ,max 为生成随机数的范围
int CreateData(int arr[],int n,int min,int max)
{
    int i,j,flag;
    srand(time(NULL));
    if((max-min+1)<n)
        return 0; //最大数与最小数之差小于产生数组的数量，生成数据不成功
    for(i=0;i<n;i++)
    {
        do
        {
            arr[i]=(max-min+1)*rand()/(RAND_MAX+1)+min;
            flag=0;
            for(j=0;j<i;j++)
            {
                if(arr[i]==arr[j])
                    flag=1;
            }
        }while(flag);
    }
    return 1;
}
//显示数组的display函数
void display(int arr[],int n)
{
    for(int i=0;i!=n;++i)
        cout<<arr[i]<<"  ";
    cout<<endl;
}
//选择排序
void SelectSort(int a[],int n)
{
    int i,j,t,k;
    for(i=0;i<n-1;i++)
    {
        k=i;
        for(j=i+1;j
   
   
    
    a[j]) k=j;
        t=a[i];
        a[i]=a[k];
        a[k]=t;    
    }
}
int main()
{
    int i,a[ARRAYLEN]={0};
    if(!CreateData(a,ARRAYLEN,1,100))
        throw runtime_error("can not creat the random array");
    cout<<"随机数组："<<endl;
    display(a, ARRAYLEN);
    SelectSort(a,ARRAYLEN);
    cout<<"after sorted:"<<endl;
    display(a, ARRAYLEN);
    return 0;
}

直接插入排序法

  插入排序（Insertion Sort）的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，在从后向前扫描过程中，需要反复把已排序元素逐步向后移动，为最新元素提供插入空间。复杂度高。

//直接插入排序法
//构建有序序列，对于未排序数据，找到相应位置并插入
//2012,10,28
#include<iostream>
#include<time.h>
#include<stdexcept>
using namespace std;
const int ARRAYLEN=10;
//创建一个随机数组，a保存生成的数据，n为数组元素的数量,min ,max 为生成随机数的范围
int CreateData(int arr[],int n,int min,int max)
{
    int i,j,flag;
    srand(time(NULL));
    if((max-min+1)<n)
        return 0; //最大数与最小数之差小于产生数组的数量，生成数据不成功
    for(i=0;i<n;i++)
    {
        do
        {
            arr[i]=(max-min+1)*rand()/(RAND_MAX+1)+min;
            flag=0;
            for(j=0;j<i;j++)
            {
                if(arr[i]==arr[j])
                    flag=1;
            }
        }while(flag);
    }
    return 1;
}
//显示数组的display函数
void display(int arr[],int n)
{
    for(int i=0;i!=n;++i)
        cout<<arr[i]<<"  ";
    cout<<endl;
}
//直接插入排序,在已排序序列中从后向前扫描
void InsertSort(int a[],int n)
{
    int i,j,t;
    for(i=1;i<n;i++)
    {
        t=a[i];     //取出一个未排序的数据
        for(j=i-1;j>=0 && t<a[j];--j)     //在排序序列中查找位置
            a[j+1]=a[j]; //向后移动数据
        a[j+1]=t; //插入数据到序列
    }
}
int main()
{
    int i,a[ARRAYLEN]={0};
    if(!CreateData(a,ARRAYLEN,1,100))
        throw runtime_error("can not creat the random array");
    cout<<"随机数组："<<endl;
    display(a, ARRAYLEN);
    InsertSort(a,ARRAYLEN);
    cout<<"after sorted:"<<endl;
    display(a, ARRAYLEN);
    return 0;
}

 希尔排序法

       希尔排序又称为缩小增量排序，也属于插入排序类的算法，是对直接插入排序的一种改进。

      基本思想就是：将需要排序的序列划分为若干个较小的序列，对这些序列进行直接插入排序，通过这样的操作可使用需要排序的数列基本有序，最后再使用一次直接插入排序。这样，首先对数量较小的序列进行直接插入排序可提高效率，最后对基本有序的序列进行直拦插入排序，也可提高效率，从而使整个排序过程的效率得到提升。

 

//希尔排序法
#include<iostream>
#include<time.h>
#include<stdexcept>
using namespace std;
const int ARRAYLEN=10;
//创建一个随机数组，a保存生成的数据，n为数组元素的数量,min ,max 为生成随机数的范围
int CreateData(int arr[],int n,int min,int max)
{
    int i,j,flag;
    srand(time(NULL));
    if((max-min+1)<n)
        return 0; //最大数与最小数之差小于产生数组的数量，生成数据不成功
    for(i=0;i<n;i++)
    {
        do
        {
            arr[i]=(max-min+1)*rand()/(RAND_MAX+1)+min;
            flag=0;
            for(j=0;j<i;j++)
            {
                if(arr[i]==arr[j])
                    flag=1;
            }
        }while(flag);
    }
    return 1;
}
//显示数组的display函数
void display(int arr[],int n)
{
    for(int i=0;i!=n;++i)
        cout<<arr[i]<<"  ";
    cout<<endl;
}
//希尔排序
void ShellSort(int a[],int n)
{
    int d,i,j,x;
    d=n/2;
    while(d>=1) //循环至增量为1时结束
    {
        for(i=d;i<n;i++)
        {
            x=a[i]; //获取序列中的下一个数据
            j=i-d; //序列中前一个数据的序号
            while(j>=0 && a[j]>x) //下一个数大于前一个数
            {
                a[j+d]=a[j]; //将后一个数向前移动
                j=j-d; //修改序号，继续向前比较
            }
            a[j+d]=x; //保存数据
        }
        d/=2;  //缩小增量
    }
}
int main()
{
    int i,a[ARRAYLEN]={0};
    if(!CreateData(a,ARRAYLEN,1,100))
        throw runtime_error("can not creat the random array");
    cout<<"the array created："<<endl;
    display(a, ARRAYLEN);
    ShellSort(a,ARRAYLEN);
    cout<<"after sorted:"<<endl;
    display(a, ARRAYLEN);
    return 0;
}


star267
关注
专栏目录
排序算法汇总---Java实现各个排序
、思考致富的博客
03-01 839
排序算法汇总 下图来自菜鸟教程： 下面所有方法都有static关键字，因为测试的时候需要被main函数调用，故添加static。 若需要c++版本的算法实现，可参考下面博文连接 排序算法汇总—C++实现各个排序 1、冒泡排序 // 冒泡排序 static void bubble_sort(int[] arr) { for (int i = 0; i < arr.length - 1; i++) { // n-1趟 for (int j = 0
十大排序算法
热门推荐
个人站点：javatv.net
08-20 2万+
冒泡排序 从数组头开始，比较相邻的元素。如果第一个比第二个大(小)，就交换它们两个 对每一对相邻元素作同样的工作，从开始第一对到尾部的最后一对，这样在最后的元素应该会是最大(小)的数 重复步骤1~2，重复次数等于数组的长度，直到排序完成 代码实现 对下面数组实现排序：{24, 7, 43, 78, 62, 98, 82, 18, 54, 37, 73, 9} 代码实现 public class BubbleSort { public static final int[] ARRAY = {2
排序和查找算法--总结
qq_36006996的博客
11-16 1390
一、分类 1.内部排序和外部排序　 内部排序：待排序记录存放在计算机随机存储器中（说简单点，就是内存）进行的排序过程。 外部排序：待排序记录的数量很大，以致于内存不能一次容纳全部记录，所以在排序过程中需要对外存进行访问的排序 2.比较类排序和非比较排序 比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此也称为非线性时间比较类排序。 非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此也称为线性时间非.
java面试算法汇总-排序问题
zlsd21的博客
03-10 300
排序问题
数据结构-排序算法汇总 -C语言
weixin_53284122的博客
03-08 425
排序算法的原理在此就不再叙述，后面代码里面注释也有原理的体现1.插入排序。
排序算法-汇总
张井天的博客
12-06 108
菜鸟教程： https://www.runoob.com/w3cnote_genre/algorithm
C语言常见的四大排序算法--插入排序、选择排序、交换排序、归并排序的实现讲解与性能对比
m0_74949249的博客
05-03 960
本文详细介绍了四大排序算法（插入排序，选择排序，交换排序，归并排序）以及它们的优化算法（希尔排序，堆排序，快速排序），并进行了它们之间的性能比较。如有错误，请批评指正，希望大家多多支持。
排序算法-归并排序的Python实现
weixin_43226196的博客
02-18 366
归并排序算法的python实现
算法-排序
在你最感兴趣的事物上，隐藏着你人生的秘密
02-03 404
所谓排序,理解起来很简单,就是将一串记录按照一定的规则重新排列。  杂乱无章的数据是很难进行查找和分析的.所以想要高效的使用大量数据，保证数据有序这个前提是很重要的。  也因此，排序算法在很多领域得到相当地重视，尤其是在大量数据的处理方面。一个优秀的算法可以节省大量的资源。在各个领域中考虑到数据的各种限制和规范，要得到一个符合大众的需求的实际的优秀算法，得经过大量的推理和分析。  经典的排序
排序算法---9.桶排序
最新发布
qq_34213197的博客
07-24 114
桶排序还是针对技术排序的升级版，当数组是数据是按照10,20,30 这种范围比较广的数据，且存在小数等数据时，就不适合使用计数排序，此处可以使用桶排序。 假设一个数组是1-100以内的数据组成的数组。可以把数组划分为10个桶，第一个桶是 1-10，第二个桶是11-20 。。。最后一个桶是91-100 把每个桶的数据进行排序，再汇总就可以了。 ...
资料汇总:数学建模常用算法----综合评价方法.zip
10-08
本资料汇总着重介绍了几种常用的数学建模算法，包括主成分分析法（PCA）、模糊综合评价以及层次分析法（AHP），并可能包含MATLAB实现的相关示例，这对于理解和应用这些方法非常有帮助。 1. **主成分分析法（PCA）**...
基于Qt5-实现九大排序算法的代码汇总
02-16
在本文中，我们将深入探讨如何使用Qt5框架和C++编程语言实现九大经典的排序算法。Qt5是一个跨平台的应用程序开发框架，它提供了丰富的库和工具，使得开发人员能够便捷地构建用户界面和应用程序逻辑。C++则是一种强大...
python常用排序算法汇总
02-19
该程序包含7大排序算法: # sort.bubbleSort() #冒泡排序 # sort.shellSort() #希尔排序 # sort.insertionSort() #插入排序 # sort.Selectionsort1() #选择排序 # sort.heapSort() #堆排序 # sort.countSort() ...
算法分析与设计实验报告-合并排序、快速排序[汇总].doc
05-30
"算法分析与设计实验报告-合并排序、快速排序" 本实验报告的主要目的是学习合并排序和快速排序算法的思想，掌握原理，并运用这些算法的思想进行编程实现，以加深理解。 一、实验目的 学习合并排序和快速排序算法...
算法----字典序问题
star267的专栏
10-24 4344
问题描述：在数据加密和数据压缩中常需要对特殊的字符串进行编码。给定的字母表由26个小写的英文字母组成，每个字母对应一个数字。对应表如下： a---1 b---2 c---3 . . . . z---26 aa--27 ab--28 ac--29 . . . . 要求，给定一个输入文件，里面是字母，迅速算出它在上面对应表中的数字，然后存入一个输出文件中。 例如：
数独算法 C++
star267的专栏
11-29 2788
#include #include #include using namespace std; static bool sign=false; ifstream &open_file(ifstream &in, string &file) { in.close(); in.clear(); in.open(file.c_str()); return in; } c
ACM 1324. Score
star267的专栏
11-24 1586
1324. Score Constraints Time Limit: 1 secs, Memory Limit: 32 MB Description There is an objective test result such as ``OOXXOXXOOO". An `O' means a correct answer of a problem and
我哪里错了？
star267的专栏
04-06 1383
编程之美——传话游戏 描述 Alice和Bob还有其他几位好朋友在一起玩传话游戏。这个游戏是这样进行的：首先，所有游戏者按顺序站成一排，Alice站第一位，Bob站最后一位。然后，Alice想一句话悄悄告诉第二位游戏者，第二位游戏者又悄悄地告诉第三位，第三位又告诉第四位……以此类推，直到倒数第二位告诉Bob。两位游戏者在传话中，不能让其他人听到，也不能使用肢体动作来解释。最后，Bob把他所听到
ACM 4188. 进制转换
star267的专栏
11-24 1179
4188. 进制转换 Constraints Time Limit: 1 secs, Memory Limit: 256 MB Description 输入一个非负的十进制整数，将其转为二进制. Input 输入的第一行是一个整数T，表示总共有T组数据. 接下来的T行，每行是一组数据，每组数据是一个待转换的十进制整数n（0
JAVA排序算法详解与实现
"这篇文档是关于JAVA排序算法的汇总，涵盖了多种常见的排序算法，并提供了相关的JAVA实现。排序算法包括插入排序、交换排序、选择排序、归并排序和基数排序。文档还提到了根据数据规模和初始顺序选择合适排序算法的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值