c++排序算法总结

已于 2022-04-06 14:34:22 修改
阅读量651 收藏 1
点赞数
文章标签： c++ 排序算法
于 2022-04-06 14:28:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30111427/article/details/123988843
版权

排序算法总结

文章目录

排序算法平均时间复杂度最好时间复杂度最坏时间复杂度空间复杂度稳定性
冒泡排序n^2nn^21稳定
选择排序n^2n^2n^21不稳定
插入排序n^2nn^21稳定
希尔排序n^1.3n^2n1不稳定
归并排序nlognnlognnlognn稳定
快速排序nlognnlognn^2logn递归 1非递归不稳定
堆排序nlognnlognnlogn1不稳定
桶排序m*nlogn,m桶数n+k根据内部
计数排序n+kn+kn+kn+k稳定
基数排序d*(n+k)
d是位数,k是进制		d*(n+k)d*(n+k)n+k稳定

算法分析

在这里插入图片描述

算法代码

冒泡排序

/**
 * @brief 冒泡排序
 * 
 * @param v 
 */
void mao_pao_sort(vector<int> &v)
{
    for (int i = 0; i < v.size() - 1; ++i)
    {
        for(int j = 0; j < v.size() - 1 - i; ++j)
        {
            if (v[j] > v[j + 1])
                ::swap(v[j], v[j + 1]);
        }
    }
}

选择排序

/**
 * @brief 选择排序
 * 
 * @param v 
 */
void select_sort(vector<int> &v)
{
    int len = v.size();
    for(int i = 0; i < len - 1; ++i)
    {
        int min_i = i;
        for (int j = i; j < len; ++j)
        {
            if (v[j] < v[min_i])
                min_i = j;
        }
        ::swap(v[i], v[min_i]);
    }
}

插入排序

/**
 * @brief 插入排序
 * 
 * @param v 
 */
void insert_sort(vector<int> &v)
{
    for(int i = 1; i < v.size(); ++i)
    {
        int cur = v[i], j = i - 1;
        while(j >= 0 && v[j] >= cur)
        {
            v[j + 1] = v[j];
            --j;
        }
        v[j + 1] = cur;
    }
}

希尔排序

/**
 * @brief 方式二希尔排序辅助函数
 * 
 * @param v 
 * @param start 
 * @param gap 
 */
void min_xier_sort(vector<int> &v,const int &start, const int &gap)
{
    for(int i = start + gap; i < v.size(); ++i)
    {
        int j = i - gap;
        int cur = v[i];
        while(j >= start && v[j] > cur)
        {
            v[j + gap] = v[j];
            j -= gap;
        }
        v[j + gap] = cur;
    }
}

/**
 * @brief 希尔排序
 * 
 * @param v 
 */
void xier_sort(vector<int> &v)
{
    // 方式一
    for(int gap = v.size() / 2; gap > 0; gap /= 2)
    {
        for (int i = gap; i < v.size(); ++i)
        {
            for(int j = i - gap;j >= 0 && v[j] > v[j + gap]; j-=gap)
                ::swap(v[j + gap], v[j]);
        }
    }

    // 方式二
    // for(int gap = v.size() / 2; gap > 0; gap /= 2)
    // {
    //     for (int i = 0; i < gap; ++i)
    //     {
    //         min_xier_sort(v, i, gap);
    //     }
    // }
}

归并排序

/**
 * @brief 归并排序辅助函数
 * 
 * @param v 
 * @param start 
 * @param end 
 * @param res 
 */
void merge(vector<int> &v, int start, int end, int *res)
{
    int mid = (end + start) / 2, p1 = start, p2 = mid + 1, p_res = start;
    while(p1 <= mid && p2 <= end)
    {
        if (v[p1] <= v[p2])
            res[p_res++] = v[p1++];
        else
        res[p_res++] = v[p2++];
    }
    while(p1 <= mid) res[p_res++] = v[p1++];
    while(p2 <= end) res[p_res++] = v[p2++];
    while(start <= end)
    {
        v[start] = res[start];
        ++start;
    }
}

/**
 * @brief 真正的归并排序
 * 
 * @param v 
 * @param start 
 * @param end 
 * @param res 
 */
void __gui_sor(vector<int> &v, int start, int end, int *res)
{
    if (end - start == 0)
        return;
    __gui_sor(v, start, (end + start) / 2, res);
    __gui_sor(v, (end + start) / 2 + 1, end, res);
    merge(v, start, end, res);
}

/**
 * @brief 归并排序
 * 
 * @param v 
 */
void gui_sort(vector<int> &v)
{
    int *res = new int[v.size()];
    __gui_sor(v, 0, v.size() - 1, res);
    delete [] res;
}

快速排序

/**
 * @brief 快速排序辅助函数
 * 
 * @param v 
 * @param l 
 * @param r 
 * @return int 
 */
int partition(vector<int> &v, int l, int r)
{
    int p = l + 1;
    for(int i = p; i <= r; ++i)
    {
        if (v[i] < v[l])
        {
            ::swap(v[i], v[p]);
            ++p;
        }
    }
    ::swap(v[p - 1], v[l]);
    return p - 1;
}

/**
 * @brief 真正的快排
 * 
 * @param v 
 * @param l 
 * @param r 
 */
void __quick_sort(vector<int> &v, int l, int r)
{
    if (l >= r)
        return;
    int p = partition(v, l, r);
    __quick_sort(v, l, p - 1);
    __quick_sort(v, p + 1, r);
}

/**
 * @brief 快速排序
 * 
 * @param v 
 */
void quick_sort(vector<int> &v)
{
    __quick_sort(v, 0, v.size() - 1);
}

堆排序

/**
 * @brief 调整堆，实际上是下沉操作
 * 
 * @param v 
 * @param n 
 * @param size 
 */
void adjust_heap(vector<int> &v, const int &n, const int &size)
{
    int l = 2*n + 1,
        r = 2*n + 2,
        max_n = n;
    if (l < size && v[l] > v[max_n])
        max_n = l;
    if (r < size && v[r] > v[max_n])
        max_n = r;
    if (max_n != n)
    {
        ::swap(v[n], v[max_n]);
        adjust_heap(v, max_n, size);
    }
}

/**
 * @brief 建堆，自下而上
 * 
 * @param v 
 * @param size 
 */
void build_heap(vector<int> &v, const int &size)
{
    int l = size / 2;
    for(int i = l; i >=0; --i)
    {
        adjust_heap(v, i, size);
    }
}

/**
 * @brief 堆排序
 * 
 * @param v 
 */
void heap_sort(vector<int> &v)
{
    build_heap(v, v.size());
    for (int i = v.size() - 1; i > 0; --i)
    {
        ::swap(v[0], v[i]);
        adjust_heap(v, 0, i);
    }
}

计数排序

/**
 * @brief 计数排序
 * 
 * @param v 
 */
void count_sort(vector<int> &v, int min_num = -100, int max_num = 100)
{
    const int range = max_num - min_num + 1;
    int *arr = new int[range]();
    for(const auto &num: v)
        ++arr[num - min_num];
    int p = 0;
    for (int i = 0; i < range; ++i)
    {
        while(arr[i] != 0)
        {
            v[p++] = i + min_num;
            --arr[i];
        }
    }
    delete [] arr;
}

桶排序

/**
 * @brief 桶排序
 * 
 * @param v 
 * @param buck_num 桶的数量，默认为5个桶
 */
void bucket_sort(vector<int> &v, int step = 3)
{
    // 求出最大最小值
    int min_num = INT_MAX , max_num = INT_MIN;
    for(const auto &t: v)
    {
        if (t < min_num)
            min_num = t;
        if (t > max_num)
            max_num = t;
    }

    vector<vector<int>> buckets((max_num - min_num) / step + 1);
    for(const auto &t: v) // 将数据映射到每个桶中
        buckets[(t - min_num) / step].push_back(t);
    int res_pos = 0;
    for(auto &bucket: buckets)
    {
        for(int i = 1; i < bucket.size(); ++i)
        {
            int j = i - 1;
            while(j >= 0 && bucket[j] > bucket[j + 1])
            {
                ::swap(bucket[j], bucket[j + 1]);
                --j;
            }
        }
        for (const auto &t: bucket)
            v[res_pos++] = t;
    }
}

基数排序

/**
 * @brief 基数排序, 只适用于自然数
 * 
 */
void base_sort(vector<int> &v)
{
    int max = *max_element(v.begin(), v.end());
    int max_dit = 1;
    while((max /= 10) != 0)
        ++max_dit;
    vector<vector<int>> base_v(10);
    for (int i = 0, dev = 1, mod = 10; i < max_dit; ++i,mod*=10,dev *=10)
    {
        for(const auto &x: v)
            base_v[(x % mod) / dev].push_back(x);
        int v_pos = 0;
        for(auto & min_base_v: base_v)
        {
            for(const auto &x : min_base_v)
                v[v_pos++] = x;
            min_base_v.clear();
        }
    }
}

算法测试

#include<iostream>
#include<queue>
#include<functional>
#include<memory>
#include<unordered_map>
#include<string>
#include<algorithm>
#include<math.h>
#include<unordered_set>
#include<queue>
#include<functional>
#include<random>
#include<sys/utime.h>
#include<time.h>
using namespace std;

template <typename T>
void swap(T &a, T &b)
{
    T temp = a;
    a = b;
    b = temp;
}

/**
 * @brief 冒泡排序
 * 
 * @param v 
 */
void mao_pao_sort(vector<int> &v)
{
    for (int i = 0; i < v.size() - 1; ++i)
    {
        for(int j = 0; j < v.size() - 1 - i; ++j)
        {
            if (v[j] > v[j + 1])
                ::swap(v[j], v[j + 1]);
        }
    }
}


/**
 * @brief 选择排序
 * 
 * @param v 
 */
void select_sort(vector<int> &v)
{
    int len = v.size();
    for(int i = 0; i < len - 1; ++i)
    {
        int min_i = i;
        for (int j = i; j < len; ++j)
        {
            if (v[j] < v[min_i])
                min_i = j;
        }
        ::swap(v[i], v[min_i]);
    }
}
/**
 * @brief 插入排序
 * 
 * @param v 
 */
void insert_sort(vector<int> &v)
{
    for(int i = 1; i < v.size(); ++i)
    {
        int cur = v[i], j = i - 1;
        while(j >= 0 && v[j] >= cur)
        {
            v[j + 1] = v[j];
            --j;
        }
        v[j + 1] = cur;
    }
}

/**
 * @brief 方式二希尔排序辅助函数
 * 
 * @param v 
 * @param start 
 * @param gap 
 */
void min_xier_sort(vector<int> &v,const int &start, const int &gap)
{
    for(int i = start + gap; i < v.size(); ++i)
    {
        int j = i - gap;
        int cur = v[i];
        while(j >= start && v[j] > cur)
        {
            v[j + gap] = v[j];
            j -= gap;
        }
        v[j + gap] = cur;
    }
}

/**
 * @brief 希尔排序
 * 
 * @param v 
 */
void xier_sort(vector<int> &v)
{
    // 方式一
    for(int gap = v.size() / 2; gap > 0; gap /= 2)
    {
        for (int i = gap; i < v.size(); ++i)
        {
            for(int j = i - gap;j >= 0 && v[j] > v[j + gap]; j-=gap)
                ::swap(v[j + gap], v[j]);
        }
    }

    // 方式二
    // for(int gap = v.size() / 2; gap > 0; gap /= 2)
    // {
    //     for (int i = 0; i < gap; ++i)
    //     {
    //         min_xier_sort(v, i, gap);
    //     }
    // }
}

/**
 * @brief 归并排序辅助函数
 * 
 * @param v 
 * @param start 
 * @param end 
 * @param res 
 */
void merge(vector<int> &v, int start, int end, int *res)
{
    int mid = (end + start) / 2, p1 = start, p2 = mid + 1, p_res = start;
    while(p1 <= mid && p2 <= end)
    {
        if (v[p1] <= v[p2])
            res[p_res++] = v[p1++];
        else
        res[p_res++] = v[p2++];
    }
    while(p1 <= mid) res[p_res++] = v[p1++];
    while(p2 <= end) res[p_res++] = v[p2++];
    while(start <= end)
    {
        v[start] = res[start];
        ++start;
    }
}

/**
 * @brief 真正的归并排序
 * 
 * @param v 
 * @param start 
 * @param end 
 * @param res 
 */
void __gui_sor(vector<int> &v, int start, int end, int *res)
{
    if (end - start == 0)
        return;
    __gui_sor(v, start, (end + start) / 2, res);
    __gui_sor(v, (end + start) / 2 + 1, end, res);
    merge(v, start, end, res);
}

/**
 * @brief 归并排序
 * 
 * @param v 
 */
void gui_sort(vector<int> &v)
{
    int *res = new int[v.size()];
    __gui_sor(v, 0, v.size() - 1, res);
    delete [] res;
}

/**
 * @brief 快速排序辅助函数
 * 
 * @param v 
 * @param l 
 * @param r 
 * @return int 
 */
int partition(vector<int> &v, int l, int r)
{
    int p = l + 1;
    for(int i = p; i <= r; ++i)
    {
        if (v[i] < v[l])
        {
            ::swap(v[i], v[p]);
            ++p;
        }
    }
    ::swap(v[p - 1], v[l]);
    return p - 1;
}

/**
 * @brief 真正的快排
 * 
 * @param v 
 * @param l 
 * @param r 
 */
void __quick_sort(vector<int> &v, int l, int r)
{
    if (l >= r)
        return;
    int p = partition(v, l, r);
    __quick_sort(v, l, p - 1);
    __quick_sort(v, p + 1, r);
}

/**
 * @brief 快速排序
 * 
 * @param v 
 */
void quick_sort(vector<int> &v)
{
    __quick_sort(v, 0, v.size() - 1);
}

/**
 * @brief 调整堆，实际上是下沉操作
 * 
 * @param v 
 * @param n 
 * @param size 
 */
void adjust_heap(vector<int> &v, const int &n, const int &size)
{
    int l = 2*n + 1,
        r = 2*n + 2,
        max_n = n;
    if (l < size && v[l] > v[max_n])
        max_n = l;
    if (r < size && v[r] > v[max_n])
        max_n = r;
    if (max_n != n)
    {
        ::swap(v[n], v[max_n]);
        adjust_heap(v, max_n, size);
    }
}

/**
 * @brief 建堆，自下而上
 * 
 * @param v 
 * @param size 
 */
void build_heap(vector<int> &v, const int &size)
{
    int l = size / 2;
    for(int i = l; i >=0; --i)
    {
        adjust_heap(v, i, size);
    }
}

/**
 * @brief 堆排序
 * 
 * @param v 
 */
void heap_sort(vector<int> &v)
{
    build_heap(v, v.size());
    for (int i = v.size() - 1; i > 0; --i)
    {
        ::swap(v[0], v[i]);
        adjust_heap(v, 0, i);
    }
}

/**
 * @brief 计数排序
 * 
 * @param v 
 */
void count_sort(vector<int> &v, int min_num = -100, int max_num = 100)
{
    const int range = max_num - min_num + 1;
    int *arr = new int[range]();
    for(const auto &num: v)
        ++arr[num - min_num];
    int p = 0;
    for (int i = 0; i < range; ++i)
    {
        while(arr[i] != 0)
        {
            v[p++] = i + min_num;
            --arr[i];
        }
    }
    delete [] arr;
}

/**
 * @brief 桶排序
 * 
 * @param v 
 * @param buck_num 桶的数量，默认为5个桶
 */
void bucket_sort(vector<int> &v, int step = 3)
{
    // 求出最大最小值
    int min_num = INT_MAX , max_num = INT_MIN;
    for(const auto &t: v)
    {
        if (t < min_num)
            min_num = t;
        if (t > max_num)
            max_num = t;
    }

    vector<vector<int>> buckets((max_num - min_num) / step + 1);
    for(const auto &t: v) // 将数据映射到每个桶中
        buckets[(t - min_num) / step].push_back(t);
    int res_pos = 0;
    for(auto &bucket: buckets)
    {
        for(int i = 1; i < bucket.size(); ++i)
        {
            int j = i - 1;
            while(j >= 0 && bucket[j] > bucket[j + 1])
            {
                ::swap(bucket[j], bucket[j + 1]);
                --j;
            }
        }
        for (const auto &t: bucket)
            v[res_pos++] = t;
    }
}

/**
 * @brief 基数排序, 只适用于自然数
 * 
 */
void base_sort(vector<int> &v)
{
    int max = *max_element(v.begin(), v.end());
    int max_dit = 1;
    while((max /= 10) != 0)
        ++max_dit;
    vector<vector<int>> base_v(10);
    for (int i = 0, dev = 1, mod = 10; i < max_dit; ++i,mod*=10,dev *=10)
    {
        for(const auto &x: v)
            base_v[(x % mod) / dev].push_back(x);
        int v_pos = 0;
        for(auto & min_base_v: base_v)
        {
            for(const auto &x : min_base_v)
                v[v_pos++] = x;
            min_base_v.clear();
        }
    }
}

/**
 * @brief Create a randon object
 * 
 * @param num 
 * @param min 
 * @param max 
 * @return vector<int> 
 */
vector<int> create_randon(long num, int min, int max)
{
    vector<int> res(num);
    uniform_int_distribution<int> r(min,max);
    default_random_engine e(time(0));
    for(auto &x: res)
        x = r(e);
    return res;
}

bool check(const vector<int> v)
{
    for(int i = 0; i < v.size() - 1; ++i)
    {
        if (v[i] > v[i + 1])
            return false;
    }
    return true;
}


int main()
{
    int min = 0, max = pow(10,3), nums = pow(10, 4);
    setbuf(stdout, NULL);
    clock_t s_time, e_time;
    s_time = clock();
    vector<int> my_list = create_randon(nums, min, max);
    vector<int> m_list;
    e_time = clock();
    cout<<"create time"<<(e_time - s_time) * 1.0 / CLOCKS_PER_SEC<<"s\n";

    vector<pair<string, function<void(vector<int>&)>>> functions = {
        {"冒泡", mao_pao_sort},
        {"选择", select_sort},
        {"插入", insert_sort},
        {"希尔", xier_sort},
        {"归并", gui_sort},
        {"快排", quick_sort},
        {"堆排序", heap_sort},
        {"计数排序", bind(count_sort, std::placeholders::_1, min, max)},
        {"桶排序", bind(bucket_sort, std::placeholders::_1, 3)},
        {"基数排序", base_sort}
    };

    for(auto &cp: functions)
    {
        m_list.assign(my_list.begin(), my_list.end());
        s_time = clock();
        cp.second(m_list);
        e_time = clock();
        printf("%-14s: times %fs,check %s\n", cp.first.c_str(), (e_time - s_time) * 1.0 / CLOCKS_PER_SEC, check(m_list)?"true":"false");
    }
    m_list.assign(my_list.begin(), my_list.end());
    s_time = clock();
    sort(m_list.begin(), m_list.end());
    e_time = clock();
    printf("%-14s: times %fs,check %s\n", "库排序算法", (e_time - s_time) * 1.0 / CLOCKS_PER_SEC, check(m_list)?"true":"false");
}
十香的黄豆粉面包
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
排序算法总结C++
weixin_42058099的博客
03-14 171
排序算法 排序是计算机内经常进行的一种操作，其目的是将一组“无序”的记录序列调整为“有序”的记录序列。 排序分为内部排序和外部排序。 若整个排序过程不需要访问外存便能完成，则称此类排序问题为内部排序。 反之，若参加排序的记录数量很大，整个序列的排序过程不可能在内存中完成，则称此类排序问题为外部排序。 八大排序算法均属于内部排序。如果按照策略来分类，大致可分为：交换排序、插入排序、选择排序、归并排序...
一个杂项题1
a3uRa的一个窝
10-27 385
给了，俩个文件 将一个打开用 010editor 打开 像是 python写的 改为.pyc 在线 反编译 得到源码 #!/usr/bin/env python # encoding: utf-8 # 如果觉得不错，可以推荐给你的朋友！http://tool.lu/pyc import flag import random def generate(flag, key, ran): ...
蓝桥杯java历年真题及答案整理(共100道题目及答案)
G_GUi的博客
07-30 1万+
1.字符排序 2.串的简单处理 3.猜算式 4.Excel地址转换 5.手机尾号评分 6.括号问题 7.扑克牌排列 8.第一个数字（数字的值返回） 9.放麦子 10.求21位数的水仙花数 11.猜生日 12.填算式 13.纵横放火柴游戏 14.古代赌局 15.源码变换 16.数量周期 17.提取子串 18.取球博弈 19.密码发生器 20.方阵顺时针旋转 21.古堡算式 22.微生物增殖 23.信用卡号校验 24.输入日期 25.顺时针螺旋填入 26.Playfair密码 27.漏掉的账目明细 28.制作表
[数据结构] 八大排序，快进来学习了
weixin_43717520的博客
06-04 587
排序算法
Java中的数据结构与算法
努力分享一些干货内容，纯干货，没有一点水
09-27 1540
java常用数据结构和常见基本算法
字符串问题
weixin_51352168的博客
08-31 690
字符串问题
c++排序算法
11-24
此排序算法为本人平常学习练习所写，在学习的过程中也是非常希望和大家分享交流
c++所有排序算法的总结
07-25
有10余种排序算法的代码和图解分析,同时还有之间的区别,其中涉及到一些基础的数据结构,树,图,二叉树,堆等.堆排序,快速排序,希尔排序,归并排序,插入排序,选择....
c++排序算法-冒泡排序
11-08
冒泡排序是一种基础且经典的计算机科学排序算法，尤其在C++编程中常见。它通过不断地比较相邻元素并根据需要进行交换，逐步将较大的元素“冒泡”到序列的末尾，从而实现升序排列。这一过程可以理解为一个逐层推进的...
C++ 排序算法之冒泡排序
07-25
C++ 排序算法之冒泡排序
简单的C++排序算法
11-21
一看就懂，一学就会的C++排序算法。学习数组使用，用数组下标进行选择排序，用双循环实现选择排序。 选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是：第一次从待排序的数据元素中选出最小...
C/C++十大排序大总结
小白的逆袭
06-23 1414
BubbleSort（冒泡排序） 定义：在同一个数组中，从数组第一个数开始，相邻两个数进行比较，按照小左大右或者大右小左的顺序，依次循环遍历，进行排序！ void BubbleSort(int *arr,int Length) { int i = 0; int j = 1; int sys = 0; for (i = 0; i < Length-1;...
C++之五种排序方法总结
热门推荐
yszdzjt的博客
08-10 7万+
 模板函数sort( ) sort是一个模板函数:sort( ),括号里可以接受两个或三个参数。这里先说一下两个参数的，因为三个参数的还没研究好，哈哈。 使用sort( )时需要添加头文件&lt;algorithm&gt;,这个英文单词的意思是“ 运算法则”。 接受两个参数时默认的排序方式是升序，添加第三个参数是为了实现降序。第一个参数是所要排序的数列的首地址，而第二个参数是该数列的最后...
排序方法总结C++实现
知识搬运工的博客
03-18 4213
时间复杂度：反映当数据量变化时，操作次数的多少;时间复杂度在评估时，要只保留最高项，并且不要最高项的系数。 时间复杂度的大小比较: N!> x^N >...>3^N >2^N > N^x>...>N^3 >N^2>NlogN>N>logN>1 空间复杂度：是指算法在计算机内执行时，所需额外开辟的空间。 稳...
排序总结(C++)
weixin_34406061的博客
01-28 196
冒泡排序 基础知识 冒泡排序：比较相邻的元素。如果第一个比第二个大，就交换他们两个。每次最外面的循环，得到一个最小值。 时间复杂度：$O(n^2)$ https://blog.csdn.net/guoweim... 代码实现 #include <iostream> using namespace std; int a[1...
gRPC
uxff的专栏
10-18 5万+
gRPC分享概述gRPC 一开始由 google 开发，是一款语言中立、平台中立、开源的远程过程调用(RPC)系统。在 gRPC 里客户端应用可以像调用本地对象一样直接调用另一台不同的机器上服务端应用的方法，使得您能够更容易地创建分布式应用和服务。与许多 RPC 系统类似，gRPC 也是基于以下理念：定义一个服务，指定其能够被远程调用的方法（包含参数和返回类型）。在服务端实现这个接口，并运行一个 g
排序C++实现总结
weixin_42077777的博客
10-02 176
几种排序算法实现C++冒泡排序简单选择排序插入排序希尔排序堆排序归并排序快速排序 注：本文所有代码源自《数据结构与算法C++描述》一书 冒泡排序 简单选择排序 插入排序 基本思想：已知从位置0到位置p-1都是排过序的状态，在前p+1个位置找到第p个元素的正确位置。 最坏 N(N+1)/2; 平均 N(N+1)/4 //简单的插入排序 template<typename Comparable> void insertionSort(vector<Comparable> &a
C语言 | Leetcode C语言题解之第337题打家劫舍III
最新发布
m0_59237910的博客
08-15 180
C语言 | Leetcode C语言题解之第337题打家劫舍III
C++实现的数据结构与排序算法总结
"这篇资料是关于数据结构、算法与应用的C++实现，重点讨论了各种排序算法，包括名次排序、选择排序、冒泡排序、插入排序、基数排序、堆排序、归并排序和快速排序。" 1、名次排序（Rank Sort） 名次排序是一种特殊的...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值