1．冒泡排序:

相邻的元素两两比较，小的放前面，大的放后面

package sort_learning;

public class demo2 {
    public static void main(String[] args) {
        int []arr={1,2,42,6,43,89};
        int []sortArr=maopao_sort(arr);
        for (int i = 0; i < sortArr.length; i++) {
            System.out.println(sortArr[i]);
        }

    }
    //冒泡排序
    public static int [] maopao_sort(int[]arr){
        for (int i = 0; i < arr.length-1; i++) {
            for (int i1 = 0; i1 < arr.length-i-1; i1++) {
                if(arr[i1]>arr[i1+1]){
                    int temp=arr[i1];
                    arr[i1]=arr[i1+1];
                    arr[i1+1]=temp;
                }
            }
        }
        return arr;
    }
}

2．选择排序:

从0索引开始，拿着每一个索引上的元素跟后面的元素依次比较小的放前面，大的放后面，以此类推

package sort_learning;

public class demo3 {
    public static void main(String[] args) {
        int []arr={1,34,562,34,6,3};
        int []sort_Arr=sort_Fast(arr);
        for (int i = 0; i < sort_Arr.length; i++) {
            System.out.println(sort_Arr[i]);
        }
    }
    //选择排序
    //每次寻找一个最小值放入左边
    public static int [] sort_Fast(int []arr){
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = i+1; j < arr.length ; j++) {
                if(arr[i]>arr[j]){
                    int temp=arr[i];
                    arr[i]=arr[j];
                    arr[j]=temp;
                }
            }
        }
        return arr;
    }
}

3．插入排序:

将数组分为有序和无序两组，遍历无序数据，将元素插入有序序列中即可。

package sort_learning;

public class demo4 {
    public static void main(String[] args) {
        int []arr={5,3,2,6,42,76};
        int []result=insertSort(arr);
        for (int i = 0; i < result.length; i++) {
            System.out.println(result[i]);
        }

    }
    //插入排序 有序和无序 将无序区的值插入有序区
    public static int [] insertSort(int []arr){
        for (int i = 1; i < arr.length; i++) {
            int j=i;
            while (j>0&&arr[j]<arr[j-1]){
                int temp=arr[j];
                arr[j]=arr[j-1];
                arr[j-1]=temp;
                j--;
            }
        }
        return arr;
    }

}

4．快速排序

将排序范围中的第一个数字作为基准数，再定义两个变量start,end，start从前往后找比基准数大的，end从后往前找比基准数小的。找到之后交换start和end指向的元素，并循环这一过程，直到start和end处于同一个位置，该位置是基准数在数组中应存入的位置，再让基准数归位。 归位后的效果:基准数左边的，比基准数小，基准数右边的，比基准数大。

package recursion;

public class demo2 {
    public static void main(String[] args) {
        int []arr={1,7,3,4,24,23,2};
        Fast_sort(arr,0, arr.length-1);
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

    }
    public static void Fast_sort(int []arr,int i, int j){
        int start=i;
        int end=j;
        if(start>end){
            return;
        }
        int basenumber=arr[i];
        while (start!=end){
            while (true){
                if(start>=end||arr[end]<basenumber){
                    break;
                }
                end--;
            }
            while (true){
                if (start>=end||arr[start]>basenumber){
                    break;
                }
                start++;
            }
            int temp=arr[start];
            arr[start]=arr[end];
            arr[end]=temp;
        }
        int temp=arr[i];
        arr[i]=arr[start];
        arr[start]=temp;

        Fast_sort(arr, i, start-1);
        Fast_sort(arr,start+1,j);
    }

}