算法小白学习日记-6：七种排序算法

最新推荐文章于 2024-06-15 23:36:03 发布
最新推荐文章于 2024-06-15 23:36:03 发布
阅读量1k 收藏 27
点赞数 30
文章标签： 算法 排序算法 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qi1148/article/details/138033037
版权
本文详细介绍了选择排序、插入排序、希尔排序、冒泡排序、快速排序、归并排序和基数排序七种常见的排序算法，包括它们的原理、C++代码实现以及时间复杂度、空间复杂度和稳定性分析。
摘要由CSDN通过智能技术生成

本文整理了常用的七种排序算法的原理、代码及复杂度，欢迎批评指正~

概览

本文将介绍选择排序、插入排序、希尔排序、冒泡排序、快速排序、归并排序、基数排序这七种常用排序算法，几种算法的比较如下图所示：

在正式开始前，为了便捷地对每种算法进行测试，我们首先准备一个.h文件，并命名为“0.sort_test.h”，内容如下：

#ifndef _SORT_TEST_H
#define _SORT_TEST_H

#include <string.h>
#include <stdlib.h>
#include <time.h>

#define SMALL_DATA_N 5000
#define BIG_DATA_N   1000000

__attribute__((constructor))//这段语句让该函数可以在主函数main之前执行，而不需要调用，用来初始化时间种子
void __init_Rand__() {
    printf("init rand\n");
    srand(time(0));
}

//该函数用来检查数组是否被正确排序
bool check(int *arr, int l, int r) {
    for (int i = l + 1; i < r; i++) {
        if (arr[i] < arr[i - 1]) return false;
    }
    return true;
}

//该函数用来生成随机数组
int *getRandData(int n) {
    int *arr = (int *)malloc(sizeof(int) * n);
    for (int i = 0; i < n; i++) arr[i] = rand() % 10000;
    return arr;
}

//该宏用来交换两个数字
#define swap(a, b) { \
    __typeof(a) __c = a; \
    a = b, b = __c; \
}

//该宏用来测试排序函数
#define TEST(func, arr, n) { \
    printf("Test %s : ", #func); \
    int *temp = (int *)malloc(sizeof(int) * n); \
    memcpy(temp, arr, sizeof(int) * n); \
    long long b = clock(); \
    func(temp, 0, n); \
    long long e = clock(); \
    if (check(temp, 0, n)) { \
        printf("\tOK "); \
    } else { \
        printf("Failed "); \
    } \
    printf(" %ditems %lldms\n", n, (e - b) * 1000 / CLOCKS_PER_SEC); \
    free(temp);\
}

#endif

1. 选择排序

排序原理

遍历数组，每次找到待排序区最大的元素，放到已排序区。

代码实现

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "0.sort_test.h"

void selection_sort(int *arr, int l, int r) {
    for (int i = l, I = r - 1; i < I; i++) {
        int ind = i;
        for (int j = i + 1; j < r; j++) {
            if (arr[j] < arr[ind]) ind = j;
        }
        swap(arr[i], arr[ind]);
    }
    return ;
}

int main() {
    int *arr = getRandData(SMALL_DATA_N);
    TEST(selection_sort, arr, SMALL_DATA_N);
    free(arr);
    return 0;
}

算法分析

  • 时间复杂度：数组有n个元素，扫描n次，共需要比较n*（n-1）/2次，因此时间复杂度为O(n^2)；
  • 空间复杂度：排序中没有开辟额外的存储空间，因此空间复杂度为O(1)；
  • 稳定性：排序中每次遍历将最大值调整到待排序区，因此会打乱相同元素的顺序，算法不稳定。

2. 插入排序

排序原理

依次调整每个元素，如果前面的元素大于当前元素，则交换顺序。

代码实现

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "0.sort_test.h"

void insert_sort(int *arr, int l, int r) {
    for (int i = l + 1; i < r; i++) {
        int j = i;
        while (j > l && arr[j] < arr[j - 1]) {
            swap(arr[j], arr[j - 1]);
            j -= 1;
        }
    }
    return ;
}

void unguarded_insert_sort(int *arr, int l, int r) {
    int ind = l;
    for (int i = l + 1; i < r; i++) {
        if (arr[i] < arr[ind]) ind = i;
    }
    while (ind > l) {
        swap(arr[ind], arr[ind - 1]);//将最小的元素移动到数组起始处，避免了j>l条件的判断
        ind -= 1;
    }
    for (int i = l + 1; i < r; i++) {
        int j = i;
        while (arr[j] < arr[j - 1]) {
            swap(arr[j], arr[j - 1]);
            j -= 1;
        }
    }
    return ;
}

int main() {
    int *arr = getRandData(SMALL_DATA_N);
    TEST(insert_sort, arr, SMALL_DATA_N);
    TEST(unguarded_insert_sort, arr, SMALL_DATA_N);
    free(arr);
    return 0;
}

此处展示了两种插入排序算法，第二种为无监督的插入排序。在第一种排序中，需要考虑边界条件"j > l"， 而无监督的插入排序则首先将最小的元素移动到数组前端，这样就避免了每次对于"j > l"条件的判断，提高了算法的效率。

算法分析

  • 时间复杂度：最坏的情况是原数组是逆序，则需要调整n * (n - 1) / 2次，复杂度为O(n^2)。最好的情况是原先数组就是顺序，只需要遍历一遍数组，此时复杂度为O(n)。因此，平均的时间复杂度是O(n^2)；
  • 空间复杂度：排序中没有开辟额外的存储空间，因此空间复杂度为O(1)；
  • 稳定性：排序中不会交换相同元素的顺序，因此算法是稳定的。

3. 希尔排序

排序原理

希尔排序在插入排序的基础上发展而来，首先选择一定的步长，通过步长对数组进行分组，对每组进行插入排序。之后减小步长，重复上述过程。

对于希尔排序的个人理解：对于普通的插入排序，如果原数组越有序，则插入排序的效率越高。希尔排序就是借鉴了这一思想，通过分组排序，使数组整体更加有序，因此提高了效率。

代码实现

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "0.sort_test.h"

void unguarded_insert_sort(int *arr, int l, int r, int step) {
    int ind = l;
    for (int i = l + step; i < r; i += step) {
        if (arr[i] < arr[ind]) ind = i;
    }
    while (ind > l) {//借鉴了无监督的插入排序的思想
        swap(arr[ind], arr[ind - step]);
        ind -= step;
    }
    for (int i = l + 2 * step; i < r; i += step) {
        int j = i;
        while (arr[j] < arr[j - step]) {
            swap(arr[j], arr[j - step]);
            j -= step;
        }
    }
    return ;
}

void shell_sort(int *arr, int l, int r) {
    int k = 2, n = (r - l), step;
    do {
        step = n / k == 0 ? 1 : n / k;
        for (int i = l, I = l + step; i < I; i++) {
            unguarded_insert_sort(arr, i, r, step);
        }
        k *= 2;
    } while (step != 1);
    return ;
}

int main() {
    int *arr = getRandData(BIG_DATA_N);
    TEST(shell_sort,         arr, BIG_DATA_N);
    TEST(shell_sort_hibbard, arr, BIG_DATA_N);
    free(arr);
    return 0;
}

算法分析

  • 时间复杂度：最坏情况的复杂度为O(n^2)，最好情况的复杂度为O(nlogn)；
  • 空间复杂度：排序中没有开辟额外的存储空间，因此空间复杂度为O(1)；
  • 稳定性：因为涉及分组排序，所以有可能交换相同元素的顺序，算法是不稳定的。

4. 冒泡排序

排序原理

遍历数组中的每个元素，如果后面的元素小于前面的元素，则交换两个元素。每次遍历都将最大的元素调整到已排序区。

代码实现

#include <stdio.h>
#include <stdlib.h>
#include "0.sort_test.h"

void bubble_sort(int *arr, int l, int r) {
    for (int i = r - 1, I = l + 1, cnt; i >= I; i--) {
        cnt = 0;
        for (int j = l; j < i; j++) {
            if (arr[j] <= arr[j + 1]) continue;
            swap(arr[j], arr[j + 1]);
            cnt += 1;
        }
        if (cnt == 0) break;//扫描一遍后如果是顺序，则直接跳出
    }
    return ;
}

int main() {
    int *arr = getRandData(SMALL_DATA_N);
    TEST(bubble_sort, arr, SMALL_DATA_N);
    free(arr);
    return 0;
}

算法分析

  • 时间复杂度：最坏的情况是原数组是逆序，则需要调整n * (n - 1) / 2次，复杂度为O(n^2)。最好的情况是原先数组就是顺序，只需要遍历一遍数组，此时复杂度为O(n)。因此，平均的时间复杂度是O(n^2)；
  • 空间复杂度：排序中没有开辟额外的存储空间，因此空间复杂度为O(1)；
  • 稳定性：排序中不会交换相同元素的顺序，因此算法是稳定的。

5. 快速排序

排序原理

快速排序首先选择一个基准值，后将剩余元素分成两个区域，一个区域的元素都小于基准值，一个区域的元素都大于基准值，将基准值插入到两个区域的中间，后分别对两个区域进行快速排序。

代码实现

#include <stdio.h>
#include <stdlib.h>
#include "0.sort_test.h"

void quick_sort(int *arr, int l, int r) {
    if (r - l <= 2) {//当元素较少时，直接排序
        if (r - l <= 1) return ;
        if (arr[l] > arr[l + 1]) swap(arr[l], arr[l + 1]);
        return ;
    }
    int x = l, y = r - 1, z = arr[l];
    while (x < y) {
        while (x < y && z <= arr[y]) --y;
        if (x < y) arr[x++] = arr[y];
        while (x < y && arr[x] <= z) ++x;
        if (x < y) arr[y--] = arr[x];
    }
    arr[x] = z;
    quick_sort(arr, l, x);
    quick_sort(arr, x + 1, r);
    return ;
}

int main() {
    int *arr_s = getRandData(SMALL_DATA_N);
    int *arr_b = getRandData(BIG_DATA_N);
    TEST(quick_sort, arr_s, SMALL_DATA_N);
    TEST(quick_sort, arr_b, BIG_DATA_N);
    free(arr_s);
    free(arr_b);
    return 0;
}

算法分析

  • 时间复杂度：最好的情况是每次进行分区操作时可以均分数组，此时的时间复杂度为O(nlogn)；最坏的情况分区极度不平衡，此时的时间复杂度为O(n^2)；
  • 空间复杂度：跟实现的方法有关；
  • 稳定性：排序过程中会将基准值插入到两个区间中间，因此有可能破坏相同元素的顺序，算法是不稳定的。

6. 归并排序

排序原理

将数组分成个子数字，并继续将子数组分成两份，直到没法再分。之后对数组进行合并，合并每两个数组时，保证合并的顺序是从小到大。

代码实现

#include <stdio.h>
#include <stdlib.h>
#include "0.sort_test.h"

int *buff;
void merge_sort(int *arr, int l, int r) {
    if (r - l <= 1) return ;//递归终止条件
    int mid = (l + r) / 2;
    merge_sort(arr, l, mid);//左段递归
    merge_sort(arr, mid, r);//右段递归
    // merge
    int p1 = l, p2 = mid, k = 0;
    while (p1 < mid || p2 < r) {//利用左右两个指针进行合并
        if (p2 == r || (p1 < mid && arr[p1] <= arr[p2])) {
            buff[k++] = arr[p1++];
        } else {
            buff[k++] = arr[p2++];
        }
    }
    for (int i = l; i < r; i++) arr[i] = buff[i - l];
    return ;
}

int main() {
    int *arr_s = getRandData(SMALL_DATA_N);
    int *arr_b = getRandData(BIG_DATA_N);
    buff = (int *)malloc(sizeof(int) * BIG_DATA_N);
    TEST(merge_sort, arr_s, SMALL_DATA_N);
    TEST(merge_sort, arr_b, BIG_DATA_N);
    free(arr_s);
    free(arr_b);
    free(buff);
    return 0;
}

算法分析

  • 时间复杂度：每次将数组从中间分成两份，因此时间复杂度为O(nlogn)；
  • 空间复杂度：O(n)；
  • 稳定性：在排序中可以保证大小相同元素的前后顺序不变，因此算法稳定。

7. 基数排序

排序原理

基数排序给人一种用空间换时间的感觉，如下图所示，对于10以上的数组，我们可以首先只关注其个位，通过基数排序保证其个位数字从大到小排列。之后再对十位的数字进行基数排序，另外因为基数排序是稳定的，因此在对十位进行排序时，不会打断个位的排序结果。以此类推，直到把所有位数都排序完。

再进一步，在基数排序时也不一定非要按照数字的位数进行排序，可以选择一个数字，比如下面代码中选择的是65536（因为int类型最大是2的32次方，而65536是2的16次方，一个int类型的数字除以65536的结果一定小于65536）。之后开辟一个65536大小的存储空间，首先对每个元素除以65536的余数排序，后对每个元素除以65536的结果排序，只需要两次遍历，就可以将数组排序。

代码实现

#include <stdio.h>
#include <stdlib.h>
#include "0.sort_test.h"

void radix_sort(int *arr, int l, int r) {
    #define K 65536
    int *cnt  = (int *)malloc(sizeof(int) * K);
    int *temp = (int *)malloc(sizeof(int) * (r - l));
    // round 1
    memset(cnt, 0, sizeof(int) * K);
    for (int i = l; i < r; i++) cnt[arr[i] % K] += 1;
    for (int i = 1; i < K; i++) cnt[i] += cnt[i - 1];
    for (int i = r - 1; i >= l; i--) temp[--cnt[arr[i] % K]] = arr[i];
    memcpy(arr + l, temp, sizeof(int) * (r - l));
    // round 2
    memset(cnt, 0, sizeof(int) * K);
    for (int i = l; i < r; i++) cnt[arr[i] / K] += 1;
    for (int i = 1; i < K; i++) cnt[i] += cnt[i - 1];
    for (int i = r - 1; i >= l; i--) temp[--cnt[arr[i] / K]] = arr[i];
    memcpy(arr + l, temp, sizeof(int) * (r - l));
    return ;
}

int main() {
    int *arr_s = getRandData(SMALL_DATA_N);
    int *arr_b = getRandData(BIG_DATA_N);
    TEST(radix_sort, arr_s, SMALL_DATA_N);
    TEST(radix_sort, arr_b, BIG_DATA_N);
    free(arr_s);
    free(arr_b);
    return 0;
}

算法分析

  • 时间复杂度：根据基数排序原理可知复杂度为O(n*K)；
  • 空间复杂度：O(n + K)；
  • 稳定性：在排序中可以保证大小相同元素的前后顺序不变，因此算法稳定。

小齐今天刷题了吗
关注
  • 30
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
初级java笔试题-Sorting-Algorithm-Analysis:七种排序算法的简单分析
06-03
初级java笔试题排序算法分析 排序元组 七种排序算法的简单分析 介绍 1998 年，唐纳德·克努斯 (Donald Knuth) 在他的《计算机编程艺术》第 3 卷：排序和搜索中表示，“编程的几乎每个重要方面都出现在排序或搜索的上下文中。” 事实上，在数据的简单化背景和现实中，需要组织的力量。 鉴于这种情况，我们对几种排序算法的威力和必要性进行了简要的扩展分析。 通过这样做，读者可以从上下文证据中受益并理解排序算法具有积极和消极后果。 我们通过问一个基本问题开始我们的分析：“什么是有效的排序算法？” 要回答这个问题，我们必须首先定义衡量算法优雅和有效性的基础。 游戏规则可以定义如下： (1) 运行时间，算法的性能可以通过比较和交换的基本操作来定义。 此外，任何有效算法的假设都必须在促进完成排序的时间测量的背景下进行检查； (2) 额外内存，内存量和存储额外内存的空间是计算总运行时间的一个因素。 更小的内存需要更高的性能； (3) 数据的类型，我们的排序算法只有在开启Comparable接口的情况下，才能和它处理的items一样有效。 推导出这三个原则，我们可以在衡量一个算法的效率时得
Go语言-排序算法：冒泡排序-综合文档
05-14
Go语言-排序算法：冒泡排序排序算法详解(Go语言实现):冒泡排序/选择排序/快速排序/插入排序 算法是程序的灵魂,而排序算法则是一种最基本的算法。排序算法有许多种,本文介绍4中
[机器学习笔记] K-mean聚类算法即实现代码
编程小白的逆袭日记
06-25 1524
在机器学习领域有一个非常特殊的存在——无监督学习, 其中最为经典就是聚类算法了。聚类算法因为其不需要先验标签，因此在很多领域应用都较为广泛，其中最经典的算法就是Kmean Cluster。
小白日记（**）排序算法：冒泡排序_直接插入排序_简单选择排序_二路归并排序_快速排序
Volta小白
06-18 160
**冒泡排序:** 思路：通过相邻两个元素之间不断比较大小，相互交换位置，来达到有序的目的； #include <stdio.h> #include <stdlib.h> #define MAX 100005 int main() { int a[MAX],i,j,N,temp; scanf("%d",&N); for(i=0 ; i<N ;i++) scanf("%d",&a[i]); printf("\n排序
算法小白学习日记-5：堆
qi1148的博客
04-14 727
分享4道关于堆的题目，欢迎批评指正~
《算法日记-玩出新花样》- 两数求和
专注JAVA、算法、数据库等干货分享，同时维护【IT技术资源免费分享】圈子
10-15 565
算法日记，小白也能看得懂。分享的不止算法、还有学习经验和实战案例！
CUDA-Quicksort:CUDA-Quicksort：快速排序算法的基于GPU的实现-开源
05-29
CUDA-quicksort 是一种基于 GPU 的快速排序算法实现。 CUDA-quicksort 旨在利用现代 NVIDIA GPU 的计算能力。 “文献中介绍了两种基于 GPU 的快速排序实现：GPU 快速排序，一种计算统一设备架构 (CUDA) 迭代实现，...
bm25-ranking-php:使用bm25排序算法对reuter的文档进行排序
07-11
bm25-排名-php 使用bm25排序算法对reuter的文档进行排序。 比较 479/6791
指针和数组
2301_77634163的博客
06-10 436
有3个指针，中间是一个数组arr，有个指针指向中间,其他两个指向两边，一个指向前面，一个人指向后面。虽然简化好，但是我们C语言要求是不允许这样写的,虽然大部分编译器是可以允许我这样写的。下面那个用数组名也是可以用的，因为他也表示一个地址，加1就会找后面那个元素的地址。我们C语言编译器中说指针允许往后比较大小，但不允许往前比面的指针比较大小。地址向后移，指针相比较，指针减减就是减去一个整数。同一指针相减的绝对值得到的是之间元素的个数。数组和指针的地址是一样的，说明是可以的。地址加地址，指针加指针没有意义。
力扣136. 只出现一次的数字
最新发布
LNsupermali的博客
06-15 440
力扣136. 只出现一次的数字
[力扣题解] 236. 二叉树的最近公共祖先
东皇太一在此的博客
06-10 440
用深度搜索的思想（好吧，前序、中序、后序都是深搜思想），保存寻找路径，看看找到2个节点的路径的重合部分，就可以找到最近公共祖先；
算法day25
2202_76101487的博客
06-11 386
正值少年的日常打卡
(第31天)【leetcode题解】404、左叶子之和
m0_73755059的博客
06-10 337
给定二叉树的根节点 root ，返回所有左叶子之和。
算法：位运算题目练习
一名还在努力学习技术的程序员的博客
06-10 675
本篇博客是关于滑动窗口算法的练习题，每道题都超链接了力扣的网页，每道题都有详细的解答过程
LeetCode1318或运算的最小翻转次数
JELEE
06-10 236
给你三个正整数 a、b 和 c。你可以对 a 和 b 的二进制表示进行位翻转操作，返回能够使按位或运算 a OR b == c 成立的最小翻转次数。「位翻转操作」是指将一个数的二进制表示任何单个位上的 1 变成 0 或者 0 变成 1。
探秘扩散模型：训练算法与采样算法的双重解读
染念的博客
06-13 1068
前面终于解释完了正向过程和反向过程，我们接下来理解训练神经网络的算法和采样图片（生成图片）的算法。
笨蛋学算法之LeetCodeHot100_3_最长连续序列（Java）
YSL_Monet的博客
06-12 169
开启我的第三篇LeetCodeHot100算法之路---最长连续序列
群体优化算法----火山爆发算法介绍以及离散优化Pareto最优解示例
u013531166的博客
06-10 484
火山爆发算法（Volcano Eruption Algorithm，VEA）是一种新兴的群智能优化算法，其灵感来源于火山爆发的自然现象。火山爆发算法模拟了火山爆发过程中熔岩流动和喷发的行为，以寻找全局最优解。这种算法利用了火山爆发过程中的不同阶段，包括火山爆发、熔岩冷却和沉积等过程。
算法10-12~10-14：归并排序
06-28
归并排序是一种基于分治思想的排序算法，它将待排序的序列分成两个子序列，对每个子序列进行排序，然后将两个已排序的子序列合并成一个有序序列。 算法10-12是归并排序的递归实现，它将待排序的序列不断地分成两...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值