【c++插入排序】对待排序序列使用直接插入排序算法进行排序，输出每一趟排序后的结果

已于 2023-12-03 06:35:50 修改
阅读量659 收藏 8
点赞数 13
分类专栏： 排序 数据结构 文章标签： 排序算法 c++ 算法
于 2023-12-03 05:44:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bilibia_1372/article/details/134760553
版权

涉及知识点

关键词：数据结构 顺序表 排列

本文所用函数参考书籍：《数据结构（c语言版 第2版）》严蔚敏 版本

插入排序

插入排序的基本思想和步骤：

  1. 初始状态：将第一个元素视为已排序序列
  2. 选择未排序序列的第一个元素：将未排序序列中的第一个元素视为当前需要插入的元素。
  3. 在已排序序列中从后向前扫描： 将当前元素与已排序序列中的元素依次比较，找到合适的位置插入。
  4. 插入元素： 将当前元素插入到已排序序列的适当位置，使得插入后的序列仍然保持有序。
  5. 重复步骤2~4： 重复以上步骤，直到未排序序列为空。

算法核心在于对每个未排序的元素，将其与已排序序列中的元素逐个比较。时间复杂度为 O（n^2），是一种稳定的算法。

【问题描述】对待排序序列使用直接插入排序算法进行排序，输出每一趟排序后的结果
【输入形式】
序列元素个数
序列
【输出形式】 每一趟排序后的结果
【样例输入】
6
18 6 28 93 46 55
【样例输出】
6 18 28 93 46 55
6 18 28 93 46 55
6 18 28 93 46 55
6 18 28 46 93 55
6 18 28 46 55 93

  • 法一：参照课本结构体写法·
#include<iostream>
using namespace std;

#define MAXSIZE 20
typedef int KeyType;
typedef struct{
	KeyType key;
	//InfoType otherinfo;	意思是这里还可以依据实际情况继续补充所需类型，本题不需要额外补充 
}RedType;//记录类型
typedef struct{
	RedType r[MAXSIZE+1];	//r[0]做哨兵，所以再额外加一个位置
	int length; 
}SqList;//顺序表类型 


//对顺序表L进行插入排序（从后往前顺序比较） 
void InsertSort(SqList &L)
{
	int i,j;	//i表示正在处理的插入元素，j作移动下标
	for(i=2;i <= L.length;++i){ 	//0号作哨兵，1号默认有序，2号开始插入 
		if(L.r[i].key < L.r[i-1].key){	//判断是否需要插入该元素
			L.r[0] = L.r[i];	//复制该元素为哨兵 
			L.r[i] = L.r[i-1];	//将前一个元素后移
			for(j=i-2;L.r[0].key < L.r[j].key;--j){
				L.r[j+1] = L.r[j];	//若再前一个也比i元素大，则继续后移
			} 
			//经过j循环，此时j指向的元素 <= i元素，则i插入j+1位置 
			L.r[j+1] = L.r[0];	
		}
		
		//输出
		for(int k=1;k<=L.length;k++){
			cout << L.r[k].key << " ";
		}
		cout << endl;
	}	 
 } 
 
 
 
 int main(){
 	SqList L;
 	
 	cin >> L.length;
 	for(int i=1;i<=L.length;i++){
 		cin >> L.r[i].key;
	 }
	 
 	InsertSort(L);
 	
 	return 0;
 }
  • 法二：使用普通数组
#include<iostream>
using namespace std;

#define MAXSIZE 20
typedef int KeyType;

// 对数组arr进行插入排序（从前往后顺序比较）
void InsertSort(KeyType arr[], int length) {
    int i, j;    // i表示正在处理的插入元素，j作移动下标
    for (i = 1; i < length; ++i) {    // 默认第一个元素是有序的，从第二个元素开始插入
        if (arr[i] < arr[i - 1]) {    // 判断是否需要插入该元素
            KeyType temp = arr[i];    // 备份当前元素
            j = i - 1;
            while (j >= 0 && temp < arr[j]) {
                arr[j + 1] = arr[j];    // 将前一个元素后移
                j--;
            }
            // 经过循环，此时temp >= arr[j]，则temp插入j+1位置
            arr[j + 1] = temp;
        }
        // 输出每一趟排序后的结果
        for (int k = 0; k < length; k++) {
            cout << arr[k] << " ";
        }
        cout << endl;
    }
}

int main() {
    int length;

    cin >> length;
    KeyType arr[MAXSIZE];

    for (int i = 0; i < length; i++) {
        cin >> arr[i];
    }

    InsertSort(arr, length);

    return 0;
}

扩展：如果是在一个已经有序序列中，插入一个元素，使其依然有序，则插入排序可改写为：

#include<iostream>
using namespace std;

#define MAXSIZE 20
typedef int KeyType;

// 在有序序列中插入元素，使其依然有序
void InsertIntoSorted(KeyType arr[], int& length, KeyType element) {
    int i = length - 1;

    // 从后往前遍历有序序列，找到合适的位置插入新元素
    while (i >= 0 && element < arr[i]) {
        arr[i + 1] = arr[i];  // 将比新元素大的元素后移
        i--;
    }

    // 插入新元素
    arr[i + 1] = element;
    length++;

    // 输出有序序列
    for (int k = 0; k < length; k++) {
        cout << arr[k] << " ";
    }
    cout << endl;
}

int main() {
    int length;

    cin >> length;
    KeyType arr[MAXSIZE];

    for (int i = 0; i < length; i++) {
        cin >> arr[i];
    }

    KeyType element;
    cin >> element;

    InsertIntoSorted(arr, length, element);

    return 0;
}

折半插入排序

在此基础上，可以再小小的优化成折半插入排序（Binary Insertion Sort）即，二分查找+插入排序=折半插入排序

折半插入排序的基本思想和步骤：

  1. 初始状态： 将第一个元素视为已排序序列。
  2. 选择未排序序列的第一个元素： 将未排序序列中的第一个元素视为当前需要插入的元素。
  3. 在已排序序列中进行折半查找： 使用二分查找的方式在已排序序列中找到合适的位置插入。
  4. 插入元素： 将当前元素插入到已排序序列的适当位置，使得插入后的序列仍然保持有序。
  5. 重复步骤2~4： 重复以上步骤，直到未排序序列为空。

折半插入排序依旧是一种稳定的算法。时间复杂度O（n^2），空间复杂度O（1）

#include<iostream>
using namespace std;

#define MAXSIZE 20
typedef int KeyType;
typedef struct {
    KeyType key;
} RedType;  //记录类型
typedef struct {
    RedType r[MAXSIZE + 1];    //r[0]做哨兵，所以再额外加一个位置
    int length;
} SqList;  //顺序表类型

// 对顺序表L进行折半插入排序
void BinaryInsertSort(SqList& L) {
    for (int i = 2; i <= L.length; ++i) {
        if (L.r[i].key < L.r[i - 1].key) {
            L.r[0] = L.r[i];  // 复制该元素为哨兵
            int left = 1, right = i - 1;

            // 使用二分查找找到插入位置
            while (left <= right) {
                int mid = (left + right) / 2;
                if (L.r[0].key < L.r[mid].key) {
                    right = mid - 1;
                } else {
                    left = mid + 1;
                }
            }

            // 将元素插入到合适的位置
            for (int j = i - 1; j >= left; --j) {
                L.r[j + 1] = L.r[j];
            }
            L.r[left] = L.r[0];
        }

        // 输出每一趟排序后的结果
        for (int k = 1; k <= L.length; k++) {
            cout << L.r[k].key << " ";
        }
        cout << endl;
    }
}

int main() {
    SqList L;

    cin >> L.length;
    for (int i = 1; i <= L.length; i++) {
        cin >> L.r[i].key;
    }

    BinaryInsertSort(L);

    return 0;
}

希尔排序

希尔排序的基本思想是通过将序列分割成若干子序列，对子序列进行插入排序，最后再对整个序列进行一次插入排序。希尔排序是一种不稳定的排序算法，其时间复杂度取决于增量序列的选择。希尔排序的平均时间复杂度为 O(n log n)。

希尔排序的具体步骤如下：

  1. 选择增量： 选择一个增量序列，通常初始增量设为序列长度的一半，之后每次缩小为上一次的一半。
  2. 分割序列： 将序列分割成若干子序列，每个子序列由相隔特定增量的元素组成。
  3. 对每个子序列进行插入排序： 对每个子序列进行插入排序，使得每个子序列都变得部分有序。
  4. 缩小增量： 缩小增量，重复步骤2和步骤3，直到增量为1。
  5. 对整个序列进行插入排序： 最后一步是对整个序列进行一次插入排序，此时序列已经相对较为有序，插入排序的工作量较小。
#include<iostream>
using namespace std;

#define MAXSIZE 20
typedef int KeyType;
typedef struct {
    KeyType key;
} RedType;  //记录类型
typedef struct {
    RedType r[MAXSIZE + 1];    //r[0]做哨兵，所以再额外加一个位置
    int length;
} SqList;  //顺序表类型

// 对顺序表L进行希尔排序
void ShellSort(SqList& L) {
    int gap, i, j;
    for (gap = L.length / 2; gap > 0; gap /= 2) {
        for (i = gap + 1; i <= L.length; ++i) {
            if (L.r[i].key < L.r[i - gap].key) {
                L.r[0] = L.r[i];  // 复制该元素为哨兵
                for (j = i - gap; j > 0 && L.r[0].key < L.r[j].key; j -= gap) {
                    L.r[j + gap] = L.r[j];
                }
                L.r[j + gap] = L.r[0];
            }
        }

        // 输出每一趟排序后的结果
        for (int k = 1; k <= L.length; k++) {
            cout << L.r[k].key << " ";
        }
        cout << endl;
    }
}

int main() {
    SqList L;

    cin >> L.length;
    for (int i = 1; i <= L.length; i++) {
        cin >> L.r[i].key;
    }

    ShellSort(L);

    return 0;
}

文章多用于作者对自身所学知识的梳理和记录。
如能帮到你，不胜荣幸。

bilibia_1372
关注
  • 13
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C++直接插入排序详解以及代码实现
12-25
归并排序（Merge Sort）是一种采用分治法（Divide and Conquer）策略的排序算法。该算法首先将已有序的子序列合并，得到完全有序的序列。在归并排序中，合并操作是将两个有序表合并成一个有序表的过程。 归并排序的原理是将数组不断分成两半，直到每个子数组只有一个元素，然后将这些子数组合并成一个有序的数组。合并操作需要两个子数组都是有序的，因此归并排序需要先对数组进行分解，然后再进行合并。 以下是归并排序的实现步骤： 1. 将待排序的数组不断分成两半，直到每个子数组只有一个元素。这一步被称为分解。 2. 对每个子数进行排序，可以使用任何有效的排序算法。这一步被称为求解。 3. 将所有已排序的子数组合并成一个有序的数组。这一步被称为合并。 归并排序的时间复杂度是 O(n log n)，其中 n 是数组的大小。这是因为它需要将数组分解成两半，然后再合并成一个有序的数组。归并排序的空间复杂度是 O(n)，因为在合并过程中需要额外的空间来存储临时变量。
C++排序算法之插入排序
01-21
本文实例为大家分享了C++排序算法之插入排序的具体代码，供大家参考，具体内容如下 1.基本思想：将未排序的数据元素按大小顺序插入到已排好序数据序列中，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。 例如：对2, 4, 3, 1, 6, 5进行插入排序。进行排序前，默认2是有序的，为有序区，而4, 3, 1, 6, 5是无序的，为无序区。将这五个无序的数按从小到大的顺序插入到有序区。 第一趟排序：将4与有序区的2比较，若小于2则插到2前面，大于2插到2后面。操作后有序区为：{2,4}； 第二趟排序：将3与有序区的每个数比较（与有序区的数按从右到左的顺序比较，即依次与4,2比
【数据结构】八大排序：直接插入排序，希尔排序，直接选择排序，堆排序，冒泡排序，快速排序，归并排序，计数排序详细教学
qq_67405610的博客
01-19 1427
通过了解不同排序的时间和空间复杂度已经稳定性，我们可以依据不同情况选择可以满足我们需求的排序。
【PTA】数据结构与算法------基于顺序表的排序算法函数题
qq_44854473的博客
06-07 1753
L是用户传入的参数，代表待排序的顺序表，也是排序后返回的顺序表。要求打印出每一趟的排序结果。L是用户传入的参数，代表待排序的顺序表，也是排序后返回的顺序表。要求打印出每一趟的排序结果。L是用户传入的参数，代表待排序的顺序表，也是排序后返回的顺序表。要求打印出每一趟的排序结果。L是用户传入的参数，代表待排序的顺序表，也是排序后返回的顺序表。要求打印出每一趟的排序结果。
快速排序
大千世界
08-22 214
快速排序原理代码 原理 设要排序的数组是A[0]……A[N-1]，首先任意选取一个数据（通常选用数组的第一个数）作为关键数据，然后将所有比它小的数都放到它左边，所有比它大的数都放到它右边，这个过程称为一趟快速排序。值得注意的是，快速排序不是一种稳定的排序算法，也就是说，多个相同的值的相对位置也许会在算法结束时产生变动。 一趟快速排序的算法是： 1）设置两个变量i、j，排序开始的时候：i=0，j=N...
数据结构-插入排序的原理与实现
m0_61789994的博客
06-12 1912
标题：插入排序：数据结构中的经典排序算法目录：1. 引言2. 插入排序的原理3. 插入排序的实现3.1 直接插入排序3.2 二分插入排序3.3 希尔排序4. 插入排序的时间复杂度分析5. 插入排序的优缺点6. 实例分析：使用插入排序对数组进行排序7. 结论8. 参考文献。
【数据结构】插入排序：直接插入排序、折半插入排序、希尔排序的学习知识总结
小人物，大梦想！
09-27 525
直接插入排序、折半插入排序、希尔排序的算法思想和代码实现
【数据结构】排序：插入排序与希尔排序详解
wangduduniubi的博客
07-08 965
本章开始就要分享一些常用的排序方法，我们的日常生活中很多地方都要使用排序，比如电商平台可以按照你的需求进行排序，或者是你想了解大学的综合排名时我们之前也学到过一些简单的排序比如冒泡排序，虽然他在时间复杂度上可以说是依托答辩，但是作为排序算法来讲还是非常有教学意义的，让更多的人可以了解到排序。那首先分享两种排序算法，简单了解一下排序；
数据结构与算法-排序（实现直接插入排序，实现快速排序）
最新发布
qq_62898666的博客
11-10 467
先将第一个记录看作是一个有序的记录序列，然后从第二个记录开始，依次将未排序的记录插入到这个有序的记录序列中去，直到整个文件中的全部记录排序完毕。：从待排序记录中任选一个记录，以它的排序码作为中心值，将其它记录划分为两个部分，本关的编程任务是补全 step1/direcInsSort.cpp 文件中的。本关的编程任务是补全 step2/quickSort.cpp 文件中的。为了讨论简单，假设待排序的每个记录是一个整数，这个整数就是排序码。包含所有排序码小于等于中心值的记录，后面的记录是待排序的。
c++插入排序详解
01-01
插入排序的基本操作就是将一个数据插入到已经排序好序的数据中，从而得到一个新的，个数加一的有序数据，算法适用与少量的数据的排序。时间复杂度O(n^2)，是稳定的排序算法。 基本思想：每步将一个待排序的记录，按...
C++插入排序算法实例详解
08-28
主要为大家详细介绍了C++插入排序算法实例，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
排序算法之快速排序c语言（三）
m0_52261881的博客
07-22 505
快速排序法—（几乎最优的排序算法） 前言：快速排序是一种典型的分而治之算法，并且只需要非常少的时间就能完成排序操作。在冒泡排序中https://blog.csdn.net/m0_52261881/article/details/118654312 ，互换两个相邻元素时只能消除一个逆序，而快速排序方法中的一次交换可能消除多个逆序，因此大大加快了排序的速度。是对冒泡排序改进的一种算法。 算法思想： 从待排序序列中选取一个数，可以随机取，但一般是取第一个，称为基准数，设为K,然后将小于K的数放到左边，比K大的排
内部排序算法总结
m0_48055133的博客
07-22 1031
内部排序算法总结
快速排序法
yuanchonglin的博客
12-04 764
1.快速排序原理快速排序是在冒泡排序上进行的改进，思路如下：在待排序中的元素随意选一个元素作为基准，一般都是以第一个元素为基准元素。将元素进行分区，比基准元素元素大的放在其右边，比其小的放在基准元素的左边。对各个分区重复上述的步骤直到所有元素为有序的。2.图解如下：（1）把第一个元素作为基准元素，用于比较进行分区，比基准元素元素大的放在其右边，比基准元素小的放在其左边，设置low索引，用来搜索比基准元素小的，设置high索引，用来搜索比基准元素大的元素。（2）从high索引从右往左依次扫描，5和基准元素6进
快速排序算法及得到数组中任意第K大的数
Lavi的专栏
12-28 1946
1 快速排序的图解 假设我们现在对6 1 2 7 9 3 4 5 10 8这个10个数进行排序。首先在这个序列中随便找一个数作为基准数（不要被这个名词吓到了，就是一个用来参照的数，待会你就知道它用来做啥的了）。为了方便，就让第一个数6作为基准数吧。接下来，需要将这个序列中所有比基准数大的数放在6的右边，比基准数小的数放在6的左边，类似下面这种排列。 3 1 2 5 4 6 9 7 10 8 在初始...
排序算法--快速排序
qq_55342245的博客
07-21 533
快速排序
算法分析：基于划分算法的快速排序C语言实现
Coolstuz的博客
10-08 377
快速排序，在最坏的情况下，算法QUICKSORT 的运行时间是0(n²)，然而如果总是选择中项作为主元，它的时间复杂性是O(nlog n)。多余的也不多说了，书上都有！直接上代码！ #include <stdio.h> #include <stdlib.h> /* 将5设为比较元素，每次比较都需要这个元素，再用j做寻找元素，j每找到一个比5小的数,则i++,并且交换比较过的元素。最后跳出循环，将比较元素与最后i的位置进行交换 1. 5 7...
快速排序算法（含详细代码和算法分析）
Loser5的博客
05-27 694
/* 基本思想 { 交换排序：根据序列中两个元素关键字的比较结果来对换这两个记录在序列中的位置。（冒泡，快速排序） 快速排序步骤（升序为例）： { 基本思想：基于分治法，在待排序表L[1..N]中任取一个元素pivort，作为枢轴（通常取首元素），通过一趟排序将待排序表划分为独立的两部分，使得左边的元素值都小于枢轴元素， 右边的元素值都大于枢轴元素值，则将枢轴元素放到对应位置上，分别递归对左右两个独立的子表重复上述操作。直到每部分只有一个元素为止。 }
c++插入排序代码，输出每趟排序结果、最终排序结果
06-03
好的，以下是 C++ 的插入排序代码，实现了输出每趟排序结果和最终排序结果： ```c++ #include <iostream> using namespace std; void insertionSort(int arr[], int n) { for (int i = 1; i < n; i++) { int key = arr[i]; int j = i - 1; while (j >= 0 && arr[j] > key) { arr[j + 1] = arr[j]; j--; } arr[j + 1] = key; // 输出每趟排序结果 cout << "第" << i << "趟排序结果："; for (int k = 0; k < n; k++) { cout << arr[k] << " "; } cout << endl; } } int main() { int arr[] = { 5, 2, 4, 6, 1, 3 }; int n = sizeof(arr) / sizeof(arr[0]); cout << "原数组为："; for (int i = 0; i < n; i++) { cout << arr[i] << " "; } cout << endl; insertionSort(arr, n); cout << "排序后的数组为："; for (int i = 0; i < n; i++) { cout << arr[i] << " "; } cout << endl; return 0; } ``` 输出结果为： ``` 原数组为：5 2 4 6 1 3 第1趟排序结果：2 5 4 6 1 3 第2趟排序结果：2 4 5 6 1 3 第3趟排序结果：2 4 5 6 1 3 第4趟排序结果：2 4 5 6 1 3 第5趟排序结果：1 2 4 5 6 3 排序后的数组为：1 2 3 4 5 6 ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值