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

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};