C语言实现插入排序——直接插入排序（根据输入实时排序、不带哨兵排序、带哨兵排序）

最新推荐文章于 2023-09-23 17:47:53 发布
最新推荐文章于 2023-09-23 17:47:53 发布
阅读量879 收藏 6
点赞数
分类专栏： 数据结构 文章标签： c语言 直接插入排序 带哨兵直接插入排序 不带哨兵直接插入排序 边输入边直接插入排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41870552/article/details/108565636
版权

C语言实现直接插入排序

文章目录

一、动态数组实现即输即排

1.定义动态数组

#define InitSize 25

//定义动态顺序表
typedef struct {
    int *data;
    int MaxSize;
    int length;
} DSqList;

2.初始化动态数组

//初始化动态顺序表
void InitList(DSqList &L) {
    //用malloc函数申请一片连续的存储空间
    L.data = (int *) malloc(InitSize * sizeof(int));
    //数组中包含有效数据个数
    L.length = 0;
    //数组最大长度
    L.MaxSize = InitSize;
}

3.增加动态数组长度

//增加动态数组长度
void IncreaseSize(DSqList &L, int len) {
    int *p = L.data;
    //重新申请符合长度的连续空间
    L.data = (int *) malloc((L.MaxSize + len) * sizeof(int));
    //将原空间里的数据复制到新的区域
    for (int i = 0; i < L.length; ++i) {
        L.data[i] = p[i];
    }
    //顺序表的最大长度增加 len
    L.MaxSize += len;
    //释放原来的顺序表所占的空间
    free(p);
}

4.排序算法

//插入元素并进行排序
bool InsertAndSort(DSqList &L, int e) {
    if (L.length >= L.MaxSize)  //判断数组是否已满
    {
        printf("数组已满，插入失败，请增加长度后再插入！");
        return false;
    } else if (L.length == 0) {   //是否为空数组
        L.data[0] = e;
        L.length++;
        return true;
    } else {                    //当数组不为空
        int i, j;
        i = L.length;
        if (e < L.data[i - 1]) {//将待插入值与数组中已存在的最后一个值比较，如果小于
            for (j = i - 1; j >= 0 && L.data[j] > e; --j)   //从后往前查找直到找到待插入位置
                L.data[j + 1] = L.data[j];  //元素后移
            L.data[j + 1] = e;  //插入
            L.length++;
        } else {
            L.data[L.length] = e;//当待插入值大于或等于最后一个值，则直接在最后一个值后面插入
            L.length++;
        }
        return true;
    }

}

5.实时输入数值并排序

//根据输入值进行直接插入排序
void CreateList(DSqList &L) {
    int e;
    scanf("%d", &e);
    getchar();
    while (e != -1) {
        InsertAndSort(L, e);
        printf("请继续输入下一个值（如果结束请输入-1）：");
        scanf("%d", &e);
        getchar();
    }
}

二、不带哨兵的数组直接插入排序

//对已存在的数组进行直接插入排序（不带哨兵）
void InsertSort_N(int arr[], int len) {
    int i, j, temp;
    for (i = 1; i < len; ++i) {         //将各元素插入已排好序的序列中
        if (arr[i] < arr[i - 1]) {      //若arr[i]的值小于前驱
            temp = arr[i];              //用temp暂存arr[i]
            for (j = i - 1; j >= 0 && arr[j] > temp; --j)   //检查所有前面已排好序的元素
                arr[j + 1] = arr[j];    //所有大于temp的元素后移
            arr[j + 1] = temp;          //插入temp
        }
    }
}

三、带哨兵的数组直接插入排序

//对已存在的数组进行直接插入排序（带哨兵）
void InsertSort_Y(int arr[], int len) {
    int i, j;
    for (i = 2; i < len; ++i) {         //将arr[2]~arr[n]各元素插入已排好序的序列中
        if (arr[i] < arr[i - 1]) {      //若arr[i]的值小于前驱
            arr[0] = arr[i];            //复制为哨兵，arr[0]初始时不存放有效关键字
            for (j = i - 1; arr[j] > arr[0]; --j)   //检查所有前面已排好序的元素
                arr[j + 1] = arr[j];    //所有大于哨兵的元素后移
            arr[j + 1] = arr[0];        //复制到插入位
        }
    }
}

项目完整代码

//插入排序————直接插入排序（稳定，空间复杂度为O(1)，时间复杂度为O(n^2)）
#include <stdio.h>
#include <stdlib.h>

#define InitSize 25

//定义动态顺序表
typedef struct {
    int *data;
    int MaxSize;
    int length;
} DSqList;

//初始化动态顺序表
void InitList(DSqList &L) {
    //用malloc函数申请一片连续的存储空间
    L.data = (int *) malloc(InitSize * sizeof(int));
    //数组中包含有效数据个数
    L.length = 0;
    //数组最大长度
    L.MaxSize = InitSize;
}

//增加动态数组长度
void IncreaseSize(DSqList &L, int len) {
    int *p = L.data;
    //重新申请符合长度的连续空间
    L.data = (int *) malloc((L.MaxSize + len) * sizeof(int));
    //将原空间里的数据复制到新的区域
    for (int i = 0; i < L.length; ++i) {
        L.data[i] = p[i];
    }
    //顺序表的最大长度增加 len
    L.MaxSize += len;
    //释放原来的顺序表所占的空间
    free(p);
}

//插入元素并进行排序
bool InsertAndSort(DSqList &L, int e) {
    if (L.length >= L.MaxSize)  //判断数组是否已满
    {
        printf("数组已满，插入失败，请增加长度后再插入！");
        return false;
    } else if (L.length == 0) {   //是否为空数组
        L.data[0] = e;
        L.length++;
        return true;
    } else {                    //当数组不为空
        int i, j;
        i = L.length;
        if (e < L.data[i - 1]) {//将待插入值与数组中已存在的最后一个值比较，如果小于
            for (j = i - 1; j >= 0 && L.data[j] > e; --j)   //从后往前查找直到找到待插入位置
                L.data[j + 1] = L.data[j];  //元素后移
            L.data[j + 1] = e;  //插入
            L.length++;
        } else {
            L.data[L.length] = e;//当待插入值大于或等于最后一个值，则直接在最后一个值后面插入
            L.length++;
        }
        return true;
    }

}

//根据输入值进行直接插入排序
void CreateList(DSqList &L) {
    //输入二叉树中的结点的值(一个字符)，空格字符表示空树并构造二叉链表表示的树T
    int e;
    scanf("%d", &e);
    getchar();
    while (e != -1) {
        InsertAndSort(L, e);
        printf("请继续输入下一个值（如果结束请输入-1）：");
        scanf("%d", &e);
        getchar();
    }
}

//对已存在的数组进行直接插入排序（不带哨兵）
void InsertSort_N(int arr[], int len) {
    int i, j, temp;
    for (i = 1; i < len; ++i) {         //将各元素插入已排好序的序列中
        if (arr[i] < arr[i - 1]) {      //若arr[i]的值小于前驱
            temp = arr[i];              //用temp暂存arr[i]
            for (j = i - 1; j >= 0 && arr[j] > temp; --j)   //检查所有前面已排好序的元素
                arr[j + 1] = arr[j];    //所有大于temp的元素后移
            arr[j + 1] = temp;          //插入temp
        }
    }
}

//对已存在的数组进行直接插入排序（带哨兵）
void InsertSort_Y(int arr[], int len) {
    int i, j;
    for (i = 2; i < len; ++i) {         //将arr[2]~arr[n]各元素插入已排好序的序列中
        if (arr[i] < arr[i - 1]) {      //若arr[i]的值小于前驱
            arr[0] = arr[i];            //复制为哨兵，arr[0]初始时不存放有效关键字
            for (j = i - 1; arr[j] > arr[0]; --j)   //检查所有前面已排好序的元素
                arr[j + 1] = arr[j];    //所有大于哨兵的元素后移
            arr[j + 1] = arr[0];        //复制到插入位
        }
    }
}

int main() {
    DSqList L;
    InitList(L);

    //根据实时输入值进行直接快速排序
    printf("请继续输入第一个值（如果结束请输入-1）：");
    CreateList(L);
    //将已排序的结果逐个输出
    printf("根据输入的值直接排序结果为：");
    for (int i = 0; i < L.length; ++i) {
        printf("%d ", L.data[i]);
    }

    printf("\n");

    //不带哨兵的数组进行快排
    int arr_n[] = {49, 38, 65, 97, 76, 13, 27, 49};
    int len = sizeof(arr_n) / sizeof(int);
    InsertSort_N(arr_n, len);
    //将已排序的结果逐个输出
    printf("不带哨兵的数组进行直接排序结果为：");
    for (int i = 0; i < len; ++i) {
        printf("%d ", arr_n[i]);
    }

    printf("\n");

    //带哨兵的数组进行快排
    int arr_y[] = {0, 49, 38, 65, 97, 76, 13, 27, 49};
    len = sizeof(arr_y) / sizeof(int);
    InsertSort_Y(arr_y, len);
    //将已排序的结果逐个输出
    printf("带哨兵的数组进行直接排序结果为：");
    for (int i = 1; i < len; ++i) {
        printf("%d ", arr_y[i]);
    }
    return 0;
}

运行效果图

//不带哨兵的数组
    int arr_n[] = {49, 38, 65, 97, 76, 13, 27, 49};
//带哨兵的数组
    int arr_y[] = {0, 49, 38, 65, 97, 76, 13, 27, 49};

在这里插入图片描述

Geekingdom
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
插入排序（C语言）
qq_43717119的博客
01-09 436
插入排序（C语言） //插入排序 #include<stdio.h> #define MAXSIZE 1024 typedef struct { int key;//关键字项 char data;//其他数据项 }RecordType;//记录类型 void D_insert(RecordType R[],int n) { //对n个记录序列R[1]~R[n]进行直接插入排序 int i,j; for(i=2;i<=n;i++) { if(R[i].key<R
简单了解C语言中直接插入排序与直接选择排序实现
09-02
直接插入排序和直接选择排序是两种基础的排序算法，它们在C语言中有着直观的实现。这两种算法都属于原地排序，即它们不需要额外的存储空间来完成排序过程。 直接插入排序的基本思想是通过逐步将未排序的元素插入到...
直接插入排序（无哨兵版）
qiandididi的博客
07-03 275
排序
educoder:第1关：实现直接插入排序
m0_54015435的博客
04-28 8502
第1关：实现直接插入排序 任务描述 本关要求通过补全函数DirecInsSort来实现直接插入排序的功能。 相关知识 记号说明：a[k:r]是指序列a[k] a[k+1] a[k+2] … a[r]。 为了讨论简单，假设待排序的每个记录是一个整数，这个整数就是排序码。 直接插入排序：先将第一个记录看作是一个有序的记录序列，然后从第二个记录开始，依次将未排序的记录插入到这个有序的记录序列中去，直到整个文件中的全部记录排序完毕。 举例说明： 假设待排序的序列是：46,58,15,45,90,18，下面的描述中[
直接插入排序（带哨兵和不带哨兵）
weixin_34313182的博客
06-27 481
前言 插入排序(insertion sort)的基本思想：每次将一个待排序的记录，按其关键字大小插入到前面已经排序好的序列中，直到全部记录插入完成为止.   直接插入排序 基本思想 假设待排序的记录存放在数组R[1..n]中。初始时，R[1]自成1个有序区，无序区为R[2..n].从i = 2起直到i = n 为止，依次将R[i]插入当前的有序区R[1..i - 1]中，生成含n个记录的...
基于C语言实现直接插入排序
Desmond_Woo的博客
03-19 286
直接插入排序： //insertion_sort.c #include<stdio.h> void insertion_sort(int a[], int len) {//len数组长度 int i = 0;//i是下标 for (i = 1; i < len; ++i) { int key = a[i];//key保存本次要插入的元素 while (a[i - ...
C语言实现选择排序、直接插入排序、冒泡排序的示例
09-02
本文将详细探讨三种经典的排序算法——选择排序、直接插入排序和冒泡排序，它们都是基于简单的比较和交换操作来实现的，并且是初学者理解排序算法的良好起点。 1. **选择排序**： 选择排序的主要思路是每次从未...
C语言基本排序算法之插入排序与直接选择排序实现方法
08-29
C语言基本排序算法之插入排序与直接选择排序实现方法 C语言基本排序算法之插入排序与直接选择排序实现方法是计算机科学中最基本的排序算法之一。排序算法是指将一组无序的数据按照一定的规则排列成有序的序列的过程...
直接插入排序算法：C语言实现直接插入排序算法
最新发布
05-22
在C语言中，实现直接插入排序的代码通常包括以下几个关键部分： - 定义数组：C语言中，可以使用`int arr[N]`来定义一个整数数组，其中N是数组的大小。 - 循环结构：使用`for`循环遍历数组，从第二个元素开始。 - ...
插入排序 减治法——C语言代码
05-23
总的来说，"插入排序 减治法——C语言代码"是一个学习和实践C语言基础排序算法的好例子，通过阅读和理解这段代码，你可以深入理解插入排序的工作原理，以及如何用C语言来实现它。同时，也可以探讨如何将问题解决策略...
C语言实现直接插入排序
永不放弃的地盘
10-20 1318
#include #include void insert_sort(int *a,int *b,int arr_size){ int buffer,i=0,j=0,m=0,flag; b[0]=a[0]; for(i=1;ib[j]){ for(m=i;m>j;m--){ b[m] = b[m-1]; } b[j] = a[i]; flag = 1; } } if(flag == 0){ b[i] =
插入排序(C语言)
qq_42669026的博客
08-04 140
void insert_sort(int* arr,size_t len) { for(int i=1; i<len; i++) { int t = arr[i] , k = i; for(int j=i-1; j>=0 && arr[j] > t; j--) { arr[j+1] = arr[j]; k = j; } arr...
插入排序（c语言）
苍老的小孩的博客
03-22 3490
插入排序的基本思想是：每步将一个待排序的纪录，按其关键码值的大小插入前面已经排序的文件中适当位置上，直到全部插入完为止。
【C语言】插入排序
zcxyywd的博客
09-23 6579
详细讲解了直接插入排序和希尔排序的具体流程
C语言之插入排序
sun5739的博客
04-03 1507
插入排序 基本思想： 每一步将一个待排序的数据插入到前面已经排好序的有序序列中，直到插完所有元素为止。 算法实现： 直接插入排序是将无序序列中的数据插入到有序的序列中，在遍历无序序列时，首先拿无序序列中的首元素去与有序序列中的每一个元素比较并插入到合适的位置，一直到无序序列中的所有元素插完为止。 算法代码： //插入排序 void insertSort(int data[],int length){ for (int i=1; i<length;i++) {
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值