9.手写sort（模仿源码）

于 2023-11-05 11:43:02 发布
阅读量759 收藏
点赞数 8
分类专栏： c++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_62318955/article/details/134228281
版权

手写sort（模仿源码）

版本一：快速排序

/*************************************************************************
        > File Name: test1.cpp
        > Author:Xiao Yuheng
        > Mail:3312638794@qq.com
        > Created Time: Sat Nov  4 10:48:10 2023
 ************************************************************************/

#include <iostream>
#include <functional>

using namespace std;

bool cmp1(int a, int b) {
    return a < b;
}

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

void __quick_sort(int *first, int *last, function<bool(int, int)> cmp = less<int>()) {
    if (first >= last) return ;
    int *l = first, *r = last - 1, value = *first;
    while (l < r) {
        while (l < r && cmp(value, *r)) r--;
        if (l < r) *(l++) = *r;
        while (l < r && cmp(*l, value)) l++;
        if (l < r) *(r--) = *l;
    }
    *l = value;
    __quick_sort(first, l, cmp);
    __quick_sort(l + 1, last, cmp);
    return ;
}

void sort(int *first, int *last, function<bool(int, int)> cmp = less<int>()) {
    __quick_sort(first, last, cmp);
    return ;
}

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

int main() {
    int n, a[10020];
    cin >> n;
    for (int i = 0; i < n; i++) cin >> a[i];
    sort(a, a + n, cmp1);
    output(a, a + n, "cmp1");
    sort(a, a + n, cmp2);
    output(a, a + n, "cmp2");
    return 0;
}

__quick_sort函数：

cppCopy codevoid __quick_sort(int *first, int *last, function<bool(int, int)> cmp = less<int>()) {
    if (first >= last) return ;
    int *l = first, *r = last - 1, value = *first;
    while (l < r) {
        while (l < r && cmp(value, *r)) r--;
        if (l < r) *(l++) = *r;
        while (l < r && cmp(*l, value)) l++;
        if (l < r) *(r--) = *l;
    }
    *l = value;
    __quick_sort(first, l, cmp);
    __quick_sort(l + 1, last, cmp);
    return ;
}
  • 这是一个递归的快速排序算法。它接受三个参数：
    • int *first：指向待排序范围的起始位置的指针。
    • int *last：指向待排序范围的结束位置的下一个位置的指针。
    • function<bool(int, int)> cmp = less<int>()：一个比较函数，默认为less<int>()，表示默认按照升序排列。
  • 首先，它检查了first和last的关系，如果first >= last，说明排序范围为空或者只有一个元素，无需进行排序，直接返回。
  • 然后，它选择了first指向的元素作为基准值value。
  • 接着，它使用两个指针l和r分别指向排序范围的开始和结束位置。
  • 然后，它开始进行分区操作，将比基准值大的元素放在右侧，比基准值小的元素放在左侧。
  • 最后，它递归调用自身，对分区后的子数组进行排序。

我们这里调用sort函数来进行排序，现在sort内部只有一个快速排序，我们我们接着来进行优化。

版本二：优化快排

/*************************************************************************
        > File Name: test1.cpp
        > Author:Xiao Yuheng
        > Mail:3312638794@qq.com
        > Created Time: Sat Nov  4 10:48:10 2023
 ************************************************************************/

#include <iostream>
#include <functional>

using namespace std;

bool cmp1(int a, int b) {
    return a < b;
}

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

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

void sort(int *first, int *last, function<bool(int, int)> cmp = less<int>()) {
    __quick_sort(first, last, cmp);
    return ;
}

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

int main() {
    int n, a[10020];
    cin >> n;
    for (int i = 0; i < n; i++) cin >> a[i];
    sort(a, a + n, cmp1);
        output(a, a + n, "cmp1");
    sort(a, a + n, cmp2);
    output(a, a + n, "cmp2");
    return 0;
}

优化方法为单边递归和无监督优化，详细解释：【精选】十大排序算法(C++)_c++排序算法-CSDN博客

版本三：插入排序优化

/*************************************************************************
        > File Name: test1.cpp
        > Author:Xiao Yuheng
        > Mail:3312638794@qq.com
        > Created Time: Sat Nov  4 10:48:10 2023
 ************************************************************************/

#include <iostream>
#include <functional>

using namespace std;

bool cmp1(int a, int b) {
    return a < b;
}

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

const int threshold = 16;

void __quick_sort(int *first, int *last, function<bool(int, int)> cmp = less<int>()) {
    while (last - first > threshold) {
        int *l = first, *r = last - 1, value = *first;
        do{
            while (cmp(*l, value)) l++;
            while (cmp(value, *r)) r--;
            if (l <= r) swap(*(l++), *(r--));
        } while (l <= r);
        __quick_sort(l, last, cmp);
        last = r + 1;
    }
    return ;
}

void insertion_sort(int *first, int *last, function<bool(int, int)> cmp = less<int>()) {
    int *ind = first;
    for (int *i = first + 1; i < last; i++) {
        if (cmp(*i, *ind)) ind = i;
    }
    while (ind != first) {
        swap(*ind, *(ind - 1));
        ind--;
    }
    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);
    return ;
}

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

int main() {
    int n, a[10020];
    cin >> n;
    for (int i = 0; i < n; i++) cin >> a[i];
    sort(a, a + n, cmp1);
    output(a, a + n, "cmp1");
    sort(a, a + n, cmp2);
    output(a, a + n, "cmp2");
    return 0;
}

  1. 插入排序的引入：

    为了提高性能，当待排序范围的大小小于 threshold 时，切换到插入排序算法。插入排序在小规模数据上比快速排序更高效，因为它的时间复杂度是 O(n^2)，但是常数因子比快速排序小。

    cppCopy codevoid insertion_sort(int *first, int *last, function<bool(int, int)> cmp = less<int>()) {
    int *ind = first;
    for (int *i = first + 1; i < last; i++) {
        if (cmp(*i, *ind)) ind = i;
    }
    while (ind != first) {
        swap(*ind, *(ind - 1));
        ind--;
    }
    for (int *i = first + 2; i < last; i++) {
        int *j = i;
        while (cmp(*j, *(j - 1))) {
            swap(*j, *(j - 1));
            j--;
        }
    }
    return ;
}

    插入排序中也引用了无监督优化

版本四：手动实现RandomIter迭代器

/*************************************************************************
        > File Name: test1.cpp
        > Author:Xiao Yuheng
        > Mail:3312638794@qq.com
        > Created Time: Sat Nov  4 10:48:10 2023
 ************************************************************************/

#include <iostream>
#include <functional>

using namespace std;

bool cmp1(int a, int b) {
    return a < b;
}

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

const int threshold = 16;

class RandomIter {
public:
    RandomIter(int *ptr) : ptr(ptr) {}
    int operator-(RandomIter &ran) { return ptr - ran.ptr; }
    RandomIter operator-(int x) { return ptr - x; }
    RandomIter operator+(int x) { return ptr + x; }
    int &operator*() { return *ptr; }
    RandomIter operator++(int) { return ptr++; }
    RandomIter operator--(int) { return ptr--; }
    // 运用小于号来重载 > <= >=
    bool operator<(RandomIter &iter) { return ptr < iter.ptr; }
    bool operator>(RandomIter &iter) { return iter < *this; }
    bool operator<=(RandomIter &iter) { return !(iter < *this); }
    bool operator>=(RandomIter &iter) { return !(*this < iter); }
    bool operator!=(RandomIter &iter) { return (*this < iter) || (iter < *this); }
    bool operator==(RandomIter &iter) { return !(*this < iter) && !(iter < *this); }
private:
    int *ptr;
};

void __quick_sort(RandomIter first, RandomIter last, function<bool(int, int)> cmp = less<int>()) {
    while (last - first > threshold) {
        RandomIter l = first, r = last - 1;
        int value = *first;
        do{
            while (cmp(*l, value)) l++;
            while (cmp(value, *r)) r--;
            if (l <= r) swap(*(l++), *(r--));
        } while (l <= r);
        __quick_sort(l, last, cmp);
        last = r + 1;
    }
    return ;
}

void insertion_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)) ind = i;
    }
    while (ind != first) {
        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);
    insertion_sort(first, last, cmp);
    return ;
}

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

int main() {
    int n, a[10020];
    cin >> n;
    for (int i = 0; i < n; i++) cin >> a[i];
    sort(a, a + n, cmp1);
        output(a, a + n, "cmp1");
    sort(a, a + n, cmp2);
    output(a, a + n, "cmp2");
    return 0;
}
  1. 优点：
    • 提高了代码的可读性和可维护性，减少了指针操作的复杂性，使代码更易理解。
    • 使代码更加通用，可以应用于不同数据类型的容器，而不仅限于整型数组。
    • 通过 RandomIter 类的运算符重载，提供了一种更面向对象的方式来处理数组元素，使代码更具面向对象编程（OOP）的特性。
    • 通过使用迭代器类，代码现在更加具有扩展性，能够适用于不同的数据结构和容器。

版本五：快排优化

/*************************************************************************
        > File Name: test1.cpp
        > Author:Xiao Yuheng
        > Mail:3312638794@qq.com
        > Created Time: Sat Nov  4 10:48:10 2023
 ************************************************************************/

#include <iostream>
#include <functional>

using namespace std;

bool cmp1(int a, int b) {
    return a < b;
}

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

const int threshold = 16;

class RandomIter {
public:
    RandomIter(int *ptr) : ptr(ptr) {}
    int operator-(RandomIter &ran) { return ptr - ran.ptr; }
    RandomIter operator-(int x) { return ptr - x; }
    RandomIter operator+(int x) { return ptr + x; }
    int &operator*() { return *ptr; }
    RandomIter operator++(int) { return ptr++; }
    RandomIter operator--(int) { return ptr--; }
    // 运用小于号来重载 > <= >=
    bool operator<(RandomIter &iter) { return ptr < iter.ptr; }
    bool operator>(RandomIter &iter) { return iter < *this; }
    bool operator<=(RandomIter &iter) { return !(iter < *this); }
    bool operator>=(RandomIter &iter) { return !(*this < iter); }
    bool operator!=(RandomIter &iter) { return (*this < iter) || (iter < *this); }
    bool operator==(RandomIter &iter) { return !(*this < iter) && !(iter < *this); }
private:
    int *ptr;
};

int Get_mid(RandomIter first, RandomIter last) {
    int a = *first;
    int b = *(last - 1);
    int c = *(first + ((last - first) >> 1));
    if (a > b) swap(a, b);
    if (a > c) swap(a, c);
    if (b > c) swap(b, c);
    return b;
}

void __quick_sort(RandomIter first, RandomIter last, function<bool(int, int)> cmp = less<int>()) {
    while (last - first > threshold) {
        RandomIter l = first, r = last - 1;
        // int value = *first;
        int value = Get_mid(first, last);
        do{
            while (cmp(*l, value)) l++;
            while (cmp(value, *r)) r--;
            if (l <= r) swap(*(l++), *(r--));
        } while (l <= r);
        __quick_sort(l, last, cmp);
        last = r + 1;
    }
    return ;
}

void insertion_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)) ind = i;
    }
    while (ind != first) {
        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);
    insertion_sort(first, last, cmp);
    return ;
}

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

int a[10000020];

int main() {
    int n;
    cin >> n;
    for (int i = 0; i < n; i++) cin >> a[i];
    sort(a, a + n, cmp1);
    output(a, a + n, "cmp1");
    sort(a, a + n, cmp2);
    output(a, a + n, "cmp2");
    return 0;
}

引入了 Get_mid 函数：

cppCopy codeint Get_mid(RandomIter first, RandomIter last) {
    int a = *first;
    int b = *(last - 1);
    int c = *(first + ((last - first) >> 1));
    if (a > b) swap(a, b);
    if (a > c) swap(a, c);
    if (b > c) swap(b, c);
    return b;
}
  • 这个函数用于选择中值元素。它接受两个 RandomIter 对象，分别指向待排序范围的起始位置和结束位置。
  • 该函数计算了首、尾和中间三个位置的元素，并确保 a <= b <= c，返回 b 作为中值元素。
  • 确保每次的value都是有意义的。
拾雪藏于春
关注
  • 8
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
手写三种sort算法
again1943的专栏
08-14 1066
最近要找工作，于是手写了stl风格的三种sort算法，quick sort，merge sort和heap sort，其中quick sort分别实现了递归和非递归两种，代码如下 ，经过了基本的正确性测试（不保证对所有类型都正确，因为没充分测试过），然后性能测试与C++的std::sort和std::stable_sort做了一些对比 代码如下： #include #include #include #include namespace fatrat { using
手写快速排序——sort
qq_35793616的博客
08-08 6525
虽然功能强大的STL里的sort函数就是快速排序的实现，而且，系统的快排速度和手写的快排速度差不多。但是，我觉得还是有必要学会手写快排，至少手写的快排比系统快排更灵活，起码不需要重定义大于运算符来实现数据的从大到小排序。手写快排的实现：一、总体思想： 快速排序，简称快排，总体上来说是运用分治思想实现有序排列数据的一种排序方法。一言以蔽之：选择一个点，大的往一侧去，小的往另一侧去。再以这个点为起点和
js 手写sort
m0_59070120的博客
07-15 549
/正序(a,b)=>a-b)//逆序(a,b)=>b-a)
Compareble接口
qq_46039862的博客
12-08 249
测试类： public class studentTest { public static void main(String[] args) { Student s1=new Student(); s1.setUserName("张三"); s1.setAge(100); Student s2=new Student(); s2.setUserName("李四"); ...
手写快速排序 简单暴力 c++实现 源码
weixin_66033926的博客
03-21 897
虽然可以自己用sort()函数实现，但是自己写一遍也有利于理解快排 #include<iostream> using namespace std; void quicksort(int a[], int start, int end)//手写快排 { int i = start, j = end, temp, flag = a[i]; do { while (a[i] < flag)i++; while (a[j] > flag)j--; if (i <=
手写画图.zipIOS应用例子源码下载
03-06
手写画图.zip是一个针对iOS平台的应用程序源码示例，提供了丰富的学习资源，适合不同层次的学习者，包括学生、个人开发者以及公司技术团队进行研究和参考。这个源码库不仅能够帮助初学者理解iOS应用的基本构建，还能...
Python手写识别源码.txt
12-19
Python手写识别源码.txt
易语言源码易语言手写识别源码.rar
02-19
易语言源码易语言手写识别源码.rar 易语言源码易语言手写识别源码.rar 易语言源码易语言手写识别源码.rar 易语言源码易语言手写识别源码.rar 易语言源码易语言手写识别源码.rar 易语言源码易语言手写识别源码....
WPF Mircosoft.Ink墨迹手写输入(源码)
08-20
标题“WPF Microsoft.Ink墨迹手写输入(源码)”涉及的是Windows Presentation Foundation（WPF）框架下的一个特殊功能，即利用Microsoft.Ink库实现的手写输入技术。这项技术允许用户通过触控设备（如触摸屏或数字笔）...
Vue-Object.defineProperty:Vue源码解析之手写Vue源码-源码解析
03-24
本篇文章通过学习文档及视频教程实现手写一个简易的Vue原始码实现数据双向绑定，解析指令等。 几种实现双向绑定的做法 目前几种主流的mvc（vm）框架都实现了单向数据绑定，而我所理解的双向数据绑定无非就是在单向...
手写各种排序
jun7118的博客
04-29 420
#include &lt;stdio.h&gt; int partition(char *A, int p, int q) { int i = p; int j = p - 1; char tmp; while(i != q){ if(A[i] &lt; A[q]){ j++; tmp = A[i]; A[i] = A[j]; A[j] = tmp; ...
【前端手撕题】手写js快速排序，原理+实现代码
qq_38615466的博客
12-26 679
前端手撕算法题，快速排序（Quicksort），又叫分区交换排序（partition-exchange sort），简称快排，一种排序算法，最早由提出。在平均状况下，排序n个项目要O(nlogn)次比较，最坏情况下是O(n^2)次比较，但这种情况不多见。事实上，快排的效率通常比其他排序算法要快，因为它的内部循环(inner loop)可以在大部分的架构上有很高的效率。
C++手写qsort：快速排序的代码实现【两种写法】
马小超
10-19 1156
思想： 快速排序是基于分治的思想实现的排序算法，对于一个无序数列，我们从中选取一个基数，然后把小于基数的所有数字放到基数前面，大于基数的数字放在基数后面，然后对基数左右的子序列进行同样的操作。 代码： #include<iostream> using namespace std; void sort(int a[],int l, int r){ int i=l; int j=r; srand(time(0)); int k=rand()%(j-i+1)+i; //取[l,r]的
手写数组快速排序（多种写法）
weixin_45242865的博客
09-10 4962
1. 简介  快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序 n 个项目要 Ο(nlogn) 次比较。在最坏状况下则需要 Ο(n2) 次比较，但这种状况并不常见。事实上，快速排序通常明显比其他 Ο(nlogn) 算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来。 2. 算法步骤 ① 从数列中挑出一个元素，称为 “基准”（pivot）; ② 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在
简单手写js的Array.sort()
冯标的博客
11-05 823
var arr = [7, 2, 6, 5, 9, 4, 3, 1, "c", "a", "b"] function sort(a, orderBy = "asc") { let arrs = [] let stringCode = [] //将字符串和数字筛选出来并转成ASCII码 for (let i of a) { if (typeof i !== "number" && typeof i === "string") {
python 手写选择排序（不用sort）
Li5566123的博客
04-28 3170
函数mysort（alist）用于计算包含数字的列表的排序（包括升序和降序。不能使用python中的函数sort或sorted）。 import random def section_sort1(alist): n = len(alist) # 定义外围循环次数 for j in range(n - 1): # 定义min_index最小值的索引为j,目的找出最小值 min_index = j # cur下标移动的范围，比较次数的范
sort排序+结构体总结
成龙大侠的博客
07-20 2391
点击此处跳转到目标网址 密码    hpuacm A题中 23:59:59 这样的时间输出可以当做字符串处理 struct people{ char name[20]; char com[20]; char lea[20]; }; struct people peo[10000]; bool cmp1( struct people p1, struct people p2 ) { ...
讲下 V8 sort 的大概思路，并手写一个 sort 的实现
我本可以容忍阳光，如果我不曾见过太阳，然而阳光已使我荒凉，成为更新的荒凉。
04-26 342
点击上方三分钟学前端，关注公众号回复交流，加入前端编程面试算法每日一题群面试官也在看的前端面试资料以上是常见的几种排序算法，首先思考一下，Array.prototype.sort()...
43. 手写数组map方法？
最新发布
11-17
根据提供的引用内容，没有直接与手写数组map方法相关的信息。但是，我们可以根据map方法的定义和实现方式来手写一个数组map方法。 数组map方法是一种高阶函数，它可以将一个数组中的每个元素都映射到一个新的元素上...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值