排序算法总结

1 插入排序

插入排序一定进行n趟（=n）,整个过程就是把数组arr[n]中带排序的n个元素看成一个有序表和无需表，开始时有序表中只包含一个元素arr[0]，无序表中包含n-1个元素arr[1]~arr[n-1],排序过程中每次从无序表中退出第一个元素，把他插入有序表中的适当位置，使之成为新的有序表，这样经过n-1次插入后，无序表就变为空表，有序表中就包含了全部n个元素，至此排序完毕。

核心思想：n-1个无序元素所以共n-1趟插入排序，第 i 趟插入排序的有序元素为i-1，从后往前比较

public static int[] insertSort(int[]arr){
        if(arr == null || arr.length < 2){
            return arr;
        }
        //i=1是无序表的元素起始位置，也是插入比较的趟数
        //第一个循环遍历次数共n-1次，
        for(int i=1;i<arr.length;i++){
            //第二个循环是从后往前和有序表中的所有元素进行比较
            // 第二个循环遍历次数为有序表元素的个数，arr[0]...arr[j-1]
            for(int j=i;j>0;j--){
                if(arr[j]<arr[j-1]){
                    int temp=arr[j];
                    arr[j]=arr[j-1];
                    arr[j-1]=temp;
                }else{
                    break;
                }
            }
        }
        return arr;
    }

2 冒泡排序

冒泡排序最多进行n-1趟（<=n），每趟冒出一个最大值在尾部

public static int[] bubbleSort(int [] arr){
        if (arr==null||arr.length<2)return arr;
        int exchange;
        //n个元素只需要冒泡n-1趟
        for (int i=0;i<arr.length-1;i++){
            exchange=0;
            //每趟都是角标0开始从前往后比较，逆序就交换位置
            for (int j=0;j<arr.length-i-1;j++){
                if (arr[j]>arr[j+1])
                {
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                    exchange=1;
                }
            }
            //如果没有交换，说明排序完成，直接退出排序
            if (exchange==0)return arr;
        }
        return arr;
    }

3选择排序

一定进行n趟（=n）,每一趟选出一个最小值，放在有序表的末尾，一共n-1趟

public static int[] SelectSort(int [] arr){
        if (arr==null||arr.length<2)return arr;
        int min;
        //n个元素只需要冒泡n-1趟
        for (int i=0;i<arr.length-1;i++){
            //假设每趟的初始最小值就是每趟的起始位置
            min=i;
            //从初始位置的下一个元素开始比较，直到末尾
            for (int j=i+1;j<arr.length;j++){
                if (arr[min]>arr[j])min=j;
            }
            //如果最小值不是初始值，就交换，初始值的话根本不需要交换
            if (min!=i){
                int temp=arr[min];
                arr[min]=arr[i];
                arr[i]=temp;
            }
        }
        return arr;
    }

4 快速排序

思想：以第一个元素为基准元素，然后从左向右一趟扫描。凡是比基准小的都交换到左边，最后对基准在做一次交换，得到划分结果

public static void quickSort(int [] arr,int left,int right){
        if (left<right){
            int pivot=Partition(arr,left,right);
            quickSort(arr,left,pivot-1);
            quickSort(arr,pivot+1,right);
        }
    }

    private static int Partition(int[] arr, int left, int right) {
        //pivot是基准元素
        int pivot=arr[left];
        //index用来记录最后一个比基准小的元素的下标
        //举例子：40 21 32 15 50 69 12 75
        // 遍历到12时，index指向50，12和50交换
        //最后遍历结束，40和12交换
        int index=left;
        for (int i=left+1;i<=right;i++){
            if (arr[i]<pivot){
                index++;
                if (i!=index){
                    int temp=arr[i];
                    arr[i]=arr[index];
                    arr[index]=temp;
                }
            }
        }
        //基准元素 和 最后一个<基准的元素 交换
        arr[left]=arr[index];
        arr[index]=pivot;
        return index;
    }