public static int[] selectInsert(int[] n) {

    int minPos,  temp;

    for (int i =  0; i < n.length; i++) {

        minPos =  i;

        //遍歷找出最小數(shù)的位置

        for (int  j = i + 1; j < n.length; j++) {

            if  (n[j] < n[minPos]) {

                 minPos = j;

            }

        }

        //如果最小數(shù)位置不等于當(dāng)前位置指針，就交換位置，即把數(shù)按照從小到大的順序依次排列

        if  (minPos != i) {

             temp  = n[i];

            n[i]  = n[minPos];

             n[minPos] = temp;

        }

    }

    return n;

}

//堆排序

private static int[] heapSort(int[] n) {

    //建立堆，從最后一個(gè)非葉子節(jié)點(diǎn)開始

    for (int i =  (n.length - 2) / 2; i >= 0; i--) {

         adjustHeap(n, i, n.length);

    }

    int temp;

    //完成排序，從最后一個(gè)元素進(jìn)行輸出，每次循環(huán)確定一個(gè)元素的位置

    for (int i =  n.length - 1; i >= 1; i--) {

        temp =  n[0];

        n[0] =  n[i];

        n[i] =  temp;

        // 篩選 R[0] 結(jié)點(diǎn)，得到i個(gè)結(jié)點(diǎn)的堆

         adjustHeap(n, 0, i);

    }

    return n;

}

//調(diào)整堆

public static void adjustHeap(int[] n, int k, int  length) {

    //設(shè)置堆頂?shù)闹?/span>

    int temp =  n[k];

     //從左孩子開始判斷

    for (int i =  k * 2 + 1; i <= length - 1; i = 2 * i + 1) {

        //如果左孩子小于右孩子

        if (i + 1  < length && n[i] < n[i + 1]) {

             //取右孩子

             i++;

        }

        //如果堆頂?shù)闹荡笥谧笥液⒆又械妮^大者，無需調(diào)整

        if (temp  >= n[i]) {

             break;

        } else {

            //否則的話，將左右孩子中的較大者換到雙親節(jié)點(diǎn)

            n[k]  = n[i];

            //然后將k值更新，方便繼續(xù)向下調(diào)整

            k =  i;

        }

    }

    //將原堆頂位置當(dāng)入最后調(diào)整出來的地方

    n[k] = temp;

}

//歸并排序

public static int[] mergeSort(int[] n, int low, int  high) {

    int mid =  (low + high) / 2;

    if (low <  high) {

         mergeSort(n, low, mid);

         mergeSort(n, mid + 1, high);

        merge(n,  low, mid, high);

    }

    return n;

}

//調(diào)整

public static void merge(int[] n, int low, int mid, int  high) {

    int[]  tempArr;

    int i = low,  j = mid + 1, k = 0;

    tempArr =  Arrays.copyOf(n, high - low + 1);

    // 把較小的數(shù)先移到新數(shù)組中

    while (i  <= mid && j <= high) {

        if (n[i]  < n[j]) {

            tempArr[k++] = n[i++];

        } else {

             tempArr[k++] = n[j++];

        }

    }

    // 把左邊剩余的數(shù)移入數(shù)組

    while (i  <= mid) {

         tempArr[k++] = n[i++];

    }

    // 把右邊邊剩余的數(shù)移入數(shù)組

    while (j  <= high) {

         tempArr[k++] = n[j++];

    }

    // 把新數(shù)組中的數(shù)覆蓋nums數(shù)組

     System.arraycopy(tempArr, 0, n, low, tempArr.length);

}

//d表示最大的數(shù)有多少位

public static int[] radixSort(int[] number, int d) {

    //控制鍵值排序依據(jù)在哪一位

    int k = 0,n =  1,m = 1;

    //數(shù)組的第一維表示可能的余數(shù)0-9

    int[][] temp  = new int[10][number.length];

    //數(shù)組orderp[i]用來表示該位是i的數(shù)的個(gè)數(shù)

    int[] order =  new int[10];

    while (m  <= d) {

        for (int  value : number) {

            int  lsd = ((value / n) % 10);

             temp[lsd][order[lsd]] = value;

            order[lsd]++;

        }

        for (int  i = 0; i < 10; i++) {

            if  (order[i] != 0)

                 for (int j = 0; j < order[i]; j++) {

                     number[k] = temp[i][j];

                     k++;

                }

            order[i]  = 0;

        }

        n *= 10;

        k = 0;

        m++;

    }

    return  number;

}