import java.time.LocalDateTime;
import java.util.Arrays;
import java.util.Random;

/**
 * @desc 插入排序
 * 思路分析：
 *  （1）把n個待排序的元素看成為一個有序表和一個無序表，開始時有序表只包含一個元素，無序表中含有n-1個元素
 *  （2）排序過程中每次從無序表中取出第一個元素，把它的排序碼依次與有序的排序碼進行比較，將它插入到有序表中的適當位置，
 *      使之成為新的有序節點
 * 例項：
 *  {101, 34, 119, 1}
 */
public class InsertSort {
    public static void main(String[] args) {
        int arr[] = {34, 101, 119, 1};
        /*int[] arr = new int[160000];
        for (int i = 0; i < 160000; i++) {
            arr[i] = new Random().nextInt(8000000);
        }*/
        System.out.println(LocalDateTime.now());
        insert_sort2(arr);
        System.out.println(LocalDateTime.now());
    }

    /**
     * 升級版
     * @param arr
     */
    private static void insert_sort2(int[] arr) {
        // 第i輪
        // （1）找到待插入的位置
        // （2）後移（從插入位置向陣列末端後移，直到條件不成立）
        // （3）替換（將新值插入找到的位置）
        for (int i = 1; i < arr.length; i++) {
            int insertIndex = i - 1; // 該位置前一個位置
            int insertVal = arr[i]; // 待插入的值

            // （2）後移（從插入位置依次位移，條件：插入值<當前值（初始為插入值的前一個位置!!!）&& 插入位置 >= 0）
            while (insertIndex >= 0 && insertVal < arr[insertIndex]) { // arr[insertIndex]表示插入位置的前一個值
                // 以2為例，[3,10][2,1] , insertIndex = 2 -1
                // A.(2 < 10) => 後移 [3,10][10,1] insertIndex=0
                // B.(2 < 3) => 後移 [3,3][10,1] insertIndex=-1
                // C.(insertIndex < 0) => 跳出迴圈
                arr[insertIndex + 1] = arr[insertIndex];
                insertIndex--;
            }
            // （3）替換（將新值插入找到的位置）
            arr[insertIndex + 1] = insertVal; // insertIndex + 1 ，因為跳轉迴圈多減了1
            //System.out.println("第" + i + "輪過後，arr=" + Arrays.toString(arr));
        }
    }

    /**
     * 普通版
     * @param arr
     */
    private static void insert_sort(int[] arr) {
        // 第i輪
        // （1）找到待插入的位置
        // （2）後移（從插入位置向陣列末端後移，直到條件不成立）
        // （3）替換（將新值插入找到的位置）
        for (int i = 1; i < arr.length; i++) {
            int insertIndex = i - 1; // 該位置前一個位置
            int insertVal = arr[i]; // 待插入的值
            for (int j = 0; j < arr.length; j++) {
                if (insertVal < arr[j]) { // （1）找到待插入的位置 j = i - 1，可以用insertIndex替換，優化見insert_sort2
                    // （2）後移（從插入位置依次位移，條件：插入值<當前值（初始為插入值的前一個位置!!!）&& 插入位置 >= 0）
                    while (insertIndex >= 0 && insertVal < arr[insertIndex]) { // arr[insertIndex]表示插入位置的前一個值
                        // 以2為例，[3,10][2,1] , insertIndex = 2 -1
                        // A.(2 < 10) => 後移 [3,10][10,1] insertIndex=0
                        // B.(2 < 3) => 後移 [3,3][10,1] insertIndex=-1
                        // C.(insertIndex < 0) => 跳出迴圈
                        arr[insertIndex + 1] = arr[insertIndex];
                        insertIndex--;
                    }
                    // （3）替換（將新值插入找到的位置）
                    arr[insertIndex + 1] = insertVal; // insertIndex + 1 ，因為跳轉迴圈多減了1
                    break;
                }
            }
            System.out.println("第"+i+"輪過後，arr=" + Arrays.toString(arr));
        }

        /*// 第1輪
        // （1）找到待插入的位置
        // （2）後移（從插入位置向陣列末端後移，直到條件不成立）
        // （3）替換（將新值插入找到的位置）
        int insertIndex = 1 - 1; // 該位置前一個位置
        int insertVal = arr[1]; // 待插入的值
        for (int j = 0; j < arr.length; j++) {
            if (insertVal < arr[j]) { // （1）找到待插入的位置
                // （2）後移（從插入位置依次位移，條件：插入值<當前值（初始為插入值的前一個位置!!!）&& 插入位置 >= 0）
                while (insertIndex >= 0 && insertVal < arr[insertIndex]) { // arr[insertIndex]表示插入位置的前一個值
                    // 以2為例，[3,10][2,1] , insertIndex = 2 -1
                    // A.(2 < 10) => 後移 [3,10][10,1] insertIndex=0
                    // B.(2 < 3) => 後移 [3,3][10,1] insertIndex=-1
                    // C.(insertIndex < 0) => 跳出迴圈
                    arr[insertIndex + 1] = arr[insertIndex];
                    insertIndex--;
                }
                // （3）替換（將新值插入找到的位置）
                arr[insertIndex + 1] = insertVal; // insertIndex + 1 ，因為跳轉迴圈多減了1
                break;
            }
        }
        System.out.println("第"+1+"輪過後，arr=" + Arrays.toString(arr));
        // 第2輪
        insertIndex = 2 - 1; // 該位置前一個位置
        insertVal = arr[2]; // 待插入的值
        for (int j = 0; j < arr.length; j++) {
            if (insertVal < arr[j]) { // （1）找到待插入的位置
                // （2）後移（從插入位置依次位移，條件：插入值<當前值（初始為插入值的前一個位置!!!）&& 插入位置 >= 0）
                while (insertIndex >= 0 && insertVal < arr[insertIndex]) { // arr[insertIndex]表示插入位置的前一個值
                    // 以2為例，[3,10][2,1] , insertIndex = 2 -1
                    // A.(2 < 10) => 後移 [3,10][10,1] insertIndex=0
                    // B.(2 < 3) => 後移 [3,3][10,1] insertIndex=-1
                    // C.(insertIndex < 0) => 跳出迴圈
                    arr[insertIndex + 1] = arr[insertIndex];
                    insertIndex--;
                }
                // （3）替換（將新值插入找到的位置）
                arr[insertIndex + 1] = insertVal; // insertIndex + 1 ，因為跳轉迴圈多減了1
                break;
            }
        }
        System.out.println("第"+2+"輪過後，arr=" + Arrays.toString(arr));
        // 第3輪
        insertIndex = 3 - 1; // 該位置前一個位置
        insertVal = arr[3]; // 待插入的值
        for (int j = 0; j < arr.length; j++) {
            if (insertVal < arr[j]) { // （1）找到待插入的位置
                // （2）後移（從插入位置依次位移，條件：插入值<當前值（初始為插入值的前一個位置!!!）&& 插入位置 >= 0）
                while (insertIndex >= 0 && insertVal < arr[insertIndex]) { // arr[insertIndex]表示插入位置的前一個值
                    // 以2為例，[3,10][2,1] , insertIndex = 2 -1
                    // A.(2 < 10) => 後移 [3,10][10,1] insertIndex=0
                    // B.(2 < 3) => 後移 [3,3][10,1] insertIndex=-1
                    // C.(insertIndex < 0) => 跳出迴圈
                    arr[insertIndex + 1] = arr[insertIndex];
                    insertIndex--;
                }
                // （3）替換（將新值插入找到的位置）
                arr[insertIndex + 1] = insertVal; // insertIndex + 1 ，因為跳轉迴圈多減了1
                break;
            }
        }
        System.out.println("第"+3+"輪過後，arr=" + Arrays.toString(arr));*/
    }

}