java排序，冒泡排序，选择排序，插入排序，快排

冒泡排序

时间复杂度：O(n^2)  空间复杂度O(1)

稳定性：稳定

1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

    private static void bubbleSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; ++i) {
            boolean swap = false;//利用标记，检测是否进行过交换
            for (int j = 0; j < arr.length - 1 - i; ++j) {
                if (arr[j] > arr[j + 1]) {
                    swap = true;
                    int tmp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = tmp;
                }
            }
            if (!swap) { //如果swap认为false，没有发生过交换，数组有序，结束程序
                return;
            }
        }
    }

优化后的冒泡排序，避免了数组有序后无用的比较。

选择排序

首先在未排序序列中找到最大元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最大元素，然后放到已排序序列的末尾。
以此类推，直到所有元素均排序完毕。

1. 从未排序序列中，找到关键字最大的元素
2. 如果最大元素不是未排序序列的第一个元素，将其和未排序序列第一个元素互换
3. 重复1、2步，直到排序结束。

稳定性：不稳定
时间复杂度O(n^2)  空间复杂度O(1)

    public static void choiceSort(int[]arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            int k=i;int temp;
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[j] <arr[k]) {
                    k=j;
                }
            }
            if (k != i) {
                temp = arr[i];
                arr[i] = arr[k];
                arr[k] = temp;
            }
        }
    }

插入排序

直接插入排序

在一组基本有序的序列中，进行排序操作，插入排序效率是最高的

时间复杂度：O(n^2)   空间复杂度：  O(1)

稳定性：稳定

从数组下标1开始进行遍历；跟前一项进行对比，如果小于前一项，退出本次循环，进行下一次循环。
如果大于前一项，将前一项后移一位，继续跟前一项对比，直到小于前一项，退出本次循环，将空缺的位置补上。

    public static void insertSort(int[]arr) {
        for (int i = 1; i < arr.length; i++) {
            int val = arr[i];
            int j = i - 1;
            for (; j >= 0; --j) {
                if (val < arr[j]) {
                    arr[j + 1] = arr[j];
                } else break;
            }
            arr[j + 1] = val;
        }
    }

改进插入排序

利用二分查找法 寻找一个合适的插入位置，可以减少比较过程，提高效率

    public static void insertSort(int []arr) {
        for (int i = 1; i < arr.length; i++) {
            int temp = arr[i];
            int j = i;
            //二分查找寻找合适的插入位置
            int first = 0;
            int last = j-1;
            while (first <=last) {
                int middle = (first + last) / 2;
                if (arr[j] < arr[middle]) {
                    last = middle - 1;
                } else if (arr[j] > arr[middle]) {
                    first = middle + 1;
                }
            }
            while (j>first){
                arr[j]=arr[j-1];
                j--;
            }
            arr[first] = temp;
        }
    }

快排

稳定性 ：不稳定

时间复杂度：O(log2 n） 最差情况：O（n^2）

快排的优化措施：

1.当数据范围小到一定程度时，采用插入排序代替快排

2.选择合适的基准数字（随机数法）（三数取中）

快速排序的基本思想：挖坑填数+分治法。
快速排序使用分治策略来把一个序列分为两个子序列。

1. 从数列中挑出一个元素，称为"基准"。
2. 重新排序数列，所有比基准值小的元素摆放在基准前面，所有比基准值大的元素摆在基准后面（相同的数可以到任一边）。在这个分区结束之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。
3. 递归地把小于基准值元素的子数列和大于基准值元素的子数列排序。

   public static void quickSort(int[]arr,int i,int j){

        if(i>j)
            return;
        int l=partation(arr,i,j);
        quickSort(arr,i,l-1);
        quickSort(arr,l+1,j);
    }
    private static int partation(int[] arr, int i, int j) {
        int temp=arr[i];
        while (i<j){
            while (i<j&&arr[j]>temp) {
                j--;
            }
                //从j开始找第一个小于temp的值
                if (i<j) {
                    arr[i]= arr[j];
                    i++;
                }
            while (i<j&&arr[i]<temp) {
                i++;
            }
            //从i+1号元素找比temp大的值
                if (i<j) {
                    arr[j] = arr[i];
                    j--;
                }
        }
        arr[i]=temp;
        return i;
    }