五种基础排序方法

选择排序

以升序为例，选择排序就是每次循环中选择一个最小的元素放在开头，第二小次之，以此类推。

    public static void selectSort(int[]arr){
        for(int i = 0;i<arr.length;i++){
            for(int j = i+1;j<arr.length;j++){
                if(arr[j]<arr[i]){
                    int temp = 0;
                    temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
    }
    public static void main(String[] args) {
        int[]arr = {1,5,6,8,7,9,12,3};
        selectSort(arr);
        System.out.println(Arrays.toString(arr));
    }

快速排序

这篇文章写的很好，可以学习一下
快速排序之所以每次要先从右往左，而不是从左往右找，是因为从右往左永远是找小的，就比如
基准数是6，中间有三个数4，3，9，现在左边指向4，右边指向9，如果每次从左开始，找大的，它会直接跳过3，指到9，与6交换，结果就错了，从右往左就不会有这些问题。

    public static void quickSort(int[]arr,int low,int high){
        if(low>=high){
            return;//递归结束条件
        }
        int i = low;
        int j = high;
        int temp = arr[i];
        while (i<j){//i<j很重要，不然就容易交错
            while(arr[j]>=temp&&i<j){
                j--;
            }
            while(arr[i]<=temp&&i<j){
                i++;
            }
            if(i<j){
                int t = arr[i];
                arr[i] = arr[j];
                arr[j] = t;
            }
        }
        arr[low] = arr[i];
        arr[i] = temp;
        quickSort(arr,low,j-1);
        quickSort(arr,i+1,high);
    }
    public static void main(String[] args) {
        int[]arr = {1,5,6,8,7,9,12,3};     
        quickSort(arr,0,arr.length-1);
        System.out.println(Arrays.toString(arr));
    }

归并排序

归并排序主要运用了分治的思想，就是先不断分割，直到这一组数分割到各自独立，再逐层归并。

准确全面的归并

public class 归并排序 {//可以传参时把临时数组也传过去，省的每次递归都要开辟空间
    public static void merge(int[]arr,int left,int mid,int right){//归并
        int[]temp = new int[arr.length];
        int p1 = left;
        int p2 = mid+1;
        int k = left;
        while(p1<=mid&&p2<=right){
            if(arr[p1]<=arr[p2]){
                temp[k++] = arr[p1++];
            }else{
                temp[k++] = arr[p2++];
            }
        }
        while(p1<=mid){//肯定有一个先结束，后面的依次填入就好
            temp[k++] = arr[p1++];
        }
        while(p2<=right){
            temp[k++] = arr[p2++];
        }
        for(int i =left;i<=right;i++){//复制到数组里
            arr[i] = temp[i];
        }
    }
    public static void mergeSort(int[]arr,int left,int right){//分割
        if(left>=right){
            return;
        }else {
            int mid = (left+right)/2;
            mergeSort(arr,left,mid);
            mergeSort(arr,mid+1,right);
            merge(arr,left,mid,right);
        }
    }
    public static void main(String[] args) {
        int[]arr = {12,56,7,8,9,1};
        mergeSort(arr,0,arr.length-1);
        System.out.println(Arrays.toString(arr));
    }
}

希尔排序

希尔排序是一种优化后的直接插入排序

public class ShellSort {
        public static void shellSort(int[] arr){
            for(int gap = arr.length/2;gap>0;gap/=2) {
                for(int i = gap;i<arr.length;i+=gap) {//在当前间隔上排序
                    int temp = arr[i];//要插入的数
                    int j = 0;
                    for(j = i;j>=gap&&temp<arr[j-gap];j-=gap) {//每一次都是一次直接插入排序，注意，这里j>=gap与temp<arr[j-gap]不能互换，否则会报数组越界，放前面&&有短路，前面为假后面就不会看了
                        arr[j] = arr[j-gap];//最大的数往后移一位
                    }
                    arr[j] = temp;
                }
            }
        }
    public static void main(String[] args) {
        int[]arr = new int[]{12,45,36,0,0,55,2,1,78,9};
        shellSort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

冒泡排序

稍微优化了些，设置一个flag，一次循环后判断如果没有交换过，则直接break。

    public static void bubbleSort(int[]arr){
        boolean flag = true;
        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]){
                    int temp =arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                    flag = false;
                }
            }
            if(flag){
                break;
            }
        }
    }
    public static void main(String[] args) {
        int[]arr = {1,59,6,4,11};
        bubbleSort(arr);
        System.out.println(Arrays.toString(arr));
    }