插入排序

插入排序

简单理解

插入排序（英语：Insertion Sort）是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。

算法步骤

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

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

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

图示

复杂度分析

最坏时间复杂度 $O(n^2)$
最优时间复杂度 $O(n)$
平均时间复杂度 $O(n^2)$
空间复杂度 总共 $O(n)$，需要辅助空间 $O(1)$

代码实现

普通版

package SortingBasic.InsertionSort;

/**
 * @ Description: 直接插入排序
 * @ Date: Created in 12:10 2018/7/27
 * @ Author: Anthony_Duan
 */
public class InsertionSort {

    private InsertionSort(){}

    public static void sort(Comparable[] arr){
        int n = arr.length;
        for (int i = 0; i < n; i++) {


            //寻找元素arr[i]合适的插入位置
            //写法1
//            for (int j = i; j > 0; j--) {
//                if (arr[j].compareTo(arr[j - 1]) < 0) {
//                    swap(arr, j, j-1);
//                }else {
//                    break;
//                }
//            }
            //写法2
            for (int j =i; j >0 && arr[j].compareTo(arr[j-1]) < 0 ; j--) {
                swap(arr, j, j-1);
            }
        }

    }

    private static void swap(Object[] arr, int i, int j) {
        Object t = arr[i];
        arr[i] = arr[j];
        arr[j] = t;
    }

    public static void main(String[] args) {
        int N = 20000;
        Integer[] arr = SortTestHelper.generateRandomArray(N, 0, 100000);
        SortTestHelper.testSort("SortingBasic.InsertionSort.InsertionSortAdvance", arr);

        return;
    }
}

优化版

package SortingBasic.InsertionSort;

import SortingBasic.InsertionSort.SortTestHelper;

/**
 * @ Description: 直接插入排序 时间复杂度：O（n^2）
 * @ Date: Created in 12:46 2018/7/27
 * @ Author: Anthony_Duan
 */
public class InsertionSortAdvance {

    // 我们的算法类不允许产生任何实例
    private InsertionSortAdvance(){}

    public static void sort(Comparable[] arr){

        int n = arr.length;
        for (int i = 0; i < n; i++) {

            // 寻找元素arr[i]合适的插入位置

            // 写法1
//            for( int j = i ; j > 0 ; j -- )
//                if( arr[j].compareTo( arr[j-1] ) < 0 )
//                    swap( arr, j , j-1 );
//                else
//                    break;

            // 写法2
//            for( int j = i; j > 0 && arr[j].compareTo(arr[j-1]) < 0 ; j--)
//                swap(arr, j, j-1);

            // 写法3
            Comparable e = arr[i];
            int j = i;
            for( ; j > 0 && arr[j-1].compareTo(e) > 0 ; j--) {
                arr[j] = arr[j-1];
            }
            arr[j] = e;

        }
    }

    private static void swap(Object[] arr, int i, int j) {
        Object t = arr[i];
        arr[i] = arr[j];
        arr[j] = t;
    }

    // 测试InsertionSort
    public static void main(String[] args) {

        int N = 20000;
        Integer[] arr = SortTestHelper.generateRandomArray(N, 0, 100000);
        SortTestHelper.testSort("SortingBasic.InsertionSort.InsertionSortAdvance", arr);

        return;
    }
}