经典排序算法 ——直接插入排序

Posted 2021-04-25 代码民工

直接插入排序

•基本思想

•演示

•算法代码

•性能

直接插入排序是指每次从无序表中抽取一个元素插入到一个有序表中的合适位置，待所有元素都插入完后，得到一个新的有序表

具体操作是将一组数的第一个数据看成是一个代排的有序表，从第二个数据开始向有序表中插入数据，在有序表中从后向前依次比较寻求合适的插入位置，直到所有元素都插入完为止

以数据 8、5、2、4、3、1、7、6为例

首先将第一个数8看作一个代排的有序序列，从第二个元素5开始向前插入，5<8，则8的位置为5的插入点，8后移到5的位置

2从有序表末尾开始依次向前比较，2<8，接着向前比较2<5，则2的插入点为5的位置，8和5依次向后移动一位

按照前面的方式4<8，4<5，4>2，则5的位置为插入点，则8和5依次向后移动一位，后续比较都依照此方式，直到所有元素插入完为止，得到新的有序表

3<8，3<5，3<4，3>2，4的位置为插入点，4、5、8后移一位

1<8，1<5，1<4，1<3，1<2，2的位置为插入点，2、3、4、5、8后移一位

7<8，7>5，8的位置为插入点，8后移一位

6<8，6<7，6>5，7的位置为插入点，7、8后移一位

排序完

C++代码

 1#include<iostream>
 2using namespace std;
 3void InsertSort(int a[], int n)
 4{
 5    int i, j, temp;
 6    for (i = 1; i<n; i++)
 7    {
 8        if (a[i]<a[i - 1])
 9        {
10            temp = a[i];
11            for (j = i - 1; j >= 0 && a[j]>temp; j--) 
12            {
13                a[j + 1] = a[j];
14            }
15            a[j + 1] = temp;
16        }
17    }
18}
19int main()
20{
21    int a[8] = { 8,5,2,4,3,1,7,6 };
22    InsertSort(a, 8);
23    for (int i = 0; i < 8; i++)
24    {
25        cout << a[i] << " ";
26    }
27
28    return 0;
29}

Python代码

 1def InsertSort(nums):
 2    for i in range(1,len(nums)):
 3        if nums[i]<nums[i-1]:
 4            temp=nums[i]
 5            j=i-1
 6            while j>=0 and nums[j]>temp:
 7                nums[j+1]=nums[j]
 8                j-=1
 9            nums[j+1]=temp
10a=[8,5,2,4,3,1,7,6];
11InsertSort(a)
12print(a)

Java代码

 1package text;
 2
 3public class InsertSort {
 4    public static void InsertSort(int a[]){
 5        int i,j,temp;
 6        for(i=1;i<a.length;i++){
 7            if(a[i]<a[i-1]){
 8                temp=a[i];
 9                for(j=i-1;j>=0&&a[j]>temp;j--){
10                    a[j+1]=a[j];
11                }
12                a[j+1]=temp;
13            }
14        }
15    }
16    public static void main(String[] args) {
17        int[]a={8,5,2,4,3,1,7,6};
18        InsertSort(a);
19        for(int i:a)
20            System.out.print(i+" ");
21
22    }
23
24}

直接从插入排序是稳定的排序算法，平均时间复杂度为O(N²),空间复杂度为O(1)