import java.util.Random;
import java.io.Serializable;
import java.lang.Comparable;
import java.util.Comparator;

public class InnerSort {
   
   
    public InnerSort(){
        super();
    }
   
    /*
     * 含義:利用隨機函式，建立一個有10個元素的陣列
     * 輸入: null
     * 輸出：Integer []
     */
    public int [] creatArray(){
        Random ran = new Random();
        int [] array = new int [10];
        for(int i=0;i<10;i++){
            array[i] = ran.nextInt(100) - ran.nextInt(100);
        }
        return array;
    }
   
    /*
     * 含義：標準輸出陣列的所有元素，並且在輸出完
     *         畢最後一個元素後執行換行操作
     * 輸入：Integer []
     * 輸出：null
     */
    public void printArray(int [] array){
        for(int i : array){
            System.out.print(i+"/t");
        }
        System.out.print("/n");
    }
   
    /*
     * 含義：氣泡排序，每次比較相鄰兩個數字是否滿足比較需要，從而決定是
     *         否交換順序，每排序一次就會把最大或者最小的數字放在最右邊的位置
     *
     * 範圍：氣泡排序，隸屬於<交換排序>
     * 輸入：Integer []
     * 輸出：Integer []
     */
    public int [] getMaoPaoSort(int [] array){
        for(int j = array.length ;j>0;j--){
            for(int i=0;i<j-1;i++){
                if(array[i]<array[i+1]){
                    int temp = array[i];
                    array[i] = array[i+1];
                    array[i+1] = temp;
                }
            }
        }
       
        return array;
    }
   
    /*
     * 含義：直接選擇排序，取第一個值與陣列中的每個值均比較一次，從中取出最大或
     *               者最小的一個值，放在陣列的第一個位置，依次迴圈。
     * 範圍：直接選擇排序 隸屬於<選擇排序>
     * 輸入：Integer []
     * 輸出：Integer []
     */
    public int [] getChooseSortWay1(int [] array){
        for(int i=0;i<array.length-1;i++){
            for(int j=i;j<array.length;j++){
                if(array[i] < array[j]){
                    int temp = array[i];
                    array[i] = array[j];
                    array[j] = temp;
                }
            }
        }
        return array;
    }
   
    /*
     * 含義：直接選擇排序，取第一個值與陣列中的每個值均比較一次，從中取出最大或
     *               者最小的一個值，放在陣列的第一個位置，依次迴圈。
     * 範圍：直接選擇排序 隸屬於<選擇排序>
     * 輸入：Integer []
     * 輸出：Integer []
     * 特點：取陣列第一個值一次與後面的值比較，滿足比較要求則取其陣列下標，第一次循
     *         環一遍得到該陣列中最大的一個最大或者最小的陣列值的下標，然後把陣列的最
     *         後一個下標的值與，剛才比較得到的最大或者最小值下標兩個位置交換，然後執
     *         行第二次的迴圈操作，只是這次操作迴圈的長度比上一次減1.
     * [與getChooseSortWay1相比：getChooseSortWay1兩個值相互比較，滿足要求立
     *     刻執行值的交換，而getChooseSortWay2是在迴圈了一遍之後得到下標之後與最後一
     *     個位置的值交換位置：這裡指的最後一個位置是隨著外迴圈i的更改而改變的。從而減少
     *  了陣列值交換的次數，提高效率，從原理上講getChooseSortWay2和getChooseSortWay1
     *  所迴圈的次數是相等的]
     */
    public int [] getChooseSortWay2(int [] array){
        for(int i=1;i<array.length-1;i++){
            int index = 0;
            for(int j = 1;j<array.length - i;j++){
                if(array[j]>array[index]){
                    index = j;
                }
            }
            int temp = array[array.length-i];
            array[array.length-i] = array[index];
            array[index] = temp;
        }
        return array;
    }
   
    public int [] switchArrayValues(int [] array ,int x ,int y){
        int temp = array[x];
        array[x] = array[y];
        array[y] = temp;
        return array;
    }
   
    public String getSubString (String str,int index){
       
        String allStr = str;
        int SplitBytes = index;
        int BytesNum = 0;
        if(allStr.length()%SplitBytes == 0){
            BytesNum = (allStr.length()/SplitBytes);
        }else{
            BytesNum = allStr.length()/SplitBytes+1;
        }
        System.out.println("BytesNum:"+BytesNum);
        for(int i =0;i<= BytesNum;i++){
            if(i == BytesNum){
                str = allStr.substring((i-1)*SplitBytes, allStr.length());
            }else{
                str = allStr.substring((i-1)*SplitBytes, (i*SplitBytes));
            }
        }
       
        return str;
       
    }
   
    /*
     * 主函式
     */
    public static void main(String [] args){
       
        InnerSort in = new InnerSort();
        int [] array =  in.creatArray();
        //排序前陣列：
        in.printArray(array);
        System.out.println(array.length);
       
        //執行排序操作
        array = in.getChooseSortWay2(array);
       
        //排序後陣列
        in.printArray(array);
       
       
    }

   
}