常用排序算法实现

最新推荐文章于 2024-07-25 23:10:45 发布
最新推荐文章于 2024-07-25 23:10:45 发布
阅读量108 收藏
点赞数 1
分类专栏： 算法 文章标签： 排序算法 算法 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51507437/article/details/121941882
版权

冒泡排序

#include<iostream>

using namespace std;

void BubbleSortAsc(double num[],int length)
{
    bool exchange=true;
    for(int i=0;i<length-1;i++)
    {
        for(int j=0;j<length-1-i;j++)
        {
            if(num[j]>num[j+1])
            {
                double t=num[j];
                num[j]=num[j+1];
                num[j+1]=t;
                exchange=false;
            }
        }
        if(exchange)
            break;
    }
}

void BubbleSortDesc(double num[],int length)
{
    bool exchange=true;
    for(int i=0;i<length-1;i++)
    {
        for(int j=0;j<length-1-i;j++)
        {
            if(num[j]<num[j+1])
            {
                double t=num[j];
                num[j]=num[j+1];
                num[j+1]=t;
                exchange=false;
            }
        }
        if(exchange)
            break;
    }
}

int main()
{
    double num[1000];
    int length;
    for(length=0;cin>>num[length];length++);
    BubbleSortDesc(num,length);
    for(int i=0;i<length;i++)
        cout<<num[i]<<" ";
    return 0;
}

优化

#include<iostream>

using namespace std;

void BubbleSortAsc(double num[],int length)
{
    bool exchange=true;
    int pos,k=length-1,n=0;//n：最小值下标（首指针）；k：最大值下标（尾指针）；pos：用于记录最后一次交换的位置
    for(int i=0;i<length-1;i++)
    {
        //正向寻找最大值
        pos=0;
        for(int j=n;j<k;j++)
        {
            if(num[j]>num[j+1])
            {
                double t=num[j];
                num[j]=num[j+1];
                num[j+1]=t;
                exchange=false;
                pos=j;
            }
        }
        if(exchange)
            break;
        k=pos;
        //反向寻找最小值
        for(int j=k;j>n;j--)
        {
            if(num[j]<num[j-1])
            {
                double t=num[j-1];
                num[j-1]=num[j];
                num[j]=t;
                exchange=false;
            }
        }
        n++;
        if(exchange)
            break;
    }
}

void BubbleSortDesc(double num[],int length)
{
    bool exchange=true;
    int pos,k=length-1,n=0;
    for(int i=0;i<length-1;i++)
    {
        //正向寻找最小值
        pos=0;
        for(int j=n;j<k;j++)
        {
            if(num[j]<num[j+1])
            {
                double t=num[j];
                num[j]=num[j+1];
                num[j+1]=t;
                exchange=false;
                pos=j;
            }
        }
        if(exchange)
            break;
        k=pos;
        //反向寻找最大值
        for(int j=k;j>n;j--)
        {
            if(num[j]>num[j-1])
            {
                double t=num[j];
                num[j]=num[j-1];
                num[j-1]=t;
                exchange=false;
            }
        }
        n++;
        if(exchange)
            break;
    }
}

int main()
{
    double num[1000];
    int length;
    for(length=0;cin>>num[length];length++);
    BubbleSortDesc(num,length);
    for(int i=0;i<length;i++)
        cout<<num[i]<<" ";
    return 0;
}

选择排序

#include<iostream>

using namespace std;

void SelectionSortAsc(double num[],int length)
{
    int minindex;
    for(int i=0;i<length-1;i++)
    {
        minindex=i;
        for(int j=i+1;j<length;j++)
        {
            if(num[j]<num[minindex])
                minindex=j;
        }
        double t=num[minindex];
        num[minindex]=num[i];
        num[i]=t;
    }
}

void SelectionSortDesc(double num[],int length)
{
    int maxindex;
    for(int i=0;i<length-1;i++)
    {
        maxindex=i;
        for(int j=i+1;j<length;j++)
        {
            if(num[j]>num[maxindex])
                maxindex=j;
        }
        double t=num[maxindex];
        num[maxindex]=num[i];
        num[i]=t;
    }
}

int main()
{
    double num[1000];
    int length;
    for(length=0;cin>>num[length];length++);
    SelectionSortDesc(num,length);
    for(int i=0;i<length;i++)
        cout<<num[i]<<" ";
    return 0;
}

优化

#include<iostream>

using namespace std;

void SelectionSortAsc(double num[],int length)
{
    int minindex,maxindex,left,right;
    for(left=0,right=length-1;left<=right;left++,right--)
    {
        minindex=left;
        maxindex=right;
        for(int i=left;i<=right;i++)
        {
            if(num[i]<num[minindex])
                minindex=i;
            if(num[i]>num[maxindex])
                maxindex=i;
        }
        if(minindex!=left)
        {
            double t=num[minindex];
            num[minindex]=num[left];
            num[left]=t;
            if(maxindex==left)
                maxindex=minindex;

        }
        if(maxindex!=right)
        {
            double t=num[maxindex];
            num[maxindex]=num[right];
            num[right]=t;
        }
    }
}

void SelectionSortDesc(double num[],int length)
{
    int minindex,maxindex,left,right;
    for(left=0,right=length-1;left<=right;left++,right--)
    {
        minindex=right;
        maxindex=left;
        for(int i=left;i<=right;i++)
        {
            if(num[i]<num[minindex])
                minindex=i;
            if(num[i]>num[maxindex])
                maxindex=i;
        }
        if(maxindex!=left)
        {
            double t=num[maxindex];
            num[maxindex]=num[left];
            num[left]=t;
            if(minindex==left)
                minindex=maxindex;
        }
        if(minindex!=right)
        {
            double t=num[minindex];
            num[minindex]=num[right];
            num[right]=t;
        }
    }
}

int main()
{
    double num[1000];
    int length;
    for(length=0;cin>>num[length];length++);
    SelectionSortDesc(num,length);
    for(int i=0;i<length;i++)
        cout<<num[i]<<" ";
    return 0;
}

插入排序

#include<iostream>

using namespace std;

void InsertionSortAsc(double num[],int length)
{
    int preindex;
    double current;
    for(int i=1;i<length;i++)
    {
        if(num[i]>num[i-1])
            continue;//小优化，如果已排好则后面不用执行
        preindex=i-1;
        current=num[i];
        while(preindex>=0&&num[preindex]>current)
        {
            num[preindex+1]=num[preindex];
            preindex--;
        }
        num[preindex+1]=current;
    }
}

void InsertionSortDesc(double num[],int length)
{
    int preindex;
    double current;
    for(int i=1;i<length;i++)
    {
        if(num[i]<num[i-1])
            continue;
        preindex=i-1;
        current=num[i];
        while(preindex>=0&&num[preindex]<current)
        {
            num[preindex+1]=num[preindex];
            preindex--;
        }
        num[preindex+1]=current;
    }
}

int main()
{
    double num[1000];
    int length;
    for(length=0;cin>>num[length];length++);
    InsertionSortDesc(num,length);
    for(int i=0;i<length;i++)
        cout<<num[i]<<" ";
    return 0;
}

折半插入排序

#include<iostream>

using namespace std;

void BinaryInsertionSortAsc(double num[],int length)
{
    int left,right,mid;
    double current;
    for(int i=1;i<length;i++)
    {
        left=0;
        right=i-1;
        current=num[i];
        while(left<=right)
        {
            mid=left+(right-left)/2;//效果等同于（left+right）/2，而且可以防止left+right的和溢出
            if(current<=num[mid])
                right=mid-1;
            else if(current>num[mid])
                left=mid+1;
        }
        for(int j=i;j>left;j--)
            num[j]=num[j-1];
        num[left]=current;
    }
}

void BinaryInsertionSortDesc(double num[],int length)
{
    int left,right,mid;
    double current;
    for(int i=1;i<length;i++)
    {
        left=0;
        right=i-1;
        current=num[i];
        while(left<=right)
        {
            mid=left+(right-left)/2;
            if(current>=num[mid])
                right=mid-1;
            else if(current<num[mid])
                left=mid+1;
        }
        for(int j=i;j>left;j--)
            num[j]=num[j-1];
        num[left]=current;
    }
}

int main()
{
    double num[1000];
    int length;
    for(length=0;cin>>num[length];length++);
    BinaryInsertionSortDesc(num,length);
    for(int i=0;i<length;i++)
        cout<<num[i]<<" ";
    return 0;
}

希尔排序

#include<iostream>

using namespace std;

void ShellSortAsc(double num[],int length)
{
    int gap=length,preindex;
    double current;
    while(gap>1)
    {
        gap=gap/3+1;
        for(int i=gap; i<length; i++)
        {
            preindex=i-gap;
            current=num[i];
            while(preindex>=0&&num[preindex]>current)
            {
                num[preindex+gap]=num[preindex];
                preindex-=gap;
            }
            num[preindex+gap]=current;
        }
    }
}

void ShellSortDesc(double num[],int length)
{
    int gap=length,preindex;
    double current;
    while(gap>1)
    {
        gap=gap/3+1;
        for(int i=gap; i<length; i++)
        {
            preindex=i-gap;
            current=num[i];
            while(preindex>=0&&num[preindex]<current)
            {
                num[preindex+gap]=num[preindex];
                preindex-=gap;
            }
            num[preindex+gap]=current;
        }
    }
}

int main()
{
    double num[1000];
    int length;
    for(length=0;cin>>num[length];length++);
    ShellSortDesc(num,length);
    for(int i=0;i<length;i++)
        cout<<num[i]<<" ";
    return 0;
}

快速排序

#include<iostream>

using namespace std;

void QuickSortAsc(double num[],int left,int right)
{
    int i=left,j=right;
    double mid=num[(left+right)/2];
    do
    {
        while(num[i]<mid)
            i++;
        while(num[j]>mid)
            j--;
        if(i<=j)
        {
            double t=num[i];
            num[i]=num[j];
            num[j]=t;
            i++;
            j--;
        }
    }while(i<=j);
    if(left<j) QuickSortAsc(num,left,j);
    if(i<right) QuickSortAsc(num,i,right);
}

void QuickSortDesc(double num[],int left,int right)
{
    int i=left,j=right;
    double mid=num[(left+right)/2];
    do
    {
        while(num[i]>mid)
            i++;
        while(num[j]<mid)
            j--;
        if(i<=j)
        {
            double t=num[i];
            num[i]=num[j];
            num[j]=t;
            i++;
            j--;
        }
    }while(i<=j);
    if(left<j) QuickSortDesc(num,left,j);
    if(i<right) QuickSortDesc(num,i,right);
}

int main()
{
    double num[1000];
    int length;
    for(length=0;cin>>num[length];length++);
    QuickSortDesc(num,0,length-1);
    for(int i=0;i<length;i++)
        cout<<num[i]<<" ";
    return 0;
}

快速排序（挖坑法）

#include<iostream>

using namespace std;

void QuickSortAsc(double num[],int left,int right)
{
    int i=left,j=right;
    double tmp=num[left];
    while(i<j)
    {
        while(i<j&&num[j]>=tmp)
            j--;
        if(i<j)
            num[i++]=num[j];
        while(i<j&&num[i]<=tmp)
            i++;
        if(i<j)
            num[j--]=num[i];
    }
    num[i]=tmp;
    if(left<j-1) QuickSortAsc(num,left,i-1);
    if(i+1<right) QuickSortAsc(num,i+1,right);
}

void QuickSortDesc(double num[],int left,int right)
{
    int i=left,j=right;
    double tmp=num[left];
    while(i<j)
    {
        while(i<j&&num[j]<=tmp)
            j--;
        if(i<j)
            num[i++]=num[j];
        while(i<j&&num[i]>=tmp)
            i++;
        if(i<j)
            num[j--]=num[i];
    }
    num[i]=tmp;
    if(left<j-1) QuickSortDesc(num,left,i-1);
    if(i+1<right) QuickSortDesc(num,i+1,right);
}

int main()
{
    double num[1000];
    int length;
    for(length=0;cin>>num[length];length++);
    QuickSortDesc(num,0,length-1);
    for(int i=0;i<length;i++)
        cout<<num[i]<<" ";
    return 0;
}

归并排序

#include<iostream>

using namespace std;

void mergeAsc(double num[],int left,int mid,int right)
{
    double tmp[right-left+1];
    int p1=left,p2=mid+1,index=0;
    while(p1<=mid&&p2<=right)
    {
        if(num[p1]<num[p2])
        {
            tmp[index]=num[p1];
            p1++;
            index++;
        }
        else
        {
            tmp[index]=num[p2];
            p2++;
            index++;
        }
    }
//简洁写法：
//while(p1<=mid&&p2<=right)
//    tmp[index++]=num[p1]<num[p2]?num[p1++]:num[p2++];
    while(p1<=mid)//将左边剩余元素填充进tmp中
    {
        tmp[index]=num[p1];
        p1++;
        index++;
    }
//简洁写法：
//while(p1<=mid)
//    tmp[index++]=num[p1++];
    while(p2<=right)//将右序列剩余元素填充进tmp中
    {
        tmp[index]=num[p2];
        p2++;
        index++;
    }
//简洁写法
//while(p2<=right)
//    tmp[index++]=num[p2++];
    for(int i=0;i<right-left+1;i++)
        num[left+i]=tmp[i];
}

void MergeSortAsc(double num[],int left,int right)
{
    if(left>=right)
        return;
    int mid=(left+right)/2;
    MergeSortAsc(num,left,mid);
    MergeSortAsc(num,mid+1,right);
    mergeAsc(num,left,mid,right);
}

void mergeDesc(double num[],int left,int mid,int right)
{
    double tmp[right-left+1];
    int p1=left,p2=mid+1,index=0;
    while(p1<=mid&&p2<=right)
        tmp[index++]=num[p1]>num[p2]?num[p1++]:num[p2++];
    while(p1<=mid)
        tmp[index++]=num[p1++];
    while(p2<=right)
        tmp[index++]=num[p2++];
    for(int i=0;i<right-left+1;i++)
        num[left+i]=tmp[i];
}

void MergeSortDesc(double num[],int left,int right)
{
    if(left>=right)
        return;
    int mid=(left+right)/2;
    MergeSortDesc(num,left,mid);
    MergeSortDesc(num,mid+1,right);
    mergeDesc(num,left,mid,right);
}

int main()
{
    double num[1000];
    int length;
    for(length=0;cin>>num[length];length++);
    MergeSortDesc(num,0,length-1);
    for(int i=0;i<length;i++)
        cout<<num[i]<<" ";
    return 0;
}

堆排序

#include<iostream>

using namespace std;

void adjustAsc(double num[],int i,int length)
{
    int j,flag=0;
    while(2*i+1<length&&flag==0)
    {
        j=2*i+1;
        if(j+1<length&&num[j]<num[j+1])
            j++;
        if(num[j]>num[i])
        {
            double tmp=num[i];
            num[i]=num[j];
            num[j]=tmp;
            i=j;//更新i为刚才与它交换的儿子结点的编号，便于接下来继续向下调整
        }
        else
            flag=1;
    }
}

void HeapSortAsc(double num[],int length)
{
    //构建大顶堆
    for(int i=length/2-1;i>=0;i--)
        adjustAsc(num,i,length);
    //交换堆顶元素与末尾元素+调整堆结构
    for(int i=length-1;i>0;i--)
    {
        double tmp=num[0];
        num[0]=num[i];
        num[i]=tmp;
        adjustAsc(num,0,i);
    }
}

void adjustDesc(double num[],int i,int length)
{
    int j,flag=0;
    while(2*i+1<length&&flag==0)
    {
        j=2*i+1;
        if(j+1<length&&num[j+1]<num[j])
            j++;
        if(num[j]<num[i])
        {
            double tmp=num[i];
            num[i]=num[j];
            num[j]=tmp;
            i=j;
        }
        else
            flag=1;
    }
}

void HeapSortDesc(double num[],int length)
{
    for(int i=length/2-1;i>=0;i--)
        adjustDesc(num,i,length);
    for(int i=length-1;i>0;i--)
    {
        double tmp=num[0];
        num[0]=num[i];
        num[i]=tmp;
        adjustDesc(num,0,i);
    }
}

int main()
{
    double num[1000];
    int length;
    for(length=0;cin>>num[length];length++);
    HeapSortDesc(num,length);
    for(int i=0;i<length;i++)
        cout<<num[i]<<" ";
    return 0;
}
h0l10w
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
常用排序算法C语言实现
03-10
本资源"常用排序算法C语言实现"提供了一个实践平台，帮助学习者将理论知识转化为实际代码。 首先，让我们探讨几种常见的排序算法及其C语言实现： 1. **冒泡排序（Bubble Sort）**：冒泡排序是最基础的排序方法，...
c++实现十大排序算法
qq_44599368的博客
04-16 898
建立在归并操作上的一种有效的排序算法。自上而下的递归（所有递归的方法都可以用迭代重写，所以就有了第 2 种方法）；自下而上的迭代；注明：此gif图源于归并排序 | 菜鸟教程。计数排序的核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。当输入的元素是 n 个 [0, k] 的整数时，它的运行时间是 Θ(n + k)。优点：计数排序不是比较排序，故其排序速度快于任何比较排序算法。
十大常见排序算法（C++版本代码）
qq_43036667的博客
04-24 1567
冒泡排序（Bubble sort）是一种交换排序，它的基本思想是：两两比较相邻元素的关键字，如果反序则交换，直到没有反序的记录（数据元素）为止。时间复杂度为O(n^2)，空间复杂度为O(1)稳定算法步骤比较相邻的元素。如果第一个比第二个大，就交换它们两个；对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；针对所有的元素重复以上的步骤，除了最后一个；重复步骤1~3，直到排序完成。
常见排序算法（c++)
qq_46132949的博客
07-23 356
插入排序，折半插入排序，希尔排序，冒泡排序，选择排序，快速排序，归并排序的c++实现
常见排序算法（算法思想以及C++代码实现）
久诚的博客
12-23 120
常见排序算法
排序
07-23 145
排序 排序的基本内容 插入排序 直接插入排序 折半插入排序 希尔排序 交换排序 冒泡排序 快速排序 选择排序 简单选择排序 堆排序 2路归并排序 基数排序 外部排序 各种排序算法的比较及应用 内部排序算法的比较及应用 外部排序 ...
C++实现常用排序算法
07-15
本文将深入探讨C++实现的几种常见排序算法：冒泡排序、选择排序、插入排序、归并排序、快速排序以及堆排序。 1. **冒泡排序**： 冒泡排序是一种简单的排序算法，它重复地遍历待排序的数列，一次比较两个元素，如果...
8大常用排序算法实现
05-19
本文将详细解析八大常用排序算法的实现，帮助你更好地理解和测试这些算法。 1. 冒泡排序（Bubble Sort）： 冒泡排序是一种简单的交换排序，通过不断比较相邻元素并交换，使得每次遍历都将最大（或最小）的元素“冒...
js实现常用排序算法
10-21
这里我们将详细介绍五种常用的排序算法：冒泡排序、选择排序、插入排序、希尔排序以及归并排序。 1. 冒泡排序（Bubble Sort） 冒泡排序是一种简单的交换排序，通过重复遍历数组，比较相邻元素并根据需要交换它们来...
常用排序算法 Go实现
01-07
冒泡排序: 分解思想: 1.每次取到最大的数和第i位交换 //取数组最大的数 遍历一遍数组 找到最大的 func GetMax(arr[] int){ for j:=1;j<len(arr);j++{ //找到数组中最小的值 交换到数组的第一位 if arr[j-1] ...
【算法】插入排序 与 希尔排序 概念+图解+代码【Python C C++】
2302_79596028的博客
07-25 314
【算法】插入排序 与 希尔排序 概念+图解+代码【Python C C++】
java算法原理
jylee的博客
07-25 469
正确回答通过率：40.0%[ 详情 ] 推荐指数： ★★★★ 试题难度： 高难 试题类型： 编程题 ▸ 写笔记试题回答参考思路： >>
数据结构与算法-插入排序
菜鸟小码的博客
07-25 574
插入排序是一种简单直观的排序算法，它的工作原理类似于人们整理手中的一叠卡片。该算法通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常使用in-place排序（即只需用到O(1)的额外空间），其时间复杂度为O(n^2)，其中n是待排序数组的长度。
软考-软件设计师(3)-数据结构与算法:树、图、队列、查找算法、排序算法、霍夫曼编码/树、环路复杂性、算法/时间复杂度/空间复杂度等高频考点
BADAO_LIUMANG_QIZHI的博客
07-25 602
软考-软件设计师-数据结构与算法模块高频考点整理。以下为高频考点、知识点汇总，不代表该模块所有知识点覆盖，请以官方教程提纲为准。
DAY15
Drumk的博客
07-25 405
冒泡排序无疑是最为出名的排序算法之一，总共有八大排序冒泡的代码还是相当简单的，两层循环，外层冒泡轮数，里层依次比较，江湖中人人尽皆知我们看到嵌套循环，应该马上就可以得到这个算法的时间复杂度为0(n 2)/*冒泡排序1.比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换他们的位置2.每一次的比较，都会产生出一个最大，或者最小的数字3.下一轮则可以少一次排序4.依次循环，直到结束*///临时变量//外层循环，判断我们这个要走多少次；i++){
C语言中常用的排序
m0_66746512的博客
07-25 66
对相邻两个元素的值进行两两比较，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就如水底下的气泡一样逐渐向上冒。
排序算法详解
最新发布
2202_76097976的博客
07-25 841
详细介绍了插入排序，希尔排序，选择排序，堆排序，冒泡排序，快速排序，归并排序，计数排序
算法-KMP字符串匹配
xx_xb的博客
07-23 178
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
【LeetCode】141.环形链表、142. 环形链表 II（算法 + 图解）
明志の博客
07-25 862
环形链表
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

h0l10w

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值