算法一小时-插入排序

在书中，插入排序和选择排序是放在一起介绍的，经过比较发现，其实两种排序的实现思路还是有一些相同的。

1.插入排序实现的思路

插入排序和选择排序实现思路的共同点都是从右边的数组选择出一个元素插入到左边的位置中。不同的是，在选择元素的时候，选择排序会选择右边最小的元素然后插入到左边的最后一位。 而插入排序是选择右边的第一位元素，然后跟左边数组中元素比较，插入到比它小的元素前面。

 

插入排序的实现思路如下所示：

S [O R T E X A M P L E]    S没有比较，直接跳过。

O S[ R T E X A M P L E]    O与S比较，与S交换位置     //一旦比较不符合条件，就结束比较的循环

O R S [T E X A M P L E]    R与S比较，交换位置，R与O比较，不动

O R S T [E X A M P L E]    T与S比较，不动，比较结束

E O R S T [X A M P L E]    E与T比较，交换，E与S比较，交换， E与R比较，交换， E与O比较，

E O R S T X [A M P L E]   X与T比较，不动。

A E O R S T X [M P L E]   A与X比较，交换，A与T比较，交换，A与S比较，交换，A与R比较，交换，A与O比较，交换，A与E比较，交换

A E M O R S T X [P L E]   M与X比较，交换，M与T比较，交换，M与S比较，交换，M与R比较，交换，M与O比较，交换，M与E比较，不动

A E M O P R S T X [L E]   P与X比较，交换，P与T比较，交换，P与S比较，交换，P与R比较，交换，P与O比较，不动

A E L M O P R S T X[ E]   L与x比较，交换，L与T比较，交换，L与S比较，交换，L与R比较，交换，L与O比较，交换，L与M比较，交换，L与E比较，不动

A E E L M O P R S T X []  E与X比较，交换，E与T比较，交换，E与S比较，交换，E与R比较，交换，E与O比较，交换，E与M比较，交换，E与E比较，不动

 指针已经运行到最后，循环结束

 

2.代码实现（Java版本）

按照插入排序的实现思路，代码如下所示：

/**
 * The function for sort.
 * @param a
 */
public static void sort(Comparable<String>[] a) {
    for (int i = 1; i < a.length; i++) {
        for(int j = i; j >0 && less(a[j], a[j-1]); j--) {
          exch(a, j, j-1);
        }
            
        show(a);
    }
}

 

代码的实现上，插入排序更加简洁，也可以看出，插入排序的复杂度和原有数组的顺序有很大关系，对于顺序逆差不大的数组来说， 插入排序是一个很好的选择。

完整的Java代码如下：

package com.jacob.demo;

public class Insertion {
    /**
     * The function for sort.
     * @param a
     */
    public static void sort(Comparable<String>[] a) {
        for (int i = 1; i < a.length; i++) {
            for(int j = i; j >0 && less(a[j], a[j-1]); j--) {
                exch(a, j, j-1);
            }
            
            show(a);
        }
    }
    
    /**
     * Compare if v is less than w.
     * @param v
     * @param w
     * @return
     */
    public static boolean less(Comparable<String> v, Comparable<String> w) {
        return v.compareTo((String) w) < 0;
    }
    
    /**
     * exchange two elements.
     * @param a
     * @param i
     * @param j
     */
    public static void exch(Comparable<String>[] a, int i, int j) {
        Comparable<String> t = a[i];
        a[i] = a[j];
        a[j] = t;
    }
    
    /**
     * Print array.
     * @param a
     */
    private static void show(Comparable<String>[] a) {
        for (int i= 0; i< a.length; i++) {
            System.out.print(a[i] + " ");
        }
        System.out.println();
    }
    
    /**
     * Judge if array is sorted
     * @param a
     * @return
     */
    public static boolean isSorted(Comparable<String>[] a) {
        for (int i = 1; i < a.length; i++) {
            if (less(a[i], a[i-1])) {
                return false;
            }
        }
        
        return true;
    }
    
    public static void main(String[] args) {
        String[] a = {"S","O","R","T","E","X","A","M","P","L","E"};
        System.out.println("Before sort:");
        show(a);
        
        System.out.println("sort begin:");
        sort(a);
        assert isSorted(a);
    }
}

 

3.JS版本代码实现：

 

function insertion(array) {
    for(i = 0; i < array.length; i++) {
        for(j = i; j > 0 && array[j] < array[j-1]; j--) {
            exch(array, j-1, j);
        }
        console.log(array);
    }
}

function exch(array, firstIndex, minIndex) {
    let temp = array[firstIndex];
    array[firstIndex] = array[minIndex];
    array[minIndex] = temp;
}

function main() {
    var arr = [5,3,7,1,7,8,1];
    console.log(arr);
    insertion(arr);
    console.log("after sort");
    console.log(arr);
}

main();