Java排序法(冒泡排序、选择排序、快速排序)

public class Java_SortMethod {
    static int temp;
    public static void main(String[]args) {
        int [] arr1 = new int[] {4,8,7,-6,5,0,2,3,9,1,-8,-9};
        int [] arr2 = new int[] {4,8,7,-6,5,0,2,3,9,1,-8,-9};
        int [] arr3 = new int[] {4,8,7,-6,5,0,2,3,9,1,-8,-9};


        //排序方法一：冒泡排序
        int[] bulle = Bulle(arr1);
        for (int i : bulle) {
            System.out.print(i+" ");
        }
        System.out.println();


        //排序方法二:选择排序
        int[] chose = Chose(arr2);
        for(int i : chose) {
            System.out.print(i+" ");
        }
        System.out.println();


        //排序方法三:快速排序
        int start = 0;
        int end = arr3.length-1;
        int[] fast = Fast(arr3,start,end);
        for (int i : fast) {
            System.out.print(i+" ");
        }
        System.out.println();
    }


    //Bulle Sort (冒泡排序) 原理:相邻两数进行两两比较，若果后一位数大于前一位数，交换位置，否则位置不变
    private static int[] Bulle(int[] arr) {
        //外层控制排序的轮数
        for(int i = 0 ; i < arr.length-1;i++) {
            //内层控制需要排序的数
            for(int j = 0 ; j < arr.length-1-i;j++) {
                if(arr[j]>arr[j+1]) {
                    temp=arr[j+1];
                    arr[j+1]=arr[j];
                    arr[j]=temp;
                }
            }
        }
        return arr;
    }


    //Chose Sort(选择排序) 原理:依次从每轮数据中找出最小值放在靠前的位置
    private static int[] Chose(int[] arr) {
        //选择排序的优化
        for(int i = 0; i < arr.length - 1; i++) {// 做第i趟排序
            int k = i;//此处如果第一位值为最小值，下面循环以及替换无效
            for(int j = k + 1; j < arr.length; j++){// 选最小的记录
                if(arr[j] < arr[k]){
                    k = j; //记下目前找到的最小值所在的位置
                }
            }
            //在内层循环结束，也就是找到本轮循环小于下标为i的数以后，再进行交换
            if(i != k){ //交换a[i]和a[k]位置
                int temp = arr[i];
                arr[i] = arr[k];
                arr[k] = temp;
            }
        }


        return arr;
    }


    //Fast Sort(快速排序) 原理:每次将第一个值作为默认的中间值，将数组拆分为三个子数组，小于中间值的为第//一个子数组，中间值为第二个子数组，大于中间值的为第三个子数组，以此为顺序递归进行排序，快速排序//是所有排序中，效率较高的排序法
    private static int[] Fast(int[]arr,int start,int end) {
//循环的条件
        if(start<end) {
//将第一个值作为默认的中间值
            int i = start; int j = end; int temp = arr[start];
            while(i<j) {
//此处作用为filter，筛选出来的值就是大于等于中间值的
                while(i < j && arr[j] >= temp) {
                    j--;
                }
                if(i<j) {//此处的作用就是替换，将大于等于temp的值，替换到temp后一位，依次类推
                    arr[i++]=arr[j];
                }
//此处作用也是为filter，筛选出来的值就是小于中间值的
                while(i < j && arr[i]<temp) {
                    i++;
                }
                if(i < j) {
                    arr[j--]=arr[i];
                }
            }

            arr[j]=temp;

            Fast(arr,start,i-1);
            Fast(arr,i+1,end);
        }
        return arr;
    }
}