算法 - 排序 - 插入排序 (Insertion Sort)

最新推荐文章于 2020-12-13 13:04:25 发布
最新推荐文章于 2020-12-13 13:04:25 发布
阅读量307 收藏
点赞数
分类专栏： 基础知识 文章标签： 插入 排序 算法 C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/darkrabbit/article/details/90240581
版权
本文介绍了插入排序的基本思想、性能分析，并提供了直接插入排序、折半插入排序和希尔排序的C++代码实现。重点讲解了直接插入排序与折半插入排序的区别，以及希尔排序的增量序列选择对时间复杂度的影响。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

算法 - 排序 - 插入排序 (Insertion Sort)

返回分类：全部文章 >> 基础知识

返回上级：算法 - 查找与排序 (Searching and Sorting)

本文将用C++实现插入排序算法。

在查看本文之前，需要一些程序语言的基础。

常用插入排序：

  • 直接插入排序 (Direct Insertion Sort) ；

  • 折半插入排序 (Binary Insertion Sort) ，也称二分插入排序；

  • 希尔排序 (Shell Sort) ，也称缩小增量排序 (Diminishing Increment Sort) 。

所有排序方法中，统一使用如下库与结构：

// Author: https://blog.youkuaiyun.com/DarkRabbit
// Sorted Dependency

#pragma once

#include <algorithm>
#include <vector>
#include <stack>

template<typename T>
struct MyItem
{
    int key;
    T data;

    MyItem(){ key = -1; }
    MyItem(const int& k) : key(k){ }
    MyItem(const int& k, const T& d) : key(k), data(d){ }
};

数据表统一使用了std::vector<MyItem<T>>，如果你使用静态数组MyItem<T>[]或指针数组MyItem<T>*，那么还要传入元素数量size。

示例所用数据：

  • 元素数量为size = 15；

  • 关键字为key = { 123, 122, 565, 22, 3, 64, 73, 44, 287, 6, 9, 83, 25, 42, 13 }。

文章目录

1 插入排序简述 (Introduction)

插入排序基本思想：把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列。

常用插入排序：

  • 直接插入排序 (Direct Insertion Sort) ；

  • 折半插入排序 (Binary Insertion Sort) ，又称二分插入排序；

  • 希尔排序 (Shell Sort) ，又称缩小增量排序 (Diminishing Increment Sort) 。

折半插入排序与直接插入排序只是在寻找位置有所不同，这是因为前面的元素已经排过序了。

折半插入排序再插入第 i 个元素时，需要经过 ⌈ log ⁡ 2 i ⌉ + 1 \lceil \log_2i \rceil + 1 ⌈log2​i⌉+1 次关键字比较。

直接插入与折半插入过程：

  • 插入到第 i 个关键字时，逆向依次与已经排过序的关键字比较：
    • 找到比它小的关键字的位置 ilow ，关键字位置在 ilow 到 i-1 之间的元素整体右移 1 位，然后将它插入到 ilow+1；
    • 超出表的范围，则它最小，它之前元素整体右移 1 位，将它插入到0位置。

希尔排序过程：定义一个增量gap

  • 将数据表分成长度为gap的几个块；

  • 对每个块的对应下标元素（间隔是gap）组成的子表进行直接插入排序；

  • 利用公式改变gap（希尔增量是减半，Hibbard增量为 {2k-1, 2k-1-1, …, 7, 3, 1}）；

  • 循环过程，直到不可再分。

具体插入过程：

key = { 123, 122, 565, 22, 3, 64, 73, 44, 287, 6, 9, 83, 25, 42, 13 }

直接插入排序与折半插入排序：
    插入开始位置 i = 1 , 即 key_1 = 122
        它之前的所有元素为 { 123 } ，
        比较它们，122 < 123 ，则 { 123 } 右移 1位，将 122 放在 key_0 的位置

    i = 2 ，即 key_2 = 565 不动
    i = 3 ，即 key_3 = 22
        它之前的所有元素为 { 122, 123, 565 }
        比较它们，超出表的范围
        则它最小，将它们右移一位，然后将 22 放在 key_0 的位置
        现在表 { 22, 122, 123, 565 }
    重复过程

详细过程：
 1: 122 123 565  22   3  64  73  44 287   6   9  83  25  42  13
 2: 122 123 565  22   3  64  73  44 287   6   9  83  25  42  13
 3:  22 122 123 565   3  64  73  44 287   6   9  83  25  42  13
 4:   3  22 122 123 565  64  73  44 287   6   9  83  25  42  13
 5:   3  22  64 122 123 565  73  44 287   6   9  83  25  42  13
 6:   3  22  64  73 122 123 565  44 287   6   9  83  25  42  13
 7:   3  22  44  64  73 122 123 565 287   6   9  83  25  42  13
 8:   3  22  44  64  73 122 123 287 565   6   9  83  25  42  13
 9:   3   6  22  44  64  73 122 123 287 565   9  83  25  42  13
10:   3   6   9  22  44  64  73 122 123 287 565  83  25  42  13
11:   3   6   9  22  44  64  73  83 122 123 287 565  25  42  13
12:   3   6   9  22  25  44  64  73  83 122 123 287 565  42  13
13:   3   6   9  22  25  42  44  64  73  83 122 123 287 565  13
14:   3   6   9  13  22  25  42  44  64  73  83 122 123 287 565


key = { 123, 122, 565, 22, 3, 64, 73, 44, 287, 6, 9, 83, 25, 42, 13 }

希尔排序详细过程：

1: gap=7
    ( 1):  44 122 565  22   3  64  73 123 287   6   9  83  25  42  13
    ( 2):  44 122 565  22   3  64  73 123 287   6   9  83  25  42  13
    ( 3):  44 122   6  22   3  64  73 123 287 565   9  83  25  42  13
    ( 4):  44 122   6   9   3  64  73 123 287 565  22  83  25  42  13
    ( 5):  44 122   6   9   3  64  73 123 287 565  22  83  25  42  13
    ( 6):  44 122   6   9   3  25  73 123 287 565  22  83  64  42  13
    ( 7):  44 122   6   9   3  25  42 123 287 565  22  83  64  73  13
    ( 8):  13 122   6   9   3  25  42  44 287 565  22  83  64  73 123
2: gap=3
    ( 9):   9 122   6  13   3  25  42  44 287 565  22  83  64  73 123
    (10):   9   3   6  13 122  25  42  44 287 565  22  83  64  73 123
    (11):   9   3   6  13 122  25  42  44 287 565  22  83  64  73 123
    (12):   9   3   6  13 122  25  42  44 287 565  22  83  64  73 123
    (13):   9   3   6  13  44  25  42 122 287 565  22  83  64  73 123
    (14):   9   3   6  13  44  25  42 122 287 565  22  83  64  73 123
    (15):   9   3   6  13  44  25  42 122 287 565  22  83  64  73 123
    (16):   9   3   6  13  22  25  42  44 287 565 122  83  64  73 123
    (17):   9   3   6  13  22  25  42  44  83 565 122 287  64  73 123
    (18):   9   3   6  13  22  25  42  44  83  64 122 287 565  73 123
    (19):   9   3   6  13  22  25  42  44  83  64  73 287 565 122 123
    (20):   9   3   6  13  22  25  42  44  83  64  73 123 565 122 287
3: gap=1
    (21):   3   9   6  13  22  25  42  44  83  64  73 123 565 122 287
    (22):   3   6   9  13  22  25  42  44  83  64  73 123 565 122 287
    (23):   3   6   9  13  22  25  42  44  83  64  73 123 565 122 287
    (24):   3   6   9  13  22  25  42  44  83  64  73 123 565 122 287
    (25):   3   6   9  13  22  25  42  44  83  64  73 123 565 122 287
    (26):   3   6   9  13  22  25  42  44  83  64  73 123 565 122 287
    (27):   3   6   9  13  22  25  42  44  83  64  73 123 565 122 287
    (28):   3   6   9  13  22  25  42  44  83  64  73 123 565 122 287
    (29):   3   6   9  13  22  25  42  44  64  83  73 123 565 122 287
    (30):   3   6   9  13  22  25  42  44  64  73  83 123 565 122 287
    (31):   3   6   9  13  22  25  42  44  64  73  83 123 565 122 287
    (32):   3   6   9  13  22  25  42  44  64  73  83 123 565 122 287
    (33):   3   6   9  13  22  25  42  44  64  73  83 122 123 565 287
    (34):   3   6   9  13  22  25  42  44  64  73  83 122 123 287 565

2 性能分析 (Performance Analysis)

排序方法最好时间最差时间平均时间辅助空间稳定性
直接插入排序O(n)O(n2)O(n2)O(1)稳定
折半插入排序O(n log2n)O(n2)O(n2)O(1)稳定
希尔排序O(n log2n)O(n2)与增量算法有关O(1)不稳定

注意1：希尔排序时间复杂度和增量算法的选择有关，标准希尔增量是 O(n2)，Hibbard增量时间复杂度 O(n1.5) 。

注意2：希尔增量的计算是一个复杂的问题，目前希尔增量的常用算法时间复杂度多为 O(n1.3) 到 O(n1.5) 。

3 直接插入排序C++代码 (Direct Insertion Sort C++ Code)

// Author: https://blog.youkuaiyun.com/DarkRabbit
// Direct Insertion Sort

template<typename T>
void DirectSort(std::vector<MyItem<T>>& list, 
                const int& start, 
                const int& end)
{
    for (int i = start + 1; i <= end; i++)
    {
        for (int j = i; 
             j > start && list[j].key < list[j - 1].key; 
             j--) // 比较
        {
            std::swap(list[j], list[j - 1]); // 左移
        }
    }
}

template<typename T>
void DirectSort(std::vector<MyItem<T>>& list)
{
    DirectSort(list, 0, list.size() - 1);
}

4 折半插入排序C++代码 (Binary Insertion Sort C++ Code)

// Author: https://blog.youkuaiyun.com/DarkRabbit
// Binary Insertion Sort
template<typename T>
void BinarySort(std::vector<MyItem<T>>& list)
{
    int left;
    int right;
    int mid;
    for (int i = 1; i < list.size(); i++)
    {
        left = 0;
        right = i - 1;
        while (left <= right) // 二分找位置
        {
            mid = (left + right) / 2;

            if (list[i].key < list[mid].key)
            {
                right = mid - 1;
            }
            else
            {
                left = mid + 1;
            }
        }

        for (int j = i - 1; j >= left; j--) // 右移
        {
            std::swap(list[j + 1], list[j]);
        }
    }
}

5 希尔排序C++代码 (Shell Sort C++ Code)

// Author: https://blog.youkuaiyun.com/DarkRabbit
// Shell Sort
template<typename T>
void ShellSort(std::vector<MyItem<T>>& list, int gap)
{
    if (list.empty())
    {
        return;
    }

    if (gap < 0 || gap >= list.size())
    {
        gap = list.size() / 2;
    }

    for (gap; gap != 0; gap /= 2) // 标准希尔增量
    {
        // 直接插入排序
        for (int i = gap; i < list.size(); i++)
        {
            for (int j = i; 
                 j >= gap && list[j].key < list[j - gap].key; 
                 j -= gap)
            {
                std::swap(list[j], list[j - gap]);
            }
        }
    }
}

template<typename T>
void ShellSort(std::vector<MyItem<T>>& list)
{
    ShellSort(list, list.size() / 2);
}
算法：排序算法之插入排序
7-SEVENS
03-30 1441
在前一篇《算法：排序算法之冒泡排序》中，我们已经对冒泡排序做了解析说明，本节我们将继续对排序算法（插入排序）进行相关解析说明。 排序算法系列目录说明 冒泡排序（Bubble Sort） 插入排序（Insertion Sort） 希尔排序（Shell Sort） 选择排序（Selection Sort） 快速排序（Quick Sort） 归并排序（Merge Sort） 堆排序（Hea...
排序算法-插入排序（InsertionSort）
dandelion_zjw的博客
03-14 1747
排序算法-插入排序（InsertionSort）-优化-希尔排序---JavaScript
insertion sort
在水一方
08-07 1055
1.insertion sort#include #include #include #define N 20 void main() { int i,j,temp, a[N]; srand((unsigned)time(0)); puts("this is the 20 numbers,"); for( i = 0; i < N; i++) { a[i] = rand(
insertionsort
当年小丑
12-05 1028
/* * szlInsertSort.h */ #ifndef SZL_INSERTSORT_H #define SZL_INSERTSORT_H /* * 将长度为n的数组a进行插入排序 */ void insertSort(int a[], int n); #endif /* szlInsertSort.c * 插入排序：首先认为第一个元素作为一个整体是排好序的； * 第
Insertion Sort
weixin_33800593的博客
03-22 198
https://www.youtube.com/watch?v=kU9M51eKSX8 插入排序 插入排序（Insertion Sort）的基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序，时间复杂度为O(n^2)。是稳定的排序方法。 插入排序的基本思想是：每步将一个待排序的纪录，按其关键码值的大小插...
基于python的排序算法-插入排序Insertion Sort
06-25
**插入排序(Insertion Sort)**是一种简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用到...
排序算法-基于C语言实现的排序算法之InsertionSort实现.zip
最新发布
03-27
综上所述，这个压缩包文件提供了一个基于C语言实现的插入排序算法示例，通过学习和理解这段代码，可以深入理解插入排序的工作原理及其在C语言中的实现方式。这对于初学者提升算法知识和编程技能非常有帮助。
详解Java常用排序算法-插入排序
08-26
在上面的代码中，`insertionSort` 函数接受一个整数数组作为输入，并使用插入排序算法对其进行排序。 插入排序算法的优点是： * 实现简单 * 在小型列表上的性能非常好 然而，插入排序算法的缺点是： * 时间...
Java数据结构及算法实例：插入排序 Insertion Sort
09-03
插入排序（Insertion Sort）是一种简单直观的排序算法，它的工作原理是通过构造一个有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用...
insertion-sort
skywatercomputer的专栏
03-27 640
The core idea of the insertion sort is to place an element in the appropriate location in the array.The detail steps of this algorithm are as follows:1.      Choose an element from left to right, and ...
Insertion sort
yansen_2010的专栏
01-12 437
from: https://www.khanacademy.org/computing/computer-science/algorithms/insertion-sort/a/insertion-sort There are many different ways to sort. As selection sort runs, the subarray at the begi
insertion_sort
iytime
03-30 487
看了算法导论后写的一个关于插入排序的程序，有缺点的地方欢迎指正 #include #include #define MAX 100 void INSERTION_SORT(int A[],int len); int main(void) { int len=0,A[MAX]; while(scanf("%d",&A[len]) != EOF)
Insertionsort
ChuckLin的博客
02-17 1381
经典插入排序 具体算法： 在数组中向前遍历每个元素，遍历时将这个元素插入到前面的序列中。 //代码清单： //in java source code for (int i = left, j = i; i &amp;lt; right; j = ++i) { long ai = a[i + 1]; while (ai &amp;lt; a[j]) { ...
insertionSort
？？？？？？？？？？？？的博客
01-09 306
插入排序 插入排序的思想：简单来说就是用一个变量来记录你要插入的数据，然后在内层for循环中遍历找到合适的位置插入 外循环执行N-1次，这很明显。 但内循环执行的次数取决于输入： 在最好的情况下，数组已经排序并且（a [j]&gt; X）总是为假所以不需要移位数据，并且内部循环运行在O（1）， 在最坏的情况下，数组被反向排序并且（a [j]&gt; X）始终为真插入始终发生在数组的前端，并且内部...
C. Insertion Sort
weixin_41755781的博客
02-18 815
题目链接：http://codeforces.com/group/NVaJtLaLjS/contest/238651/problem/C 题面：   题目大意：给你一个数组，求任意交换其中两个数，使得交换后的逆序数最小，输出最小的逆序数以及有多少种方案。 思路：看了大神的代码没看懂，就顺着他的思路重新写了一遍，过了，好开心，主要是两个数组ma[i][j]表示i到j区间内大于a[i]的数...
一、Insertion sort
runing
12-13 155
1. 问题 2. 算法 2.1 伪代码 2.2 算法思想 2.3 手工演示 2.4 Python实现 《算法导论》一书数组默认从111开始，这种方式适合算法分析，从000开始适合程序实现，为了能和伪代码一致便于对比，后边所有的Python实现中数组均从111开始。 # -*- coding: utf-8 -*- import sys def insertion_sort(A, n): for j in range(2, n+1): key = A[j] i
Insertion Sort(插入排序）
H_earbeats的博客
08-07 2384
插入即表示将一个新的数据插入到一个有序数组中，并继续保持有序。例如有一个长度为N的无序数组，进行N-1次的插入即能完成排序；第一次，数组第1个数认为是有序的数组，将数组第二个元素插入仅有1个有序的数组中；第二次，数组前两个元素组成有序的数组，将数组第三个元素插入由两个元素构成的有序数组中……第N-1次，数组前N-1个元素组成有序的数组，将数组的第N个元素插入由N-1个元素构成的有序数组中，则完成了整
C语言实现InsertionSort排序算法详解
标签所指的排序算法、C语言和InsertionSort，分别指向了算法的类型、编程语言和具体的排序方法。这些关键词概括了资源的主要内容，对于希望学习相关知识的读者提供了明确的方向。 压缩包文件的名称列表中包含了资源...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值