排序 C++

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

排序

稳定排序：直接插入排序，折半插入排序，冒泡排序，归并排序，基数排序

不稳定排序：希尔排序，快速排序，堆排序，简单选择排序

插入排序

每一趟排序，将一个待插入的关键字插入到按照大小插入到已经排好序的记录中

直接插入排序

清晰解释：https://blog.csdn.net/weixin_42109012/article/details/91478883
代码：

#include<iostream>
using namespace std;

#define Max 20//排序元素个数的最大值

typedef struct
{
    int array[Max];
    int len;
}sort;

void CreateData(sort &s)
{
    int i;
    cout<<"输入元素个数：";
    cin>>s.len;
    cout<<"输入元素：";
    for(i=1;i<=s.len;i++)
        cin>>s.array[i];
}

void Print(sort s)
{
    int i;
    for(i=1;i<=s.len;i++)
        cout<<s.array[i]<<" ";
    cout<<endl;
}

void SIS(sort &s)//直接插入排序straight insertion sort
{
    int i,j;
    for(i=2;i<=s.len;++i)
        if(s.array[i]<s.array[i-1])
        {
            s.array[0]=s.array[i];
            s.array[i]=s.array[i-1];
            for(j=i-2;s.array[0]<s.array[j];--j)
                s.array[j+1]=s.array[j];
            s.array[j+1]=s.array[0];
        }
}

int main(void)
{
    sort s;
    CreateData(s);
    cout<<"直接插入排序，为：";
    SIS(s);
    Print(s);
}

结果
在这里插入图片描述
时间复杂度：O(n^2)
空间复杂度：O(1)

折半插入排序

清晰解释：
https://blog.csdn.net/weixin_42245157/article/details/80458542
代码：

#include<iostream>
using namespace std;

#define Max 20//排序元素个数的最大值

typedef struct
{
    int array[Max];
    int len;
}sort;

void CreateData(sort &s)
{
    int i;
    cout<<"输入元素个数：";
    cin>>s.len;
    cout<<"输入元素：";
    for(i=1;i<=s.len;i++)
    cin>>s.array[i];
}

void Print(sort s)
{
    int i;
    for(i=1;i<=s.len;i++)
        cout<<s.array[i]<<" ";
    cout<<endl;
}

void BIS(sort &s)//折半插入排序Binary Insertion sort
{
    int i,j,low,high,m;
    for(i=2;i<=s.len;++i)
    {
        s.array[0]=s.array[i];
        low=1;
        high=i-1;
        while(low<=high)
        {
            m=(low+high)/2;
            if(s.array[0]<s.array[m])
                high=m-1;
            else low=m+1;
        }
        for(j=i-1;j>=high+1;--j)
            s.array[j+1]=s.array[j];
        s.array[high+1]=s.array[0];
    }
}

int main(void)
{
    sort s;
    CreateData(s);
    cout<<"折半插入排序，为：";
    BIS(s);
    Print(s);
}

结果：
在这里插入图片描述
时间复杂度： O(n^2)
空间复杂度： O(1)

希尔排序

解释： 就是把相隔dk的数挑出来再直接插入排序
在这里插入图片描述

代码：

#include<iostream>
using namespace std;

#define MaxInt 10//增量个数的最大值
#define Max 20//排序元素个数的最大值

typedef struct
{
    int array[Max];
    int len;
}sort;

void CreateData(sort &s)
{
    int i;
    cout<<"输入元素个数：";
    cin>>s.len;
    cout<<"输入元素：";
    for(i=1;i<=s.len;i++)
    cin>>s.array[i];
}

void Print(sort s)
{
    int i;
    for(i=1;i<=s.len;i++)
        cout<<s.array[i]<<" ";
    cout<<endl;
}

void SI(sort &s,int dk)//希尔插入Shell's insertion
{
    int i,j;
    for(i=dk+1;i<=s.len;++i)
        if(s.array[i]<s.array[i-dk])
        {
            s.array[0]=s.array[i];
            for(j=i-dk;j>0&&s.array[0]<s.array[j];j-=dk)
                s.array[j+dk]=s.array[j];
            s.array[j+dk]=s.array[0];
        }
}

void SS(sort &s)//t是趟数
{
    int i=0,dk[MaxInt],a;
    cout<<"输入增量个数：";
    cin>>a;
    cout<<"输入增量: ";
    for(i=0;i<a;i++)
        cin>>dk[i];
    for(i=0;i<a;i++)
        SI(s,dk[i]);
}

int main(void)
{
    int a,b[MaxInt],i;
    sort s;
    CreateData(s);
    SS(s);
    cout<<"希尔排序，为：";
    Print(s);
}

结果：
在这里插入图片描述
时间复杂度： O(n^3/2)
空间复杂度： O(1)

交换排序

两两比较待排序的关键字，如果不满足次序要求，则调换，直到整个次序符合要求为止

冒泡排序

解释： 如果发生了交换，flag=1,则说明此时的数据还未必有序，需要进行下一趟循环，当然，如果flag=0，则说明此时的数据已经有序，不用进行下一趟循环了。
代码：

#include<iostream>
using namespace std;

#define Max 20//排序元素个数的最大值

typedef struct
{
    int array[Max];
    int len;
}sort;

void CreateData(sort &s)
{
    int i;
    cout<<"输入元素个数：";
    cin>>s.len;
    cout<<"输入元素：";
    for(i=1;i<=s.len;i++)
    cin>>s.array[i];
}

void BS(sort &s)//Bubble Sort冒泡排序
{
    int m=s.len-1,i,t;
    int flag=1;
    while(m>0&&flag==1)
    {
        flag=0;
        for(i=1;i<=m;i++)//执行len-1次循环
            if(s.array[i]>s.array[i+1])
            {
                t=s.array[i+1];
                s.array[i+1]=s.array[i];
                s.array[i]=t;
                flag=1;
            }
        m--;
    }
}

void Print(sort s)
{
    int i;
    for(i=1;i<=s.len;i++)
        cout<<s.array[i]<<" ";
    cout<<endl;
}

int main(void)
{
    sort s;
    CreateData(s);
    BS(s);
    Print(s);
}

在这里插入图片描述
时间复杂度： O(n^2)
空间复杂度： O(1)

快速排序

清晰解释： https://blog.csdn.net/elma_tww/article/details/86164674
代码：

#include<iostream>
using namespace std;

#define Max 20//排序元素个数的最大值

typedef struct
{
    int array[Max];
    int len;
}sort;

void CreateData(sort &s)
{
    int i;
    cout<<"输入元素个数：";
    cin>>s.len;
    cout<<"输入元素：";
    for(i=1;i<=s.len;i++)
    cin>>s.array[i];
}

void Print(sort s)
{
    int i;
    for(i=1;i<=s.len;i++)
        cout<<s.array[i]<<" ";
    cout<<endl;
}

int Partition(sort &s,int low,int high)//partition 隔板
{
    s.array[0]=s.array[low];
    while(low<high)//当low=high时停止
    {
        while(low<high&&s.array[high]>=s.array[0])
            high--;
        s.array[low]=s.array[high];//无所谓原本的s.array[low],因为它在s.array[0]处有备份
        while(low<high&&s.array[low]<=s.array[0])
            low++;
        s.array[high]=s.array[low];//无所谓原本的s.array,因为它在s.array[low（之前的）]有备份
    }
    s.array[low]=s.array[0];//s.array[high]=s.array[0]也可以，因为此时low=high
    return low;//把枢轴位置输出，此位置的左边都是比它小的数，此位置的右边都是比它大的数
}

void QS(sort &s,int low,int high)//quick sort 快速排序
{
    int pivotloc;//pivotloc枢轴锁定
    if(low<high)
    {
        pivotloc=Partition(s,low,high);
        QS(s,low,pivotloc-1);//枢轴左边排序
        QS(s,pivotloc+1,high);//枢轴右边排序
    }
}

int main(void)
{
    sort s;
    CreateData(s);
    int low=1,high=s.len;
    QS(s,low,high);
    Print(s);
}

结果：
在这里插入图片描述
时间复杂度：
平均情况：O(nlog2(n))
空间复杂度：
最好情况：O(log2(n))
最坏情况：O(n)

选择排序

每一趟从待排序的记录中取出最小的关键字，然后按顺序放在已排序的记录的最后

简单选择排序

太过于简单，此处不予说明
时间复杂度： O(n^2)
空间复杂度： O(1)

堆排序（以大根堆为例）

堆的形状是一课完全二叉树

清晰解释：（主要看动图）
https://www.runoob.com/w3cnote/heap-sort.html
代码：

#include<iostream>
using namespace std;

#define Max 20//排序元素个数的最大值

typedef struct
{
    int array[Max];
    int len;
}sort;

void CreateData(sort &s)
{
    int i;
    cout<<"输入元素个数：";
    cin>>s.len;
    cout<<"输入元素：";
    for(i=1;i<=s.len;i++)
        cin>>s.array[i];
}

void Print(sort s)
{
    int i;
    for(i=1;i<=s.len;i++)
        cout<<s.array[i]<<" ";
    cout<<endl;
}

void HeapAdjust(sort &s,int a,int b)//heap 堆 此时调整的是[a+1--b]的堆
{
    int i,rc;
    rc=s.array[a];
    for(i=2*a;i<=b;i*=2)
    {
        if(i<b&&s.array[i]<s.array[i+1])
            ++i;
        if(rc>=s.array[i])
            break;
        //否则
        s.array[a]=s.array[i];
        a=i;
    }
    s.array[a]=rc;
}

void CreateHeap(sort &s)
{
    int i;
    for(i=s.len/2;i>0;--i)
        HeapAdjust(s,i,s.len);
}

void HS(sort &s)//heap sort堆排序
{
    int t,i;
    CreateHeap(s);
    for(i=s.len;i>1;--i)//注意是i>1为循环条件
    {
        t=s.array[1];//第一个结点和最后一个结点的数值互换
        s.array[1]=s.array[i];
        s.array[i]=t;
        HeapAdjust(s,1,i-1);
    }
}

int main(void)
{
    sort s;
    CreateData(s);
    HS(s);
    Print(s);
}

结果：
在这里插入图片描述
时间复杂度：
平均情况+最坏情况：O(nlog2(n))
空间复杂度：
O(1)

平衡二叉搜索树(Self-balancing binary search tree)又被称为AVL树(有别于AVL算法)，且具有以下性质:它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。

二叉排序树（Binary Sort Tree）或者是一棵空树；或者是具有下列性质的二叉树： （1）若左子树不空，则左子树上所有结点的值均小于它的根结点的值； （2）若右子树不空，则右子树上所有结点的值均大于它的根结点的值； （3）左、右子树也分别为二叉排序树；

归并排序

2-路归并排序

把两个有序表合并成成一个有序表

清晰解释：
https://www.cnblogs.com/chengxiao/p/6194356.html
时间复杂度： O(nlog2(n))
空间复杂度： O(n)

基数排序

多关键字时用

清晰解释：
https://blog.csdn.net/double_happiness/article/details/72452243

外部排序

待排序的记录数目较大，无法一次性存入内存，用外存分批调入内存

清晰解释：
https://www.sohu.com/a/258751244_818692

咸鱼肥美妖娆
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
冒泡排序C++代码
weixin_35753431的博客
01-05 1941
冒泡排序是一种比较简单的排序算法，它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。 以下是 C 语言实现的冒泡排序代码： void bubbleSort(int array[], int length) { int i, j; for (i = 0; i < length - ...
冒泡排序c＋＋
01-06
冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果他们的顺序（如从大到小、首字母从A到Z）错误就把他们交换过来。
C++ sort()排序详解
热门推荐
晴空๓
05-05 40万+
本文对C++中的sort()做了一个比较详细的说明，包括为什么选择使用sort()、sort()函数的实现原理、sort()的使用方法等等。
归并排序 C++
小天狼星_布莱克 的博客
07-17 3386
​ 归并排序(Merge Sort)是建立在归并操作上的一种有效，稳定的排序算法，该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列。即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。 ​...
快速排序c++代码
qq_68035932的博客
10-30 4007
c++实现快速排序
堆排序c++代码
guan_yue的博客
11-16 1869
堆排序 从第一个非叶子节点开始建立大顶堆，然后与堆顶进行交换，重新进行再调整 class Solution { public: //第二个参数表示剩余未排序数字的数量即堆的大小 void makeHeap(vector<int> &arr,int heapSize ,int index) { int left = 2 * index + 1;//左节点 int right = 2 * index + 2;//右节点
拓扑排序C++
weixin_44966641的博客
04-08 3289
拓扑排序C++ 邻接表 邻接表，存储方法跟树的孩子链表示法相类似，是一种顺序分配和链式分配相结合的存储结构。如这个表头结点所对应的顶点存在相邻顶点，则把相邻顶点依次存放于表头结点所指向的单向链表中。 在有向图中，描述每个点向别的节点连的边（点a->点b这种情况）。 在无向图中，描述每个点所有的边(点a-点b这种情况) LeetCode习题 207. 课程表 解题思路 本题可约化为： 课程安排图是否是有向无环图(DAG)。即课程间规定了前置条件，但不能构成任何环路，否则课程前置条件将不成立。
英文名排序c++
Zx120110的博客
11-11 1172
无
冒泡排序c++
yyf525的博客
10-23 1258
冒泡排序 void fun(int a[],int n)//对数组a进行了操作 n表示数组内一共有多少个元素 { for(int i=n-1;i>=0;i--)//顶 { for(int j=0;j<i;j++)//从底到顶的一个遍历 { if(a[j] <a[j+1]) //从大到小的排序 swap(a[j],a[j+1]); } } } 快排（sort...
年龄排序c++
Creeper05的博客
10-24 3520
这里是利用结构体完成年龄排序的c++代码 #include<bits/stdc++.h> using namespace std; struct stu{ string name; string fuck; int year,month; }; const int MAXN=110; stu a[MAXN]; int main(){ int n; cin>>n; for(int i=1;i<=n;i++) cin>>a[i].name>>
基数排序C++实现
lzq8090的博客
04-13 2165
10.基数排序基数排序的基本思想基数排序的算法步骤C++代码实现 基数排序的基本思想 基数排序是一种非比较型整数排序算法，其原理是将整数按位数切割成不同的数字，然后按每个位数分别比较。由于整数也可以表达字符串（比如名字或日期）和特定格式的浮点数，所以基数排序也不是只能使用于整数。 基数排序的发展：（计数→桶→基数排序） 计数排序：每个桶只存储单一键值； 桶排序：每个桶存储一定范围的数值； 基数排序：根据键值的每位数字来分配桶。 静态图解： 按照个位数进行排序； 按照十位数进行排序； 按照百位数进行排序
八大排序C++完整代码（冒泡、希尔、插入、选择、快排、归并、桶、堆）
12-30
本资源提供了八大经典排序算法的C++实现，包括冒泡排序、希尔排序、插入排序、选择排序、快速排序、归并排序、桶排序以及堆排序。接下来，我们将深入探讨这些排序算法的原理、效率以及它们在C++中的实现。 1. **...
C++堆排序C++堆排序.zip
01-18
**C++堆排序详解** 堆排序是一种基于比较的排序算法，它的主要思想是利用数据结构中的堆特性来实现数组或序列的排序。在C++中，我们可以通过标准库中的`<algorithm>`头文件来实现堆排序，但更深入的理解和自定义...
-生日排序C++语言代码
10-29
--生日排序C++代码----生日排序C++代码----生日排序C++代码----生日排序C++代码----生日排序C++代码----生日排序C++代码----生日排序C++代码----生日排序C++代码----生日排序C++代码----生日排序C++代码----生日排序...
数据排序 C++ 算法 详细
01-12
学习算法人群
顺序栈的逆序和顺序输出
m0_51754096的博客
04-15 4541
#include<stdio.h> #include<stdlib.h> typedef int Status; #define OVERFLOW -1 #define ERROR 0 #define OK 1 #define MAXSIZE 100 typedef struct { int *base; int *top; int stacksize; }SqStack; /**栈的创建**/ Status InitStack(SqStack *s)
两个单链表的合并 C++
m0_51754096的博客
06-13 1499
#include<iostream> #include<cstdlib> using namespace std; #define OK 1; #define ERROR 0; typedef int Status; typedef int DataType; typedef struct LNode//Linked list=链表 { DataType data; struct LNode *next; }LNode,*LinkList; Status Init
折半查找--顺序表
m0_51754096的博客
06-14 970
折半查找又称二分查找。 优点：比较次数少，查找速度快，平均性能好； 缺点：要求待查表为有序表，且插入删除困难。 因此：折半查找方法适用于不经常变动而查找频繁的有序列表。 /**在有序顺序表中进行**/ #include<iostream> using namespace std; #define Max 20 typedef int DataType; typedef struct { DataType *data; int length; }SqList; void I
C语言 单链表 学生信息的取值，定位，删除，插入
m0_51754096的博客
04-06 647
#include<stdio.h> #include<stdlib.h> #include<string.H> #define ERROR 0 #define OK 1 typedef struct { char no[8]; char name[20]; float score; }stu; typedef struct LNode { stu data; struct LNode *next; }LNode,*LinkLi
opencv vector 排序 c++
最新发布
05-19
```c++ #include #include using namespace std; using namespace cv; int main() { // 创建一个int类型的vector vector<int> v = { 5, 3, 2, 8, 1 }; // 对vector进行升序排序 sort(v.begin(), v.end()); ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值