/**
     * 直接插入排序
     * 說的簡單點，就是一組無序序列{A1,A2,........An} 先取出A1，然后從A2與A1比較,比較完之后序列狀況是{A1,A2}{A3..........An}, 
     * 其中{A1,A2}有序， 然后取出A3 ，放到{A1,A2}有序序列合適位置，
     * 導致{A1,A2,A3}{A4........An}。重復這個過程，直到取出An放入{A1,A2........An-1}有序序列中。
     * @param a 要排序的數(shù)組
     */
    public void insertSort(int[] a) {
        int len = a.length;// 數(shù)組的長度，提升效率
        int num;//要插入的數(shù)據(jù)
        for (int i = 1; i < len; i++) {
            num = a[i];
            int k = i - 1;
            //從后向前將大于num的數(shù)據(jù)全部后移
            while (k >= 0 && a[k] > num) {
                a[k + 1] = a[k];
                k--;
            }
            //找到位置后，插入num
            a[k + 1] = num;
        }
    }

    /**
     * 希爾排序
     * 現(xiàn)在有一個array,希爾排序就是設定一個增量incrementNum(0<incrementNum<array.length)。
     * 先從array[0]開始，以incrementNum為增量的進行直接插入排序，直到數(shù)組末尾，然后從array[1]開始重復：以incrementNum為增量的進行直接插入排序; 然后從array[1]開始重復......一直到array[n]。
     * 然后取一個小于上一步增量的新的增量（比如設置為incrementNum/2）,對前一個步驟的結果array進行遍歷，直接插入排序....
     * 再取小于上一步增量的新的增量，重復進行：遍歷，直接插入排序
     * 直到新的增量小于1之后再退出循環(huán)
     * @param a 要排序的數(shù)組
     */
    public void sheelSort(int[] a) {
        int len = a.length;
        int increment = len / 2;
        while (increment >= 1) {
            for (int i = 0; i < len; i++) {
                for (int k = i; k < len - increment; k += increment) {
                    if (a[k] > a[k + increment]) {
                        int temp = a[k + increment];
                        a[k + increment] = a[k];
                        a[k] = temp;
                    }
                }
                increment = increment / 2;
            }
        }
    }

    /**
     * 冒泡排序
     * 冒泡排序，就是每次遍歷都會把最小(或者最大)的數(shù)放在前面。
     * 比如要升序{A1,........An}  第一次排序要取出整個數(shù)組中最小放在A1的位置，
     * 從An開始往前遍歷，相鄰兩個數(shù)比較，如果Aj < Aj-1 則換位,直到比較到A1 這一趟完事之后， A1放的就是整個數(shù)組中最小的數(shù)。
     * 然后從A2位置開始比較，重復上一個步驟，一直比較到A2，這時候A2中放的就是整個數(shù)組中第二個小的數(shù)...........
     *
     * @param a 要排序的數(shù)序，升序排列
     */
    public void bubbleSort(int[] a) {
        int len = a.length;
        for (int i = 0; i < len; i++) {
            for (int m = len - 1; m >= i; m--) {
                if (a[m] < a[m - 1]) {
                    int temp = a[m - 1];
                    a[m] = a[m - 1];
                    a[m - 1] = temp;
                }
            }
        }
    }

    /**
     * 快速排序
     * 基本思想：基于分治的思想，是冒泡排序的改進型。首先在數(shù)組中選擇一個基準點（該基準點的選取可能影響快速排序的效率，后面講解選取的方法），
     * 然后分別從數(shù)組的兩端掃描數(shù)組，設兩個指示標志（lo指向起始位置，hi指向末尾)，首先從后半部分開始，如果發(fā)現(xiàn)有元素比該基準點的值小，就交換lo和hi位置的值，然后從前半部分開始掃秒，
     * 發(fā)現(xiàn)有元素大于基準點的值，就交換lo和hi位置的值，如此往復循環(huán)，直到lo>=hi,然后把基準點的值放到hi這個位置。一次排序就完成了。以后采用遞歸的方式分別對前半部分和后半部分排序，
     * 當前半部分和后半部分均有序時該數(shù)組就自然有序了。
     * @param a 排序數(shù)組
     * @param leftIndex 左邊開始查詢的下標
     * @param rightIndex 右邊開始查詢的下標
     */
     public void quickSort(int[] a, int leftIndex, int rightIndex) {
        int i = leftIndex;//左邊查詢下標
        int j = rightIndex;//右邊查詢下標
        int temp = a[leftIndex];//基準數(shù)值
        if (leftIndex > rightIndex) {
            return;
        }
        while (i < j) {
            //先從右邊向左查詢，找到第一個比temp小的值
            while (a[j] >= temp && i < j) {
                j--;
            }
            //從左邊向右查詢，找到第一個比temp大的值
            while (a[i] <= temp && i < j) {
                i++;
            }
            //滿足條件，則交換兩個位置的值
            if (i < j) {
                int t = a[j];
                a[j] = a[i];
                a[i] = t;
            }
        }
        //交換基準位置的值
        a[leftIndex] = a[i];
        a[i] = temp;
        //左邊再次來一遍查詢排序
        quickSort(a, leftIndex, j - 1);
        //右邊再次來一遍查詢排序
        quickSort(a, j + 1, rightIndex);
    }

/**
     * 選擇排序
     * 每趟找出余下數(shù)組中最小的放在前邊
     *
     * @param a 數(shù)組
     */
    private void selectSort(int[] a) {
        int len = a.length;
        for (int i = 0; i < len; i++) {//循環(huán)次數(shù)
            int num = a[i];
            int position = i;
            //循環(huán)找到最小的值，和下標index
            for (int k = i + 1; k < len; k++) {
                if (a[k] < num) {
                    num = a[k];
                    position = k;
                }
            }
            //交換找到的最小值和當前的位置，放在前邊
            a[position] = a[i];
            a[i] = num;
        }
    }


/**
     * 前提條件：已排序的數(shù)組中查找
     * 首先確定該查找區(qū)間的中間點位置： int mid = (low+upper) / 2；
     * 然后將待查找的值與中間點位置的值比較：若相等，則查找成功并返回此位置。
     * 若中間點位置值大于待查值，則新的查找區(qū)間是中間點位置的左邊區(qū)域。
     * 若中間點位置值小于待查值，則新的查找區(qū)間是中間點位置的右邊區(qū)域。下一次查找是針對新的查找區(qū)間進行的。
     * 遞歸實現(xiàn)二分查找
     * @param a 數(shù)組
     * @param start 開始位置
     * @param end 結束位置
     * @param key 要查找的key
     * @return
     */
    private int binSearch(int[] a, int start, int end, int key) {
        int mid = (end - start) / 2 + start;
        if (a[mid] == key) return mid;
        if (start > end) {
            return -1;
        } else if (key < a[mid]) {
            return binSearch(a, start, mid - 1, key);
        } else if (key > a[mid]) {
            return binSearch(a, mid + 1, end, key);
        }
        return -1;
    }

    /**
     * 普通循環(huán)實現(xiàn)二分查找
     * @param a 數(shù)組
     * @param key 要查找的key
     * @return
     */
    private int binSearch(int[] a, int key) {
        int mid = a.length / 2;
        if (a[mid] == key) {
            return mid;
        }
        int start = 0;
        int end = a.length - 1;
        while (start < end) {
            mid = (end - start) / 2 + start;
            if (key < a[mid]) {
                end = mid - 1;
            } else if (key > a[mid]) {
                start = mid + 1;
            } else {
                return mid;
            }

        }
        return -1;
    }