插入排序增强版

最新推荐文章于 2025-07-08 00:15:00 发布
原创 最新推荐文章于 2025-07-08 00:15:00 发布 · 616 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

排序算法按照其稳定性来说，分为非稳定性排序与稳定性排序算法。判断稳定性与非稳定性算法的依据一般在是否为相邻元素之间的数据交换，不然一般为非稳定排序。比如快速排序，Shell排序等都不是稳定排序，而像冒泡排序，插入排序，合并排序等都是稳定排序。C语言库函数中的qsort函数是基于快速排序的，因此排序之后，未参加排序的数据之间的顺序可能被打乱。有时我们又需要在某一类场景下利用到稳定排序算法。而C++ STL算法库中也对应着这两种算法接口函数: sort与stable_sort，而stable_sort就是稳定排序算法。当然稳定与否还是与具体实现相关，如果算法在交换两个元素时，用的是严格意义上的比较运算，则可能就是稳定的，如果不是严格的(比如>=)，那即使用稳定的算法，也可能排序后的相对元素位置也发生改变了。下面我们研究下稳定的插入排序算法实现，原理就不用多说了，算法流程类似与我们玩纸牌手法，插入新元素之前，原来的序列就是已经排序好的，这样从时间复杂度来说，和冒泡排序一样，都是O(n^2)。以下是简单的实现源码:

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

void insertSort(int a[], int len) //插入排序
{
    if (len < 2) // 如果元素个数小于2,直接返回
    {
        return;
    }
    for (int i = 1; i < len; i++)
    {
        int temp = a[i]; //先将待交换的元素保存起来
        int j = i - 1;
        while (j >= 0 && a[j] > temp) //按照升序排列，如果指定排序元素之前的元素比待排序元素大
        {	                          //，那么从此元素开始到开头，都向后移动一位
            a[j +1] = a[j];
            j--;
        }
        a[j+1] = temp;  //将交换的数据插入到合适位置
    }
}

#define SIZE  sizeof(a)/sizeof(a[0])

int main()
{
    int a[10] = {0};

    srand(time(NULL));

    for (int i = 0; i < SIZE; i++)//随机生成10个数字
    {
        a[i] = rand() % 100;
    }

    for (int i = 0; i < SIZE; i++)//打印排序之前的数字
    {
        printf("%d ", a[i]);
    }
    printf("\n");
    insertSort(a, SIZE);

    for (int i = 0; i < SIZE; i++)//打印排序之后的数字
    {
        printf("%d ", a[i]);
    }

    return 0;
} 

上面只是对整数进行排序，那么能不能对一般数据类型(主要指的是结构体类型)进行排序呢? 答案是肯定的。我们先看看库函数中qsort的函数接口。实际上qsort一般对连续内存的数组进行排序的，qsort一共有4个参数，第1个参数是数组基址，第2个参数是元素个数，第3个参数是每个元素大小，第4个参数是提供给调用者的回调函数，用来改变排序规则用的。我们也可以提供类似的接口，我们这里交换元素的概念变为交换两块内存的内容，本质上和一般的插入排序算法一样，一般插入排序本质上也是交换4个字节的内存数据。于是我们得到如下增强版的插入排序算法：

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

void insertSort(void *base , size_t num, size_t size, int(*cmp_func)(const void*, const void *) ) //插入排序
{
    if (num < 2 || size < 1) // 如果元素个数小于2,直接返回
    {
        return;
    }
    void *pTemp = (void*)malloc(size); //不判定为空指针
    memset(pTemp, 0x0, size);
    for (size_t i = 1; i < num; i++)
    {
        memcpy(pTemp, (char*)base + i * size, size);//先将待交换的元素保存起来
        int j = i - 1; //防止无符号溢出,此处用有符号数
        while (j >= 0 && cmp_func((char*)base + j * size, pTemp) > 0) //按照升序排列，如果指定排序元素之前的元素比待排序元素大
        {	                          //，那么从此元素开始到开头，都向后移动一位
            memcpy((char*)base + (j+1)*size, (char*)base + j * size, size);
            j--;
        }
        memcpy((char*)base + (j+1)*size, pTemp, size);  //将交换的数据插入到合适位置
    }

    free(pTemp);

}

#define SIZE  sizeof(a)/sizeof(a[0])

int cmp_func(const void *a, const void *b)
{
    return *(int*)a - *(int*)b;
}

int main()
{
    int a[10] = {0};

    srand(time(NULL));

    for (unsigned int i = 0; i < SIZE; i++)//随机生成10个数字
    {
        a[i] = rand() % 100;
    }

    for (unsigned int i = 0; i < SIZE; i++)//打印排序之前的数字
    {
        printf("%d ", a[i]);
    }
    printf("\n");

    insertSort(a, SIZE, sizeof(int), cmp_func);

    for (unsigned int i = 0; i < SIZE; i++)//打印排序之后的数字
    {
        printf("%d ", a[i]);
    }

    return 0;
}

假设现在有一个需求，班级一共有10名学生，学生信息包括学生id号，学生姓名及考试总成绩(100分制算)。现在需要对学生信息进行排名：学生成绩按照从高分往低分排序，如果两人成绩一样，则按照学生的姓名字典序排序。

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

typedef struct
{
	int id; //学生ID
	char *name; //学生姓名
	int score; //分数
}student_t;

void insertSort(void *base , size_t num, size_t size, int(*cmp_func)(const void*, const void *) ) //插入排序
{
    if (num < 2 || size < 1) // 如果元素个数小于2,直接返回
    {
        return;
    }
    void *pTemp = (void*)malloc(size); //不判定为空指针
    memset(pTemp, 0x0, size);
    for (size_t i = 1; i < num; i++)
    {
        memcpy(pTemp, (char*)base + i * size, size);//先将待交换的元素保存起来
        int j = i - 1;
        while (j >= 0 && cmp_func((char*)base + j * size, pTemp) > 0) //按照升序排列，如果指定排序元素之前的元素比待排序元素大
        {	                          //，那么从此元素开始到开头，都向后移动一位
            memcpy((char*)base + (j+1)*size, (char*)base + j * size, size);
            j--;
        }
        memcpy((char*)base + (j+1)*size, pTemp, size);  //将交换的数据插入到合适位置
    }

    free(pTemp);

}

student_t student[] =
{
		{320991, "zhangsan", 65},
		{543321, "lisi", 78},
		{333453, "xiaoqi", 79},
		{456566, "hangang", 77},
		{354444, "zhaolei", 91},
		{456566, "hangang", 87},
		{242333, "sunjunior", 99},
		{424444, "wangyong", 88},
		{445444, "santian", 73},
		{445444, "qidong", 91}
};

#define g_student_num sizeof(student)/sizeof(student[0])

int cmp_func(const void *a, const void *b)
{
	student_t *pa = (student_t*)a;
	student_t *pb = (student_t*)b;
	if (pa->score != pb->score)
	{
		return pb->score - pa->score;
	}
	else
	{
		return strcmp(pa->name, pb->name);
	}
}

int main()
{
    for (unsigned int i = 0; i < g_student_num; i++)//打印排序之前的数字
    {
        printf("%d:%s:%d\n", student[i].id, student[i].name, student[i].score);
    }
    printf("*********************************\n");

    insertSort(student, g_student_num, sizeof(student_t), cmp_func);

    for (unsigned int i = 0; i < g_student_num; i++)//打印排序之后的数字
    {
        printf("%d:%s:%d\n", student[i].id, student[i].name, student[i].score);
    }

    return 0;
}


最后再验证下此增强版排序算法的稳定性，即如果数据元素不发生交换的话，排序之前与之后的相对位置不变。现在对上面学生学号分成10类，以学号最后一位作为分类号，如果学号最后一位数字相同，则归为一类，那排序后的情况如何呢？我们只需在上面源码下修改下比较函数即可，其他不变

 

int cmp_func(const void *a, const void *b)
{
	student_t *pa = (student_t*)a;
	student_t *pb = (student_t*)b;
	return pa->id % 10 - pb->id % 10;
}


从上图我们可以看到，排序之前与之后，元素的相对位置还是维持原样，从而证明了增强板插入排序算法是稳定的。

同样，我们将此排序算法运用链表来实现，也可以同样实现其要求，下面是用单链表来实现排序的功能：

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

typedef struct ListNode
{
    void *data;
    struct ListNode *next;

}SList;

SList *insertSort(SList *head, int (*cmp_func)(const void *a, const void *b))
{
    if (head == NULL || head->next == NULL)
    {
        return head;
    }

    SList *newHead = NULL; //原链表剩下的用于直接插入的结点头指针
    SList *pNode = NULL; //待插入结点
    SList *pre = NULL; //前驱指针变量
    SList *cur = NULL; //指向排序好的链表当前指针变量

    newHead = head->next;
    head->next = NULL;
    while (newHead != NULL)
    {
        pNode = newHead;   //待插入结点
        cur = head;   //已经排序好的结点
        while (cur != NULL && (cmp_func(cur->data, pNode->data) < 0))
        {
            pre = cur;
            cur = cur->next;
        }
        //退出循环，找到插入位置
        newHead = newHead->next;
        if (cur == head)
        {
            head = pNode;
        }
        else
        {
            pre->next = pNode;
        }

        pNode->next = cur; //完成插入动作
    }

    return head;
}


typedef struct
{
    int id; //student id
    const char *name; //student name
    int score; //student score
}student_t;

student_t student[] =
{
        {320991, "zhangsan", 65},
        {543321, "lisi", 78},
        {333453, "xiaoqi", 79},
        {456566, "hangang", 77},
        {354444, "zhaolei", 91},
        {456566, "hangang", 87},
        {242333, "sunjunior", 99},
        {424444, "wangyong", 88},
        {445444, "santian", 73},
        {445447, "qidong", 91}
};

int g_student_num = sizeof(student) / sizeof(student[0]);

int cmp_func(const void *a, const void *b)
{
    student_t *pa = (student_t*)a;
    student_t *pb = (student_t*)b;
    if (pa->score != pb->score)
    {
        return pb->score - pa->score;
    }
    else
    {
        return strcmp(pa->name, pb->name);
    }
}


SList *createList(void)
{
    SList *pHead = NULL;
    for (int i = 0; i < g_student_num; i++)
    {
        SList *pTemp = (SList*)malloc(sizeof(SList));
        student_t *pt = (student_t*)malloc(sizeof(student_t));
        pt->id = student[i].id;
        pt->name = student[i].name;
        pt->score = student[i].score;
        pTemp->data = (void*)pt;
        pTemp->next = pHead;
        pHead = pTemp;
    }

    return pHead;
}



void traverseList(SList *pList)
{
    while (pList != NULL)
    {
        student_t *pt = (student_t*)pList->data;
        printf("%d:%s:%d\n", pt->id, pt->name, pt->score);
        pList = pList->next;
    }
    printf("****************\n");
}

int main()
{
    SList *pHead = createList();
    traverseList(pHead);
    pHead = insertSort(pHead, cmp_func);
    traverseList(pHead);



    return 0;
}

从上面排序之后的结果可以看出，跟预期结果是一致的。

插入排序（直接插入），希尔（shell）排序 算法实现（数据结构C语言版）
weixin_56187542的博客
08-03 576
插入排序是把一个记录插入到已排序的有序序列中，使整个序列在插入该记录后仍然有序。插入排序中较简单的种方法是直接插入排序，其插入位置的确定方法是将待插入的记录与有序区中的各记录自右向左依次比较其关键字值的大小。希尔排序是将待排序的数组元素 按下标的一定增量分组 ，分成多个子序列，然后对各个子序列进行直接插入排序算法排序；然后依次缩减增量再进行排序，直到增量为1时，进行最后一次直接插入排序，排序结束。希尔排序其实是将直接插入排序算法优化后的算法，当数据量越大时，这种优化的效果会显著增强。...
Hash函数经典用法
热门推荐
sunjunior的专栏
05-28 1万+
撰写这篇文章之前，先牢骚几句。程序员除了数据结构与算法，什么也不属于自己---记得哪个NB人物曾经说过这样的话。的确，程序员水平高低如何，很大程度上取决于基本功是否扎实。高级程序员与普通码农的区别在我看来就是对这些基础知识是否做到了运用自如。许多程序员开发程序也是简单地调用已有系统库，或者第三方组件，写写简单的hello world或者if...else之类的程序，这样下去其个人竞争优势逐渐散失，
插入排序算法C语言程序.zip
07-19
插入排序算法C语言程序，算法思路:先对数组前两个数进行大小比较，将第三个数与前两个数比较，插入合适位置，再将第四个数与前三个数比较并插入，以此类推
插入排序和希尔排序
Code_Allen的博客
04-18 1263
今天给小伙伴们分享两个比较基础的排序算法，插入排序和希尔排序
排序算法（一）插入排序
s_liang666的博客
08-02 340
1、直接插入排序 思想：每一趟将一个待排序的记录，按照其关键字的大小插入到有序队列的合适位置里，直到全部插入完成。 当数据正序时，执行效率最好，每次插入都不用移动前面的元素，时间复杂度为O(N)。 当数据反序时，执行效率最差，每次插入都要前面的元素后移，时间复杂度为O(N^2)。 所以，数据越接近正序，直接插入排序的算法性能越好。 由于只需要一个临时变量进行存储，因此空间复杂度为O(1)。 直接排序过程中，不需要改变相等元素的位置，所以是稳定的算法。 void insertSort(int arr[],
希尔(Shell) 排序 - 增强版插入排序算法
一叶不知秋
05-05 235
前面讲过的几种排序多是以排序逻辑来命名的，例如冒泡，选择和插入排序，以及其他如归并排序，当然还有觉得自己足够牛 X 快速排序命名。而本文要学习的排序算法叫做希尔排序是以其设计者 Donlad Shell 命令的排序算法，该算法在 1959 年公布，能以作者来命名的算法应该是很不错的，令设计者引以为傲的。最初写出冒泡和选择排序的就没以作者来命名，可能不好意说，更可能是公共思维。 那么什么是希尔排序...
java:实现插入排序（附带源码）
最新发布
欢迎来到我的博客！这里是一个专注于计算机技术的分享平台，涵盖编程开发、算法研究、系统架构、软件工程等多个领域。无论你是初学者还是资深开发者，都能在这里找到有价值的内容。
07-08 604
java:实现插入排序（附带源码）
插入排序
代码大湿的专栏
04-26 297
插入排序主要有直接插入排序和希尔排序希尔排序是直接插入排序的威力增强版。将列表元素分成若干组，，如下图{0,8,3,4,5,6,2,4,40,3}
scratch之十大经典排序算法-插入排序
IT_Scratch的博客
04-08 2408
十大经典排序算法简介0、算法概述0.1 算法分类十种常见排序算法可以分为两大类：比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此也称为非线性时间比...
排序算法之插入排序与希尔排序
weixin_45801057的博客
02-10 180
插入排序 插入排序的核心思想为： 将无序序列插入到有序序列之中 思路 1.给定一个数组，默认将数组的第一个元素作为有序数组，将其他元素作为无序数组，并将无序数组的第一个元素用临时变量保存下来 2.从数组的第二个的元素(即 无序数组的第一个元素 )开始遍历，循环的与有序数组进行比较，根据大小插入到有序数组的相关位置 举例：给定无序数组 [ 4 3 6 2 1 9 8 7 ] 相关过程如图所示： 代...
9 基本排序算法：直接插入排序与希尔排序
gofuncchan的博客
02-18 261
一、直接插入排序 原理 直接插入排序是一种最基本的插入排序方法，能够将第i个记录插入到前面i-1个已排好序的记录中，具体插入过程如下所示。 将第i个记录的关键字Ki 顺序与其前面记录的关键字Ki-1 , Ki-2 , …, K1 进行比较，将所有关键字大于Ki 的记录依次向后移动一个位置，直到遇见关键字小于或者等于Ki 的记录Kj 。此时Kj 后面必为空位置，将第i个记录插入空位置即可。完整的直接...
CListCtrlEx：增强版MFC控件，支持插入控件与列排序
- **插入控件：** CListCtrlEx允许开发者在list控件的任意位置插入其他控件，如Edit框或ComboBox。这一功能极大地扩展了list控件的用途，可以实现更加复杂的用户界面和交互。 - **设置颜色：** 通常，改变list控件...
Java实现插入排序算法并动态打印排序过程
本文将围绕标题“InsertionSort:使用插入排序算法将整数插入排序列表的 Java 程序”以及其描述、标签和相关文件信息，深入探讨插入排序的核心思想、Java 实现细节、算法特性、时间复杂度分析、原地排序机制、数值...
JavaScript实现插入排序算法详解
本资源标题为“js代码-插入排序、、、”，描述同样为“js代码-插入排序、、、”，表明该文件主要聚焦于使用JavaScript语言实现插入排序算法的具体代码实现过程。结合标签信息：“插入排序, JavaScript, 算法, 排序...
c#插入排序
03-22
上述代码展示了如何使用泛型来增强插入排序函数的通用性[^1]。此版本允许对任意类型的集合进行排序，只要这些类型支持比较操作。 如果仅针对整数数组，则可以直接简化为如下形式： ```csharp public class ...
堆排序算法原理及实现
sunjunior的专栏
06-09 8158
堆排序是排序中一种比较重要的算法，和快速排序一样，其复杂度也是O(nlogn)；同时也是一种原地排序算法：在任何时候，数组中只有常数个元素存储在输入数组以外。堆这种数据结构是处理海量数据比较常见的结构，海量数据的TOP K问题一般可以通过分治法+hash+堆这种数据结构解决。值得注意的是，这里将的“堆”准确的说是二叉堆，逻辑上是一棵类似完全二叉树的数据结构。
单链表归并排序
sunjunior的专栏
05-04 4896
数组排序常见的有十几种排序算法，然而对于单链表来说，链表缺乏随机访问特点，导致一些排序算法在时间和空间复杂度上都比较负责，一般的冒泡排序与插入排序，其时间复杂度都是O(N^2)。链表中最优的排序算法应该为归并排序，归并排序是分治法的典型应用，主要思想是将一个大问题划分为N（一般取2）个等价的子问题，通过对子问题的解答来达到对原有问题的解决。下面对链表的归并排序用代码实现。归并排序思想可以参考数组归
二维指针的使用场景
sunjunior的专栏
04-02 3115
实际上，指针作为参数，其目的有许多，一般来说，一维指针主要传给函数入参地址，或者通过其改变地址对应的值。而二维指针也比较类似，如果需要修改指针的值，则可以将函数出参修改为二维指针。若需要修改入参地址，如果实参是一级指针，则函数出参是二级指针，如果实参是二级指针，则函数出参是三级指针。
BST算法原理及其实现
sunjunior的专栏
04-28 2920
首先，我们先了解下递归。说到递归，数据结构中树介绍章节中有大量的实例用了，包括二叉树定义与遍历等。当然一般公司项目中很少用它，主要是效率低下，同时递归涉及到函数反复建栈，压栈，销毁栈的过程，开销较大。这里仅仅作为一种技术探讨来研究。递归，简单地说就是函数自己调用自己，网上也有不少解释了。这里我的看法是将整个递归过程看做一种函数映射关系，即 F(A) --> B,如果B与A具有相同的属性和操作，同时
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值