JAVA冒泡算法和选择算法代码

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);
       
       
    }

   
}