【算法】直接插入排序

2022-06-20 19:03:49 阅读：146 来源： 互联网

插入排序的设计初衷是往有序的数组中快速插入一个新的元素。它的算法思想是：把要排序的数组分为了两个部分，一部分是数组的全部元素(除去待插入的元素)，另一部分是待插入的元素；先将第一部分排序完成，然后再插入这个元素。其中第一部分的排序也是通过再次拆分为两部分来进行的。

插入排序由于操作不尽相同，可分为直接插入排序，折半插入排序(又称二分插入排序)，链表插入排序，希尔排序。我们先来看下直接插入排序。

一、基本思想

直接插入排序的基本思想是：将数组中的所有元素依次跟前面已经排好的元素相比较，如果选择的元素比已排序的元素小，则交换，直到全部元素都比较过为止。

直接插入排序演示

二、算法描述

一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下：

从第一个元素开始，该元素可以认为已经被排序
取出下一个元素，在已经排序的元素序列中从后向前扫描
如果该元素（已排序）大于新元素，将该元素移到下一位置
重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
将新元素插入到该位置后
重复步骤2~5

算法实现中比较有意思的一点是，在每次比较操作发现取出来的新元素小于等于已排序的元素时，可以将已排序的元素移到下一位置，然后将取出来的新元素插入该位置（即相邻位置对调），接着再与前面的已排序的元素进行比较，如上图所示，这样做缺点是交换操作代价比较大。另一种做法是：将新元素取出（挖坑），从左到右依次与已排序的元素比较，如果已排序的元素大于取出的新元素，那么将该元素移动到下一个位置（填坑），接着再与前面的已排序的元素比较，直到找到已排序的元素小于等于新元素的位置，这时再将新元素插入进去。就像基本思想中的动图演示的那样。

如果比较操作的代价比交换操作大的话，可以采用二分查找法来减少比较操作的数目。可以认为是插入排序的一个变种，称为二分查找插入排序。

三、代码实现

/**
 * 插入排序
 * <p>
 * 1. 从第一个元素开始，该元素可以认为已经被排序
 * 2. 取出下一个元素，在已经排序的元素序列中从后向前扫描
 * 3. 如果该元素（已排序）大于新元素，将该元素移到下一位置
 * 4. 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
 * 5. 将新元素插入到该位置后
 * 6. 重复步骤2~5
 *
 * @param arr 待排序数组
 */
public static int[] insertionSort(int[] arr) {
    for (int i = 1; i < arr.length; i++) {
        int temp = arr[i];    // 取出下一个元素，在已经排序的元素序列中从后向前扫描
        for (int j = i; j >= 0; j--) {
            if (j > 0 && arr[j - 1] > temp) {
                arr[j] = arr[j - 1];    // 如果该元素（已排序）大于取出的元素temp，将该元素移到下一位置
                //System.out.println("Temping:  " + Arrays.toString(arr));
            } else {
                // 将新元素插入到该位置后
                arr[j] = temp;
                //System.out.println("Sorting:  " + Arrays.toString(arr));
                break;
            }
        }
    }
    return arr;
}

// 交换次数较多的实现
public static int[] insertionSort2(int[] arr) {
    for (int i = 0; i < arr.length - 1; i++) {
        for (int j = i + 1; j > 0; j--) {
            if (arr[j - 1] <= arr[j])
                break;
            int temp = arr[j];      //交换操作
            arr[j] = arr[j - 1];
            arr[j - 1] = temp;
            //System.out.println("Sorting:  " + Arrays.toString(arr));
        }
    }
    return arr;
}

//遍历显示数组
public static void display(int[] array) {
    for (int i = 0; i < array.length; i++) {
        System.out.print(array[i] + " ");
    }
    System.out.println();
}

public static void main(String[] args) {
    int[] array = {4, 2, 8, 9, 5, 7, 6, 1, 3};
    //未排序数组顺序为
    System.out.println("未排序数组顺序为：");
    display(array);
    System.out.println("-----------------------");
    array = insertionSort2(array);
    System.out.println("-----------------------");
    System.out.println("经过插入排序后的数组顺序为：");
    display(array);
}

性能分析

在第一轮排序中，它最多比较一次，第二轮最多比较两次，一次类推，第N轮，最多比较N-1次。因此有1+2+3+...+N-1 = N*（N-1）/2。

假设在每一轮排序发现插入点时，平均只有全体数据项的一半真的进行了比较，我们除以2得到：N*（N-1）/4。用大O表示法大致需要需要O(N^2^)时间级别。

复制的次数大致等于比较的次数，但是一次复制与一次交换的时间耗时不同，所以相对于随机数据，插入排序比冒泡快一倍，比选择排序略快。

这里需要注意的是，如果要进行逆序排列，那么每次比较和移动都会进行，这时候并不会比冒泡排序快。

直接插入排序复杂度如下：

最好情况下，排序前对象已经按照要求的有序。比较次数(KCN)：\(n−1\)；移动次数(RMN)为0。则对应的时间复杂度为\(O(n)\)。
最坏情况下，排序前对象为要求的顺序的反序。第i趟时第i个对象必须与前面i个对象都做排序码比较，并且每做1次比较就要做1次数据移动（从上面给出的代码中看出）。比较次数(KCN)：\(\sum_{i=1}^{n−1}i= \frac {n(n−1)}2≈ \frac{n^2}2\); 移动次数(RMN)为：\(\sum_{i=1}^{n−1}i= \frac {n(n−1)}2≈ \frac{n^2}2\)。则对应的时间复杂度为\(O(n^2)\)。
如果排序记录是随机的，那么根据概率相同的原则，在平均情况下的排序码比较次数和对象移动次数约为\(\frac{n^2}2\)，因此，直接插入排序的平均时间复杂度为\(O(n^2)\)。

平均时间复杂度	最好情况	最坏情况	空间复杂度
O(n²)	O(n)	O(n²)	O(1)

Tips：由于直接插入排序每次只移动一个元素的位，并不会改变值相同的元素之间的排序，因此它是一种稳定排序xf。

标签：arr,直接,int,插入排序,元素,算法,新元素,排序
来源： https://www.cnblogs.com/ciel717/p/16366138.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

【算法】直接插入排序

一、基本思想

二、算法描述

三、代码实现

性能分析