插入排序以及分析（JAVA）

插入排序

• 對於少量元素的排序，插入排序是一個有效的算法

插入排序的基本思想：
是將一個記錄插入到已經排好序的有序表中，從而一個新的、記錄數增1的有序表
附代碼(用了單例模式，因爲這個類是爲了算法算法性能的內部分析的程序做的)
代碼分析了移動和比較次數

時間複雜度：

這個算法如果不在內部統計比較和移動的次數，當待排序數組是有序時，是最優的情況，
只需當前數跟前一個數比較一下就可以了，這時一共需要比較N- 1次，時間複雜度爲 O[N]     
但是由於我們要在內部計數，實際上得到的時間複雜度還是O[N],但是比較的次數不再是N-1次了，而是2N-1次，
但是實際應用中，是N-1次            
此處我們記錄的是實際應用中的移動次數          
此算法最壞的情況是待排序數組是逆序的，此時需要比較次數最多，總次數記爲：1+2+3+…+N-1=(N^2-N)/2，
所以，插入排序最壞情況下的時間複雜度爲 O[N^2]        

空間複雜度：

O(1)

穩定性分析：

如果待排序的序列中存在兩個或兩個以上具有相同關鍵詞的數據，排序後這些數據的相對次序保持不變，即它們的位置保持不變，則該算法是穩定的；
如果排序後，數據的相對次序發生了變化，則該算法是不穩定的。關鍵詞相同的數據元素將保持原有位置不變，所以該算法是穩定的
插入排序是穩定的算法
代碼:
使用了單例模式，方便在程序內部比較不同算法的移動/比較次數，不需要的刪掉就可以
代碼中in_order（List list, boolean flag）方法中的list爲一個ArryList，flag=true的時候按正序排列，flag=false的時候逆序排列

public  class Insert_sort {
    public static Insert_sort insert_sort;
    private Insert_sort(){}
    private int com_step;
    private int move_step;

    public List<Integer> in_order(List<Integer> list,boolean flag){//flag=true按正序排序 flag=false按逆序排序
        com_step=0;
        move_step=0;
        Integer[] nums=list.toArray(new Integer[0]);//將列表list轉爲Integer對象數組
        int i,j;
        for( i=1;i<list.size();i++) {//從數組下標爲1的位置開始循環
            int temp = nums[i];//輔助變量
            if (flag==true) {
                for (j = i; j > 0; j--) {//從外層循環開始的位置開始，對當前位置的前一個點的數據和輔助變量（外層循環確定的位置）做比較，
                    // 如果當前位置的前一個位置的數據比輔助結點的大，那麼將當前結點的位置和其前一個結點的位置交換
                    //若交換，比較步數+1，移動步數+1；若不交換，比較步數+1
                    if (nums[j - 1] > temp) {
                        nums[j] = nums[j - 1];
                        com_step++;
                        move_step++;
                    } else {
                        com_step++;
                        break;
                    }
                }
                if (nums[j] == temp) {
                    continue;
                } else {
                    nums[j] = temp;
                    move_step++;
                }
            }
            else{
                for(i=0;i<list.size();i++){
                    temp=nums[i];
                    for(j=i;j>0;j--){
                        if(nums[j-1]<temp) {
                            nums[j] = nums[j - 1];
                            com_step++;
                            move_step++;
                        }
                        else{
                            com_step++;
                            break;
                        }

                    }
                    if(nums[j]==temp){
                        continue;
                    }
                    else{
                        nums[j]=temp;
                        move_step++;
                    }
                }
            }
        }
        list=new ArrayList<>(Arrays.asList(nums));
        return list;
    }
    public int getCom_step() {
        return com_step;
    }
    public int getMove_step() {
        return move_step;
    }

    public static Insert_sort getInsert_sort(){
        if(insert_sort==null){
            synchronized (Insert_sort.class){
                if(insert_sort==null){
                    insert_sort=new Insert_sort();
                }
            }
        }
        return insert_sort;
    }
}

參考：
常用算法比較與分析