java实现数组排序（可以从小到大排，也可以从大到小排）

本文有两个类一个自定义排序工具类和一个测试类
其中冒泡排序和选择排序的方法中还有一个boolean类型的参数
传入true返回的数组则是从小到大排，传入flase则是从大到小排的

public class MySort {
    /* 自定义排序工具类 */

    /**
    冒泡排序传入true从小到大排
          传入flase从大到小排
    */
    public static int[] bubbleSort(int[] array,boolean b){
        int temp;
        if (b==true){//从小到大排
            for (int i = 0; i < array.length-1; i++) {
                for (int j=0;j< array.length-i-1;j++){
                    if(array[j]>array[j+1]){
                        temp=array[j+1];
                        array[j+1]=array[j];
                        array[j]=temp;
                    }
                }
            }
        }else {//从大到小排
            for (int i = 0; i < array.length-1; i++) {
                for (int j=0;j< array.length-i-1;j++){
                    if(array[j]<array[j+1]){
                        temp=array[j+1];
                        array[j+1]=array[j];
                        array[j]=temp;
                    }
                }
            }
        }
        return array;
    }

    /**
    选择排序传入true从小到大排
     传入flase从大到小排
    */
    public static int[] selectionSort(int[] array, boolean b){
        int temp;  //临时变量
        int minindex;
        int maxindex;
        if (b==true){//从小到大排
            for (int i = 0; i < array.length-1; i++){
                minindex=i;
                for (int j=i+1;j< array.length;j++){
                    if (array[minindex]>array[j]){
                        minindex=j;
                    }
                }
                temp=array[i];
                array[i]=array[minindex];
                array[minindex]=temp;
            }
        }else {//从大到小排
            for (int i = 0; i < array.length-1; i++){
                maxindex=i;
                for (int j=i+1;j< array.length;j++){
                    if (array[maxindex]<array[j]){
                        maxindex=j;
                    }
                }
                temp=array[i];
                array[i]=array[maxindex];
                array[maxindex]=temp;
            }
        }
        return array;
    }

    /**
     插入排序
     */
    public static int[] insertionSort(int[] array){
        int insert; //插入的数
        for (int i = 1; i < array.length; i++){
            insert=array[i];
            int insertindex=i-1;  //应该插入的位置
            for (int j=0;j<i;j++){
                if (insert<array[insertindex]){
                    array[insertindex+1]=array[insertindex];
                    if (insertindex==0){
                        break;
                    }
                    insertindex--;
                }else {
                    insertindex++;
                    array[insertindex]=insert;
                    break;
                }
            }
           array[insertindex]=insert;
        }
        return array;
    }
}

测试类

public class Test {
    public static void main(String[] args) {
        int []a={51, 11, 15, 2, 36, 7, 59, 6,64,33};
        //MySort.bubbleSort(a,false);  //冒泡排序
        //MySort.selectionSort(a,false);   //选择排序
        //MySort.insertionSort(a);     //插入排序
        //System.out.println(Arrays.toString(a));
    }
}

本文只涉及了冒泡排序，选择排序，插入排序，其他几种排序会在今后补充。