Java常见排序算法之交换排序

public class 交换排序 {

    public static void swap(int[] array, int i, int j){
        int tmp = array[i];
        array[i] = array[j];
        array[j] = tmp;
    }

    /**
     * 冒泡排序：
     * 时间复杂度：0(n^2) 逆序情况下
     * 有序情况下：0(n)
     *
     * 空间复杂度：0(n)
     *
     * 稳定性：稳定
     * @param array
     */
    public static void bubbleSort(int[] array){
        for (int i = 0; i < array.length-1; i++) {
            boolean flg = false;
            for (int j = 0; j < array.length-1; j++) {
                if(array[j] > array[j+1]){
                    swap(array, j, j+1);
                    flg = true;
                }
            }
            if(flg = false){
                break;
            }
        }
    }

    /**
     * 快排：递归
     * 时间复杂度：O(n*logn)
     * 最坏情况下 有序：O(n^2)
     *
     * 空间复杂度：O(logn)
     * 最坏情况下 有序：O(n)
     *
     * 稳定性：不稳定的排序
     *
     * 优化：随机选取基准法  三数取中法   把基准相同的数字移动到基准附近  利用直接插入排序越快越有序
     * @param array
     */
    public static void quickSort1(int[] array){
        quick(array, 0, array.length-1);
    }
    public static void quick(int[] array,int start, int end){
        if(start >= end){
            return;
        }

        if(end-start+1 <= 40){
            //这里使用直接插入排序
            return;
        }
        int midIndex = findMidValIndex(array , start, end);
        swap(array, start, midIndex);
        int pivot = partition(array, start, end);
        quick(array, start, pivot-1);
        quick(array, pivot+1, end);
    }
    public static int partition(int[] array, int left, int right){
        int tmp = array[left];
        while(left < right){
            while(left < right && array[right] >= tmp){
                right--;
            }
            //走到这里说明遇到了比tmp小的array[right]
            array[left] = array[right];
            while(left < right && array[left] <= tmp){
                left++;
            }
            //走到这里说明遇到了比tmp大的array[left]
            array[right] = array[left];
        }
        array[left] = tmp;
        return left;
    }
    //优化三数取中法
    public static int findMidValIndex(int[] array,int start, int end){
        int mid = start + ((end - start)>>>1);
        if(array[start] < array[end]){
            if(array[mid] < array[start]){
                return start;
            }else if(array[mid] > array[end]){
                return end;
            }else{
                return mid;
            }
        }else{
            if(array[mid] < array[end]){
                return end;
            }else if(array[mid] > array[start]){
                return start;
            }else{
                return mid;
            }
        }

    }

    public static void quickSort2(int[] array) {
        Stack<Integer> stack = new Stack<>();
        int left = 0;
        int right = array.length-1;
        int pivot = partition(array, left, right);
        if(pivot > left + 1){
            stack.push(left);
            stack.push(pivot-1);
        }
        if(pivot < right - 1){
            stack.push(pivot+1);
            stack.push(right);
        }

        while(!stack.isEmpty()){
            right = stack.pop();
            left = stack.pop();
            pivot = partition(array, left, right);
            if(pivot > left + 1){
                stack.push(left);
                stack.push(pivot-1);
            }
            if(pivot < right - 1){
                stack.push(pivot+1);
                stack.push(right);
            }
        }
    }
    public static void main(String[] args) {
        int[] array = {2,8,5,9,4,6,0,1};
        quickSort2(array);
        System.out.println(Arrays.toString(array));
    }
}