Sort简单实现，简单详细（附源码）

已于 2023-11-10 20:28:44 修改
阅读量1.2k 收藏 2
点赞数 8
分类专栏： 排序 文章标签： 排序算法 算法 数据结构
于 2023-11-10 20:26:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_71331863/article/details/134340602
版权

sort的简单实现

本篇面向的是初学者，旨在帮助他们了解sort排序的实现。
提供详细的过程的同时附源码，也是为了让自己的进步，共勉之。

引言

看本文的 基础是快速排序及其优化 点击跳转，快速排序及其优化

排序算法是计算机科学中的一个基本问题，有许多不同的实现方法。在本文中，我们将介绍一个基于快速排序和插入排序结合的排序算法的实现一个简单sort。这个算法结合了快速排序的高效性和插入排序的简单性，适用于大部分数据集。

算法实现

首先，我们定义了一个命名空间 zhu，并在其中实现了比较函数 cmp、一个比较类 CMP 以及输入输出函数 input。接下来，我们实现了快速排序 _quick_sort 和插入排序 insertion_sort，最后，我们将两者结合在 Sort 函数中。

include<iostream>
#include<functional>
using namespace std;

#define BEGINS(x) namespace x{
#define ENDS(x)}

BEGINS(zhu)

// 比较函数
bool cmp(int a, int b){
    return a > b;
}	

// 比较类
class CMP{
public:
    bool cmp(int a, int b){
        return a < b;
    }
};

// 输入输出函数
void input(int *first, int *last, const char *g){
    while(first != last){
        cout << *first << " ";
        ++ first;
    }
    cout << endl;
}

// 常量
const int length = 16;
//快排
void _quick_sort(int *first, int *last, function<bool(int, int)> cmp = less<int>()){
    while(last - first > length){
        int *l = first, *r = last - 1;
        int v = *first;
        do{
        while(cmp(v, *l)) ++l;
        while(cmp(*r, v)) --r;
        if(l <= r) swap(*(l++), *(r--));
        }while(l <= r);
         _quick_sort(l, last, cmp);
          last = r + 1;
    }
    return;
}

// 插入排序
void inserion_sort(int *first, int *last, function<bool(int, int)> cmp = less<int>()){
    int *l = first;
    for(int *i = first + 1; i < last; i++){
        if(cmp(*i, *(i - 1))) l = i;
    }
    while(l != first){
        swap(*l, *(l - 1));
        l--;
    }
    for(int *i = first + 2; i < last; i++){
        int *j = i;
        while(cmp(*j, *(j - 1))){
            swap(*j, *(j - 1));
            j--;
        }
    }
    return;
}

// 结合排序
void Sort(int *first, int *last, function<bool(int, int)> cmp = less<int>()){
    _quick_sort(first, last, cmp);
    insertion_sort(first, last, cmp);
}

ENDS(zhu)

主函数

在 main 函数中，我们演示了如何使用我们的排序算法对数组进行排序。用户输入数组的长度和元素，然后调用 Sort 函数进行排序，并最终输出结果。

int main(){
    int a[100], n;
    cin >> n;
    for(int i = 1; i < n; i++){
        cin >> a[i];
    }
    zhu::Sort(a, a + n, zhu::cmp);
    zhu::input(a, a + n, "cmp:");
    return 0;
}

完整代码

让我们通过一个简单的例子来演示我们的排序算法。

#include<iostream>
#include<functional>
using namespace std;

#define BEGINS(x) namespace x{
#define ENDS(x)}

BEGINS(zhu)

bool cmp(int a, int b){
    return a > b;
}

class CMP{
    public:
    bool cmp(int a, int b){
        return a < b;
    }

};

void input(int *first, int *last,const char *g){
    while(first != last){
        cout << *first << " " ;
        ++ first;
    }
    cout << endl;
}

const int length = 16;
void _quick_sort(int *first, int *last, function<bool(int, int)> cmp = less<int>()){
    while(last - first > length){
        int *l = first, *r = last - 1;
        int v = *first;
        do{
        while(cmp(v, *l)) ++l;
        while(cmp(*r, v)) --r;
        if(l <= r) swap(*(l++), *(r--));
        }while(l <= r);
         _quick_sort(l, last, cmp);
          last = r + 1;
    }
    return;
}

void inserion_sort(int *first, int *last, function<bool(int, int)> cmp = less<int>()){
    int *l = first;
    for(int *i = first + 1; i < last; i++){
        if(cmp(*i, *(i - 1))) l = i;
    }
    while(l != first){
        swap(*l, *(l - 1));
        l--;
    }
    for(int *i = first + 2; i < last; i++){
        int *j = i;
        while(cmp(*j, *(j - 1))){
            swap(*j, *(j - 1));
            j--;
        }
    }
    return;
}
void Sort(int *first, int *last, function<bool(int, int)> cmp = less<int>()){
    _quick_sort(first, last, cmp);
    inserion_sort(first, last, cmp);
    return;

}

int main(){
    int a[100], n;
    cin >> n;
    for(int i = 1; i < n; i++){
        cin >> a[i];
    }
    Sort(a, a + n, cmp);
    input(a, a + n, "cmp:");
    return 0;
}

ENDS(zhu)

int main(){
    zhu::main();
    return 0;
}

通过上文，我们深入了解了基于快速排序和插入排序结合的排序算法，并实现了相应的sort代码。这种结合排序的方法在一些情况下可能比单独使用快速排序或插入排序更加高效。读者可以通过阅读代码和运行示例来更好地理解这一排序算法的实现和应用

Sort优化

当我们编写涉及迭代器的算法时，为了增强代码的灵活性和可扩展性，我们通常会定义一些自定义迭代器。在你提供的代码中，RandomIter 类就是一个模拟迭代器的示例

class RandomIter{
    public:
    RandomIter(int *ptr) : ptr(ptr){}
    int operator-(const RandomIter &iter) {return ptr - iter.ptr;}
    int &operator*(){return *ptr;}
    RandomIter &operator++(){ ptr++; return *this;}
    RandomIter &operator--(){ ptr--; return *this;}
    RandomIter operator+(int x){return RandomIter(ptr + x);}
    RandomIter operator-(int x){return RandomIter(ptr - x);}
    RandomIter &operator++(int){ptr++; return *this;}
    RandomIter operator--(int){return RandomIter(ptr + 1);}
    bool operator<(const RandomIter &iter) const {
        return ptr < iter.ptr;
    }
    bool operator<=(const RandomIter &iter) const {
        return !(iter < *this);
    }
    bool operator==(const RandomIter &iter) const{
        return !(iter < *this) && !(*this < iter);
    }
    bool operator!=(const RandomIter &iter) const {
        return !(iter == *this);
    }
    private:
    int *ptr;
};

功能解析

  • BEGINS 和 ENDS 宏用于定义命名空间，本例中命名空间为 zhu。
  • RandomIter 类模拟了迭代器的基本功能，用于表示排序算法中的迭代器。
  • CMP 类定义了一个仿函数，可以用于比较元素。
  • _quick_sort 函数实现了快速排序算法，而 insertion_sort 函数实现了插入排序算法。
  • sort 函数是一个接口函数，允许用户选择使用不同的比较函数。
  • 主函数中演示了如何使用不同的比较函数进行排序。
完整代码：
#include<iostream>
#include<functional>
using namespace std;

#define BEGINS(x) namespace x{
#define ENDS(x)}

BEGINS(zhu)
bool cmp(int a, int b){
    return a > b;
}

class CMP{
    public:
    bool operator()(int a, int b){
        return a < b;
    }
};

void output(int *first, int * last,const char * g){
    cout << g << endl;
    while(first != last){
        cout << *(first++) << " ";
    }
    cout << endl;
}

const int threshold = 16;


class RandomIter{
    public:
    RandomIter(int *ptr) : ptr(ptr){}
    int operator-(const RandomIter &iter) {return ptr - iter.ptr;}
    int &operator*(){return *ptr;}
    RandomIter &operator++(){ ptr++; return *this;}
    RandomIter &operator--(){ ptr--; return *this;}
    RandomIter operator+(int x){return RandomIter(ptr + x);}
    RandomIter operator-(int x){return RandomIter(ptr - x);}
    RandomIter &operator++(int){ptr++; return *this;}
    RandomIter operator--(int){return RandomIter(ptr + 1);}
    bool operator<(const RandomIter &iter) const {
        return ptr < iter.ptr;
    }
    bool operator<=(const RandomIter &iter) const {
        return !(iter < *this);
    }
    bool operator==(const RandomIter &iter) const{
        return !(iter < *this) && !(*this < iter);
    }
    bool operator!=(const RandomIter &iter) const {
        return !(iter == *this);
    }
    private:
    int *ptr;
};
void _quick_sort(RandomIter first, RandomIter last, function<bool(int, int)> cmp = less<int>()){
    while(last - first > 16){
        RandomIter l = first, r = last;
        int v = *first;
        do{
            while(cmp(v, *l)); ++l;
            while(cmp(*r, v)); --r;
            if(l <= r) swap(*(l++), *(r--));
        }while(l <= r);
        _quick_sort(l, last, cmp);
        last = r + 1;
    }
    return;
}

void inserion_sort(RandomIter first, RandomIter last, function<bool(int, int)> cmp =less<int>()){
    RandomIter ind = first;
    for(RandomIter i = first + 1; i < last; ++i){
        if(cmp(*i, *ind)) swap(*i, *ind);
    }

    while(first != ind){
        swap(*ind, *(ind - 1));
        --ind;
    }

    for(RandomIter i = first + 2; i < last; ++i){
        RandomIter j = i;
        while(cmp(*j, *(j - 1))){
            swap(*j, *(j - 1));
            --j;
        }
    }

    return;
}

void sort(RandomIter first,  RandomIter last, function<bool(int, int)> cmp = less<int>()){
    _quick_sort(first, last, cmp);
    inserion_sort(first, last, cmp);
    return;
}
int main(){
    int a[100], x;
    cin >> x;
    for(int i = 0; i < x; i++){
        cin >> a[i];
    }
    sort(a, a + x, cmp);
    output(a, a + x, "cmp:");
    CMP cmp1;
    sort(a, a+ x, cmp1);
    output(a, a + x, "cmp1:");
    return 0;
}
ENDS(zhu)

int main(){
    zhu::main();
    return 0;
}

结论

这个排序算法示例展示了C++中灵活且可扩展的排序实现。通过自定义比较函数，用户可以根据实际需求灵活选择排序策略，使得代码更具通用性。

希望这个简单的示例对你理解C++中的排序算法以及自定义比较函数有所帮助。如果有任何疑问或建议，请留言让我知道！

LI WB
关注
  • 8
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
JAVA:实现SimpleSort简单排序算法(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
08-13 164
JAVA:实现SimpleSort简单排序算法(附完整源码)
C语言最简单的sleep sort睡眠排序实现(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
03-29 1008
C语言最简单的sleep sort睡眠排序实现C语言最简单的sleep sort睡眠排序实现完整源码(定义，实现，main函数测试） C语言最简单的sleep sort睡眠排序实现完整源码(定义，实现，main函数测试） #include<iostream> #include<thread> #include<vector> #include <chrono> using namespace std; void sleepSort(int*, int); vo
C++STL 快速排序算法(sort)的原理(源码解析)
Migga的博客
02-20 978
这个混合排序的策略可以在大多数情况下保持较好的性能，因为快速排序在大部分情况下表现良好，而插入排序适用于小规模的数据。这段代码的作用是执行快速排序的主要循环部分，通过分割数组并递归地对子数组进行排序来完成整个排序过程。这段代码的作用是对指定范围内的元素进行排序，使用的排序算法是。一个普通的插入排序。
Sort源代码
01-06
各种排序算法的源代码，很详细，非常好，基础不是很扎实的人可以看一看，在找工作的人一定不能错过！
STL::sort函数实现
weixin_30642305的博客
04-01 192
声明：本文参考链接：STL::sort实现。 排序是面试中经常被问及的算法基础知识点，虽然实际应用中不会直接使用，但是理解这些简单的算法知识对于更复杂更实用的算法有一定的帮助，毕竟面试总不能问的太过深入，那么这些知识点就显得很重要了。我们在程序中经常利用sort给序列排序，那么你知道它是什么实现的吗？ 函数声明 #include <algorithm> template...
sort函数应用
05-22
主要是一些排序分类算法，学会应用这些算法进行排序很管用。
STL算法之sort源码
qq_38212976的博客
10-04 255
总体上来说sort在快排基础上做了以下几点优化： pivot选取，取区间的首，中间，尾部三点中值，避免快排算法恶化 快排采用分而治之的思想，将待排序容器分为若干个区间，由于采用的时递归实现，当区间个数太多，导致效率下降。这里当区间大于lg(last - first) * 2时，采用堆排序来优化。 最后，当区间元素个数小于16时，此时区间元素已大致有序，采用插入排序，时间复杂度可达到O(n); std::sort的代码如下： template <class RandomAccessIterator&
sort函数（C++实现）
m0_62600503的博客
02-19 1854
快来看，6行代码写sort函数，没有更简单的了。
Objective-C实现pigeon sort鸽巢算法(附完整源码)
最新发布
希望我的博客，能帮上你解决学习中工作中所遇到的问题
07-24 14
Objective-C实现pigeon sort鸽巢算法(附完整源码)
python跑酷游戏源码_Phaser.js实现简单的跑酷游戏附源码下载
weixin_39928787的博客
12-01 1490
采用的物理引擎是Phaser.js在这里对此引擎不做过多介绍(因为我也是小白，嘿嘿)效果展示：源码(详细源码图片资源可点击文章下方或屏幕右上方的github链接进行clone)1.创建游戏舞台var config = {type: Phaser.AUTO,width: 800,height: 400,physics: {default: 'arcade',arcade: {gravity: {y:...
通过c++的sort函数实现成绩排序功能
08-25
主要介绍了通过c++的sort函数实现成绩排序,本文通过实例代码给大家介绍的非常详细，具有一定的参考借鉴价值，需要的朋友可以参考下
PHP实现希尔排序shell sort算法(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
04-21 12
PHP实现希尔排序shell sort算法(附完整源码)
sort实现
qq_37805832的博客
09-23 812
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>Document</title> </head> <body> <script type="text/jav
STL sort 函数实现详解
diaokeng7360的博客
01-07 114
作者：fengcc 原创作品 转载请注明出处 前几天阿里电话一面，被问到STL中sort函数的实现。以前没有仔细探究过，听人说是快速排序，于是回答说用快速排序实现的，但听电话另一端面试官的声音，感觉不对劲，知道自己回答错了。这几天特意看了一下，在此记录。 函数声明 #include <algorithm> template< class Ran...
STL 中sort源码分析
superhackerzhang的专栏
05-10 3093
以SGI的STL为例sort有两种t重载形式emplate inline void sort(_RandomAccessIter __first, _RandomAccessIter __last) {  __STL_REQUIRES(_RandomAccessIter, _Mutable_RandomAccessIterator);  __STL_REQUIRES(typename iterator_traits::value_type,                 _LessThanComparab
sort函数
Prim
02-03 2554
看了好多网上的资料，写的事无巨细，却不适合小白菜鸟们看。 想想还是自己重新写一遍吧，反正寒假在家也没事做。 水平所限（毕竟初学者），写的肯定既不系统也不科学，将就看吧。排序的算法有很多，冒泡排序，插入排序，选择排序，快速排序等等。 冒泡可能是很多人接触的第一种排序算法。先讲讲为什么用sort排序而不用冒泡。 原因很简单，冒泡排序时间复杂度为O(n^2)，而sort作为qsort快速排序的改进
sort 函数实现数值排序
eno的博客
08-06 2783
下面是详细讲解, 比较啰嗦, 嫌弃的请直接看本文最后 什么是sort函数? sort函数是 JS 数组中自带的用于排序的函数 二话不说上代码 var arr = [3,5,6,8,4,1,9,7]; console.log(arr.sort()); 上面的代码声明了一个数组,然后使用sort()函数排序并输出 可以再控制台看到其输出结果如下 看起来好...
sort函数源码分析(超详细)
qq_51986661的博客
08-31 1833
a表示数组，from表示数组开始排序的位置下标，to表示数组结束位置下标。如果 comparefn(a,b) return 的结果小于 0 ，那么 a 会被排列到 b 之前；如果 comparefn(a, b) return 的结果等于 0 ， a 和 b 的相对位置不变。如果 comparefn(a, b) return 的结果大于 0 ， b 会被排列到 a 之前。数组arr1[6,8,2,4,10] 排序后的结果是[10,2,4,6,8]10中的第一位1跟6，8，2，4进行排序。...
集合中sort的源码分析
wyqwilliam的博客
06-24 313
1、不设定比较规则的sort排序 public static <T extends Comparable<? super T>> void sort(List<T> list) { Object[] a = list.toArray(); Arrays.sort(a); ListIterator<T&...
java实现堆排序(附完整源码)
06-09
好的，下面是Java实现堆排序的完整源码： ```java public class HeapSort { public static void sort(int[] arr) { int n = arr.length; for (int i = n / 2 - 1; i >= 0; i--) { heapify(arr, n, i); } for ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值