直接插入算法

直接插入排序

1.基本思想

基本思想是，遍历整个数组，每次遍历找出最小的插入到对应的位置，具体的方法是：
存在数组array[n],第一次遍历数组得到最小值与array[0]进行交换，第二次遍历数组得到第二小的值与array[1]交换……
如此下去，最后的结果是以升序排序

例如:给定n=8，数组R中的8个元素的排序码为(8,3,2,1,7,4,6,5),则直接选择排序的过程如下所示
由于百科不方便画出关联箭头 所以用 n – n 表示 ：
初始状态 [ 8 3 2 1 7 4 6 5 ] 8 – 1
第一次 [ 1 3 2 8 7 4 6 5 ] 3 – 2
第二次 [ 1 2 3 8 7 4 6 5 ] 3 – 3
第三次 [ 1 2 3 8 7 4 6 5 ] 8 – 4
第四次 [ 1 2 3 4 7 8 6 5 ] 7 – 5
第五次 [ 1 2 3 4 5 8 6 7 ] 8 – 6
第六次 [ 1 2 3 4 5 6 8 7 ] 8 – 7
第七次 [ 1 2 3 4 5 6 7 8 ] 排序完成

2.代码实现

java:


/**
* Created by samsung on 2017/5/24.
*/
public class InsertSort {
public static void main(String[]args ){
int[] array = {8,3,2,1,7,4,6,5 };
array = sort(array);
}

public static int[] sort(int[] array){
    int minIndex = 0;
    int j = 0;
    for(int i = 0 ; i < array.length -1;i++){
        for( j = i + 1,minIndex = i;j < array.length;j++){
            if(array[minIndex] > array[j]){
                minIndex = j;
            }
        }
        int temp = array[i];
        array[i] = array[minIndex];
        array[minIndex] = temp;
        printArray(array,array[minIndex],array[i]);
    }
    return array;
}

public static void printArray(int[] array,int a ,int b){
    System.out.print("[");
    for (int i = 0 ; i < array.length ;i++){
        if(i == array.length -1){
            System.out.print(array[i]);
        }else{
            System.out.print(array[i] + ",");
        }
    }
    System.out.print("]");
    System.out.println(" " + a + " <----> "+ b);
}

}

3.运行结果




[1,3,2,8,7,4,6,5] 8 <----> 1

[1,2,3,8,7,4,6,5] 3 <----> 2

[1,2,3,8,7,4,6,5] 3 <----> 3

[1,2,3,4,7,8,6,5] 8 <----> 4

[1,2,3,4,5,8,6,7] 7 <----> 5

[1,2,3,4,5,6,8,7] 8 <----> 6

[1,2,3,4,5,6,7,8] 8 <----> 7



复杂度计算

从上面代码可以看出套了两次循环，基本的复杂度,**O(n*n)**，最差的情况：复杂度不变：刚好和你的排序成逆序，时间复杂度为**n**的平方,

第一次循环要做元素交换的次数为n-1，第二次循环要做的次数为n-1,如此推下去要做元素交换的次数为：(n-1) + (n-2) + (n-3) + … + 2 + 1 ,计算下来结果为：C=n(n-1)/2;这个为交换次数次数。最好的情况已排好序，时间复杂度都不会变，因为都会去比较，但是交换次数明显为0。空间复杂度：O(n),在整个交换过程中就只有一个用来存储临时数据，所以空间为O(n+1),也就为O(n).

稳定性

什么是稳定性？在排序算法中，如果数组中有两个想等的数，比如：3，6，8，5，3，5，有5是相等的，在做了排序之后两个5的位置发生了交换，那么就代表这个算法不稳定。那么这个算法稳定吗？可以稳定，也可以为稳定，为什么呢？因为在下面一句中，

if(array[minIndex] > array[j]){
     minIndex = j;
 }

换成

if(array[minIndex] >= array[j]){
     minIndex = j;
 }

就变为不稳定了。