交换排序

交换排序

冒泡排序

在无序区间，通过相邻数的比较，将最大的数冒泡到无序区间的最后，持续这个过程，直到数组有序

public static void bubbleSort(int[] array){
        for (int i = 0; i < array.length-1; i++) {//i代表趟数
            for (int j = 0; j < array.length-1-i; j++) {
                if (array[j] > array[j+1]){
                    int tmp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = tmp;
                }
            }
        }
    }

冒泡排序的优化：

public static void bubbleSort2(int[] array){//优化
        for (int i = 0; i < array.length-1; i++) {//i代表趟数
            boolean flg = false;
            for (int j = 0; j < array.length-1-i; j++) {
                if (array[j] > array[j+1]){
                    int tmp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = tmp;
                    flg = true;//交换就将flg置为true
                }
            }
            if (flg == false){
                //如果flg为false，则这一趟没有进行排序，数组已经有序，也不用进行之后的排序
                break;
            }
        }
    }

性能分析：

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

快速排序

1. 从待排序区间选择一个数，作为基准值（pivot）
2. Partition：遍历待排序区间，将比基准值小的（可以包含相等的）放到基准值的左边，将比基准值大的放到他的右边
3. 采用分治思想，对左右两个小区间按照同样的方式处理，直到小区间的长度=1，代表已经有序，或者小区间长度=0，代表没有数据

    //找到基准值的位置
    public static int partion(int[] array,int start,int end) {
        int tmp = array[start];
        while (start < end) {
            while (start < end && array[end] >= tmp){
                end--;
            }
            if (start >= end){
                array[start] = tmp;
                break;
            }else {
                array[start] = array[end];
            }
            while (start < end && array[start] <= tmp){
                start++;
            }
            if (start >= end){
                array[start] = tmp;
                break;
            }else {
                array[end] = array[start];
            }
        }
        return start;
    }
    //分别递归基准值的左边和右边
    public static void quick(int[] array,int low,int high){
        if (low >= high) return;
        int par = partion(array,low,high);
        quick(array,low,par-1);
        quick(array,par+1,high);
    }
    public static void quickSort(int[] array){
        quick(array,0,array.length-1);
    }

非递归实现快速排序 模拟栈

public static void quick2(int[] array){
        Stack<Integer> stack = new Stack<>();
        int low = 0;
        int high = array.length-1;
        int par = partion(array,low,high);
        //分别判断左右两边是否有两个元素以上
        //1.左边有两个元素以上
        if (low + 1 < par) {
            stack.push(low);
            stack.push(par - 1);
        }
        //2.右边有两个元素以上
        if (par < high - 1) {
            stack.push(par + 1);
            stack.push(high);
        }
        while (!stack.empty()) {
            high = stack.pop();
            low = stack.pop();
            par = partion(array,low,high);
            if (low + 1 < par) {
                stack.push(low);
                stack.push(par - 1);
            }
            if (par < high - 1) {
                stack.push(par + 1);
                stack.push(high);
            }
        }
    }

优化：

1. 基准值的选择（三数取中）
   满足 array[mid] <= array[start] <= array[end]

public static void medianOfThree(int[] array,int start,int mid,int end){
        //array[mid] <= array[start] <= array[end]
        if (array[mid] > array[start]){
            int tmp = array[mid];
            array[mid] = array[start];
            array[start] = tmp;
        }
        if (array[start] > array[end]){
            int tmp  = array[start];
            array[start] = array[end];
            array[end] = tmp;
        }
        if (array[mid] > array[end]){
            int tmp = array[mid];
            array[mid] = array[end];
            array[end] = tmp;
        }
    }

2.直接插入排序

public static void quick(int[] array,int low,int high){
        if (low >= high) return;
        if (high-low+1 < 100){
            insertSort(array);//100个数以下直接用直接插入排序
        }
        int mid = (low+high)>>>1;//(low+high)/2;
        medianOfThree(array,low,mid,high);//三数取中
        int par = partion(array,low,high);
        quick(array,low,par-1);
        quick(array,par+1,high);
    }

性能分析：

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

给过多有序的数据进行快速排序，容易导致栈溢出