利用链表和数组实现5大排序算法（详细篇）

原创 于 2025-12-10 20:34:15 发布 · 762 阅读 · 13 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#排序算法 #链表 #算法 #数据结构 #c# #vscode #vim

一、概念

        将一组无序的数据元素按照特定的规则（如逻辑顺序、字母顺序等）重新排列为有序序列。

1.稳定性：

        在排序过程中，对于序列中两个相等的元素，如果排序前它们的相对位置为a在b之前，排序后a仍然在b之前，则称该排序算法是稳定的。否则，如果排序前后它们的相对位置为a在b之前，则称该排序算法是不稳定的。

2.内排序和外排序：

  • 内部排序：数据在内存中进行排序
  • 外部排序：因排序数据量太大，内存不能一次性容纳全部数据，在排序过程中需要访问外存。

二、内排序算法

1.选择排序算法

步骤：

  1. 初始化：将列表分为有序部分和无序部分。最开始整个序列都是无序部分。
  2. 查找元素：在无序部分中查找最小大的元素。
  3. 交换位置：将找到的最小大元素与未排序部分的第一个元素交换位置。
  4. 更新范围：将未排序部分的起始位置向后移动一位，扩大已排序部分的范围。
  5. 重复步骤：重复上述步骤，直到未排序部分为空，列表完全有序。

动画演示：

数组实现：

#include <stdio.h>
void select_Sort(int arr[],int len);
int main()
{
    int arr[10]={5,1,8,3,9,11,34,90,24,6};
    select_Sort(arr,10);
    return 0;
}

void select_Sort(int arr[],int len)
{
    int min,temp;
    for (int i = 0; i < len; i++)
    {
        min=i;  //第一个元素作为有序序列
        for (int j = i; j < len; j++)  //从无序序列开始
        {
            if(arr[min]>arr[j])     //找到比min更小的元素
            {
                min=j;
            }
        }
        //进行交换
        temp=arr[i];     
        arr[i]=arr[min];
        arr[min]=temp;
        
    }
    for (int i = 0; i < len; i++)
    {
        printf(" %d ",arr[i]);
    }
    printf(" \n");
    
}

链表实现：

//选择排序
void select_sort(PNode head)
{
    if(list_empty(head))
        return;

    PNode min,start , node;
    start = head->next;

    while (start->next != head)
    {
        //寻找无序部分中的最小节点
        min = start;
        node = start->next;
        while (node != head)
        {
            if(node->data < min->data)
                min = node;
            node = node->next;
        }
        
        //将最小节点移动到无序部分开头前面
        if(min != start)
            mv_node(min , start->prev);
        else
            start = start->next;   
    }
}

2.插入排序

步骤：

        1.初始化：将整个序列分成有序和无序两部分，最开始只有第一个元素作为有序部分，其它的都是无序部分。

        2.插入：将无序部分的第一个元素start插入到有序部分。

                1）从右到左找到第一个比start小的元素min。

                2）将start插入到min的后面。

        3.重复步骤：循环执行步骤2，直到将无序部分的所有元素都插入到有序部分中。

动画演示：

数组实现：

#include <stdio.h>
void insert_Sort(int arr[],int len);
int main()
{
    int arr[10]={5,1,8,3,9,11,34,90,24,6};
    insert_Sort(arr,10);
    return 0;
}

void insert_Sort(int arr[],int len)
{
    int start,j;
    for (int i = 1; i < len; i++)
    {
        start=arr[i];  //作为有序序列的第一个元素
        for ( j = i-1; j >=0; j--)  //从右往左找到比start小的元素min（arr[j])
        {
            if(start>arr[j])
            break;
            arr[j+1]=arr[j]; //没有找到就不插入，直接往后继续
        }
        arr[j+1]=start;//讲=将start插入到min后面
    }
    for (int i = 0; i < len; i++)
    {
        printf(" %d ",arr[i]);
    }
    printf(" \n");
    
}

链表实现：

//插入排序
void insert_Sort(PNode head)
{
    if(list_empty(head) )
        return;
    
    PNode start = head->next->next;
    PNode dest , next;
    while (start != head)
    {
        next = start->next;
        //找到第一个比start大的节点
        dest = head;
        while (dest != start)
        {
            if(dest->next->data > start->data)
                break;
            dest = dest->next;
        }
        if(dest != start)
            mv_node(start , dest);
        
        start = next;
    }
}

3.冒泡排序

步骤：

  • 顺序：两个数据的位置符合排序需要
  • 逆序：两个数据的位置不符合排序需要

        遍历所有元素，让相邻两个元素比较，如果逆序，就交换两个元素的位置，否则就不动。经过一轮比较，“极值”就会被放到最后面。

动画演示：

数组实现：

#include <stdio.h>
// 1. 定义交换宏（必须）
#define SWAP(a, b) { int temp = a; a = b; b = temp; }
void bubble_Sort(int arr[], int len);
int main()
{
    int arr[]={5,1,8,3,9,11,34,90,24,6};
    int len = sizeof(arr) / sizeof(arr[0]); // 计算数组长度
    bubble_Sort(arr,len);
    printf(" 排序后的数组：\n");
    for (int i = 0; i < len; i++)
    {
        printf(" %d ",arr[i]);
    }
    printf(" \n");
    return 0;
}
//冒泡排序
void bubble_Sort(int arr[] , int len)
{
    for (int i = 0; i < len; i++)   //完成一轮排序
    {
        for(int j=0 ; j<len-1-i; j++)
        {
            if(arr[j] > arr[j+1])   //逆序
            {
                SWAP(arr[j] , arr[j+1]) //交换两个逆序的元素
            }
        }
    }
}

链表实现：

//冒泡排序
void bubble_Sort(PNode head)
{
    if(list_empty(head) )
        return;
    
    int len =0;
    bool change;
    PNode node = head->next;
    while (node != head){
        len++;
        node = node->next;
    }
    
    for (int i = 0; i < len; i++){
        change =false;
        node = head->next;
        for(int j=0 ; j<len-i-1 ; j++){
            if(node->data > node->next->data){
                change = true;
                mv_node(node , node->next);
            }
            else
                node = node->next;
        }
        if(!change)
            break;
    }
}

4.希尔排序

        是插入排序的优化。

步骤：

  1. 选择一个不序列长度len小的数字gap作为间距（步长、增量）
  2. 以gap进行分组
  3. 在各小组内部进行插入排序
  4. 再将gap减小，重新分组，并在各小组内部进行插入排序
  5. 直到gap小于等于1为止

动画演示

数组实现：

#include <stdio.h>
void shell_insert(int arr[],int count,int gap); //插入
void shell_Sort(int arr[] , int len);
int main()
{
    int arr[10]={5,1,8,3,9,11,34,90,24,6};
    shell_Sort(arr,10);
    return 0;
}
/*
对分组内部进行插入排序
arr：小组的起点
count：小组长度
gap:步长
*/
void shell_insert(int arr[],int count,int gap)
{
     if(count<=1)
        return;
    
    int start ,j;
    for(int i = gap ; i< count * gap ; i+= gap)
    {
        start = arr[i];
        for(j = i-gap ;j>=0 ; j-=gap)
        {
            if(arr[j] < start)
                break;
            arr[j+gap] = arr[j];
        }
        arr[j+gap] = start;
    }
}

//希尔排序
void shell_Sort(int arr[] , int len)
{
    //分组
    for (int gap = len/2; gap  > 0 ; gap/=2)
    {
        for (int i = 0; i < gap; i++)   //对每个小组进行排序
        {
            shell_insert(arr+i , len/gap , gap);
        }
    }
    for (int i = 0; i < len; i++)
    {
        printf(" %d ",arr[i]);
    }
    printf(" \n");
}

5.快速排序

步骤：

  1. 从序列中挑选一个元素，作为基准key，一般是最左边（升序）或最右边（降序）的元素

  2. 进行一轮排序

        i·定义一个left和right，left从左往右走，right从右往左走

        ii.走的过程中，如right遇到比key小的元素就停下来；若left遇到比key大的元素就停下来

        ii交换left和right所在位置的元素，交换后，继续相向而行

        iv.直到left和right相遇，交换key和相遇点的值

  1. 以key分成左右两部分，左边的都是比key小的，右边的都是比key大的

  2. 递归地对左右两部分分别进行快速排序

动画演示：

数组实现：

#include <stdio.h>
// 1. 定义交换宏（必须）
#define SWAP(a, b) { int temp = a; a = b; b = temp; }
void quick_Sort(int arr[] , int left , int right);
int main()
{
    int arr[]={5,1,8,3,9,11,34,90,24,6};
    int len = sizeof(arr) / sizeof(arr[0]); // 计算数组长度
    quick_Sort(arr,0,len-1);
    printf(" 排序后的数组：\n");
    for (int i = 0; i < len; i++)
    {
        printf(" %d ",arr[i]);
    }
    printf(" \n");
    return 0;
}
//快速排序
void quick_Sort(int arr[] , int left , int right)
{
    if(left >= right)
        return;
    
    int key = arr[left];    //比较基准
    int l = left;
    int r = right;

    //进行一轮排序，退出条件就是l和r相遇
    while(l<r){
        //r从右往左走,遇到比key小的元素就停下来
        while (l<r && arr[r] >= key){
            r--;
        }

        //l从左往右走,遇到比key大的元素就停下来
        while (l<r && arr[l] <= key){
            l++;
        }
        if(l<r){
            SWAP(arr[l] ,arr[r])
        }
    }
    //交换key和相遇点的值
    arr[left] = arr[l];
    arr[l] = key;
    
    //d.递归地对左右两部分分别进行快速排序
    quick_Sort(arr , left , l-1);
    quick_Sort(arr , l+1 , right);
}

三、应用场景

排序算法的种类和应用场景如下：

  1. 冒泡排序：适用于待排序序列元素个数较少，或对稳定性要求较高的场景。

  2. 快速排序：适用于待排序序列元素个数较多，且元素分布比较均匀的场景。

  3. 选择排序：适用于待排序序列元素个数较少，或对稳定性要求较高的场景。

  4. 插入/希尔排序：适用于待排序序列元素个数较少，或元素基本有序的场景。

m学习
关注
链表排序算法（C++）：数组辅助排序、插入排序、归并排序
S13352784013的博客
10-11 1044
链表排序算法（C++）：数组辅助排序、插入排序、归并排序
常用排序算法总结（数组+链表）Java
weixin_42970016的博客
01-25 1552
常用排序算法的总结和分析一、简介二、具体分析及代码1.冒泡排序2.选择排序3.插入排序4.归并排序5.快速排序6.希尔排序7.计数排序8.堆排序9.桶排序10.基数排序 一、简介 最近在复习算法和数据结构，复习到排序和查找，在这里对常用的几种排序算法做一个总结 先放一张图，这张图包括了十种经典排序算法的一些特点和复杂度，接下来就按照图中的顺序来进行具体的分析 二、具体分析及代码 说明：本文中的排序目标均为升序 *定义swap方法: private void swap(int[]nums, int
排序算法总结（含链表）
Jerry的博客
10-07 1248
查找中心点的while循环，得根据fast的初始值来进行设计，如果fast=head,则可以用fast→next&&fast→next→next。这些排序算法并不依赖元素之间的比较来确定顺序，因此可以突破 O(n log n) 的时间复杂度。递归的开头一定是判断，如果递归的是快慢那么一定是!涉及到链表元素变动的一般都有哨兵节点；
排序算法汇总（数组+链表）
乐嘉工作室
03-17 915
经典排序算法总结（数组+链表实现排序代码）
冒泡排序【数组、链表实现】
m0_67246225的博客
12-24 905
里面循环控制的是轮两两交换的次数n个元素两两交换需要n-1次，每轮会有一个最大或者最小元素放到最后需要交换的元素会减少,做过几轮就减少几个所以是n-i-1;外面循环用来控制进行几轮冒泡，进行n-1轮就行了；n-1轮后数组后面n-1个数已经是有序了，第一个自然就是最大(降序)或者最小(升序)了；冒泡排序的实现思路是通过一次次的两两交换把当前最大或者最小的元素放到最后面去，进行一定轮数这一过程最后就会得到一个有序序列。链表实现跟数组实现的思路是一样的，只是链表会涉及到两个结点的交换可能会麻烦一点。
c语言 链表的排序算法,排序链表最快的算法是什么？
weixin_34751996的博客
05-22 548
根据许多因素，将列表复制到数组然后使用Quicksort实际上可能更快。之所以会更快，是因为数组的缓存性能要比链表好得多。如果列表中的节点分散在内存中，则可能是整个地方都生成高速缓存未命中。再说一次，如果数组很大，无论如何都会遇到缓存未命中的情况。Mergesort可以更好地并行化，因此如果您要这样做，可能是更好的选择。如果直接在链接列表上执行它，则速度也更快。由于这两种算法都在O(n * log...
链表排序算法实战：归并排序与快速排序详解
weixin_35649491的博客
05-16 982
在计算机科学中，链表是一种基础而重要的数据结构，它是众多复杂数据结构和算法的基础。链表由一系列节点组成，每个节点包含数据部分和指向下一个节点的引用。链表的特性使其在插入和删除操作上具有优势，因为它不需要像数组那样进行数据迁移。快速排序的实现与数据结构无关，可以应用于数组，链表，或者其他数据结构。考虑到快速排序的经典场景是数组，以下给出快速排序对数组的实现。首先需要定义数组节点的数据结构，这里使用Python语言来描述：# 数组排序，所以直接用列表来代替链表。
算法入门——数组，链表，选择排序
qq_55977554的博客
01-30 1506
内存的工作原理 大家逛超市的时候，应该都看见门口有储存柜，进去逛超市时，就把东西存入储存柜，如果你东西很多，就可能需要开两个柜子来放你的东西，然后你就只需要拿着储存柜小票轻轻松松去逛超市了，等逛完超市，你凭借小票在把自己的东西拿出来。其实计算机内存的工作原理大致就是这样，。计算机就是超市门口这一堆储物柜的集合，每个单独的储物柜都有对应的小票，都有它们的地址。 当我们需要将数据存储到内存时，我们请求到计算机，计算机再分配给我们一片空间用于存储。 数组 数组大家都有一定了解了，在python中的列表
链表和数组的二路归并排序
HurryRabbit的博客
04-24 884
归并排序(Merge Sort)是将两个(或两个以上)有序表合并成一个新的有序表，即把待排序序列分为若干个有序的子序列，再把有序的子序列合并为整体有序序列。 归并排序的具体做法： 把原序列不断地递归等分，直至每等份只有一个元素，此时每等份都是有序的。 相邻等份合并，不断合并，直至合并完全。 二路归并 归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法(Divide and ...
《链表算法：浅谈并实现一下链表各种排序算法及其性能》
akiba-miku
11-22 1507
蒟蒻浅浅地谈一下链表的各种排序算法。 我是怎么水这么多的（小声...)
用链表和数组实现各种排序算法(C语言)
zhzdezhanghao的博客
05-23 985
#define MAX_SIZE 100 typedef struct LNode { int data; struct LNode *next; }LNode, *LinkList; void createLinkList(LinkList &L) { int data; scanf("%d", &data); if (data == 0) { L = NULL;...
链表中实现常见排序算法的比较研究
当我们需要通过链表实现排序时，所面对的挑战和数组排序有所不同，因为链表的访问不是连续的，这会影响排序算法的设计和效率。以下是几种可以在链表上实现的排序算法的知识点总结。 ### 1. 冒泡排序（Bubble Sort）...
链表与数组的区别及排序算法实现
链表和数组是两种基本的数据结构，在编程中广泛使用。它们各有优缺点，适用于不同的场景。 1. 链表与数组的区别： - 存储方式：数组在内存中是连续存储的，元素间的地址通常是连续的；而链表的节点在内存中可以...
【计算机算法与设计（4）】排序算法的原理和方法，以及寻找一个长序列中前k个最大数所运用的方法
最新发布
hiliang521的博客
12-09 379
【计算机算法与设计】排序算法的原理和方法，以及寻找一个长序列中前k个最大数所运用的方法
Leetcode 68 搜索插入位置 | 寻找比目标字母大的最小字母
im_AMBER的博客
12-04 1065
你的错误逻辑正确逻辑找到 target 时返回 mid-1找到 target 时，继续向右查找（因为需要「大于」target 的最小字符）target <letters [mid] 时，mid 是候选，需保留，right=mid（左闭右开）或不立即排除 mid循环结束直接返回 letters [0]循环结束后，先判断 left 是否越界：越界则返回 letters [0]，否则返回 letters [left]初始right的取值与「越界判断」不匹配；
练题100天——DAY21：统计奇数个数+合并有序数组
2301_81099859的博客
12-07 366
今天写了两道题，难度，并更新了之前的DAY13的冒泡排序+二进制求和、DAY14全排列的思路。
欧几里得距离算法-相似度
weixin_45609702的博客
12-04 216
本文介绍了一个计算欧几里得距离的Java方法。该方法接收两个Double数组作为输入，通过计算对应元素差值的平方和再开方，返回两个数组之间的欧几里得距离值。当输入数组长度不一致时，方法会返回0作为默认值。欧几里得距离算法常用于比较两个数组之间的相似度，是数据分析和机器学习中的基础距离度量方法。
shardingsphere-jdbc分表实现案例和算法比对
Sunchaser的博客
12-08 784
本文档基于shardingsphere-jdbc-core-spring-boot-starter 5.2.1版本验证分表能力，同时基于实际的业务场景对比几类分表策略和实现方案 分库和分表是两个截然不同的功能，分表只要我们在Springboot中引入shardingsphere-jdbc这个依赖库即可，但是分库就要单独部署一个服务shardingsphere-proxy，其他服务连接shardingsphere-proxy，从而实现分库的功能
从零开始写算法——链表篇：相交链表 + 反转链表
m0_59624833的博客
12-09 263
leetcode hot100中链表的两个题
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值