经典排序算法[1]-快排

经典排序算法[1]-快排

1、荷兰国旗问题

  荷兰国旗问题又称为三边界问题，先来看看数据分区问题：假设有一个数组arr，给定一个数，将数组中小于该数和大于该数的数据各放在数组的两边

  算法流程：

假设数组[5,3,7,5,3,4,1] 给定的数是3

• 假设数组最后会被划分成[小于等于3的区域][大于3的区域]，构造小于等于3的数据区的右边界，初始右边界是-1，扫描数组进行如下比较

     如果 扫描的数据<=给定数据
        当前数据和小于等于3区域的数据右边界的下一个元素交换，并移动边界【也就是边界+1】，意味着小于等于3的数据区变大了
     否则 不做操作    
     
     扫描下一个数据

• 1)、扫描数据5时，5>3 直接扫描下一个
• 2)、扫描3时，3<=3，此时小于等于3的区域右边界是-1，先将右边界+1变成0，再将3和0位置数据交换变成

[3,5,7,5,3,4,1]

• 3)、重复该操作，不断扩充小于等于3的数据边界，最终能达到数据分散在两侧，但是不是有序的

假设需要分为三个区[小于区][等于区][大于区]，其中：小于区的所有元素<等于区的所有元素<大于区的所有元素，解法和上面的相似，算法流程是：

[3,2,4,0,4,6,7] 给定数字是4 //实际情况这个给定数字可以随机从数组选择

• 需要设置小于区的右边界初始值为-1，大于区的左边界初始值为数组的长度，扫描的时候两个边界向中间扩展，以上面的例子为例，起始左边界为-1 右边界为8，只是当数据和右边界交换后，需要重复判断交换后的数

     如果 扫描的数据<给定数据
        当前数据和小于区域的数据右边界的下一个元素交换，并移动边界【也就是边界+1】
        扫描下一个数据
     如果 扫描的数据>给定数据
        当前数据和大于区域的数据左边界的上一个元素交换，并移动边界【也就是边界+1】
        下一次继续扫描比较当前位置的数 //英文当前位置的数为交换回来的数，还未和给定数字比较
     否则
         扫描下一个数据

代码实现：**

public class ThreeBound {

    /**
     * 数据分区，假设有一个数组，给定一个数，将数组中小于该数的的大于该数的数据各放在数组的两边
     * 要求 空间复杂度O(1) 时间复杂度 O(N)
     *
     * 假设数组[5,3,7,5,3,4,1] 给定的数是3
     *
     * 1、构造小于等于3的数据边界，初始边界是-1，扫描数组进行如下比较
     *       如果扫描的数据<=给定数据
     *       当前数据和小于等于3的数据边界的下一个元素交换，并移动边界【也就是边界+1】
     *       扫描下一个数据
     *
     *  1、扫描数据5时，5>3 直接扫描下一个
     *  2、扫描3时，3<=3，此时小于等于3的区域边界是-1，所以3需要和0位置数据交换变成
     *     [3,5,7,5,3,4,1]
     *  3、重复该操作，不断扩充小于等于3的数据边界，最终能达到数据分散在两侧，但是不是有序的
     *
     *
     * 假设需要分为三个区，大于 等于 小于
     * 则需要设置小于的边界初始值为-1，大于区的初始边界为数组的长度，扫描的时候边界向中间扩展，只是当数据和右边界交换后，需要重复判断交换后的数
     * 例如
     * [3,2,4,0,4,6,7] 给定数字是4
     *
     * 起始左边界为-1 右边界为8
     * 扫描到6时，需要和7交换，交换后为[3,2,4,0,4,7,6]，由于7原来在6后面，未被扫描，所以扫描指针等从现在的7位置开始扫描才能保证不漏数据
     *
     *
     */

    //实现三边界问题，荷兰国旗问题
    //以数组最后一个元素划分
    public  static  int[] ThreeBound(int[] data,int L,int R){

        if(L > R){
            return new int[]{-1,-1};
        }

        if(L == R){
            return new int[]{L,R};
        }


        int less = L-1;
        int more = R; //先固定最后一个元素，扫描后将其和大于区的边界交换即可
        int index = L;

        while(index<more){
            if(data[index] == data[R]){
                index++;
            }else if(data[index]<data[R]){
                swap(data,index++,++less);
            }else{
                swap(data,index,--more);
            }
        }

        swap(data,more,R); //
        return new int[]{less+1,more};
    }

    private static void swap(int[] data, int index, int i) {

        if(i==index){
            return;
        }else {
            data[index] = data[index] ^ data[i];
            data[i] = data[index] ^ data[i];
            data[index] = data[index] ^ data[i];
        }
    }

}

2、 快排

  快排的整体思想和荷兰国旗是一样的，整体的思路如下：

    /**
     * 快排的思想
     *
     *
     * 借用的是三边界问题，假设现在有一个数组，我们以数组最后一个元素进行边界划分
     * 得到的是
     * [小于区][等于区][大于区][末尾元素]
     * 再将末尾元素和大于区的第一个元素交换，得到
     * [小于区域][等于区][末尾元素][大于区]
     * 
     * 可以看到入如果将原数组进行排序，等于区在排好序数组的位置就是这样，所以可以递归小于区和大于区就可以完成排序
     *
     * 优化点：
     * 有可能出现的数组是7654321这种逆序数组，如果都拿最后一个元素，最后的时间复杂度是O(N^2)，所以递归的时候先随机选择一个元素
     * 和末尾交换，再调用三边界问题得到边界，再递归，转化成等概率问题，时间复杂度就是O(NlogN)
     *
     */

  代码实现：

public class QuickSort {


    //实现三边界问题，荷兰国旗问题
    //以数组最后一个元素划分
    public  static  int[] ThreeBound(int[] data,int L,int R){

        if(L > R){
            return new int[]{-1,-1};
        }

        if(L == R){
            return new int[]{L,R};
        }


        int less = L-1;
        int more = R; //先固定最后一个元素，扫描后将其和大于区的边界交换即可
        int index = L;

        while(index<more){
            if(data[index] == data[R]){
                index++;
            }else if(data[index]<data[R]){
                swap(data,index++,++less);
            }else{
                swap(data,index,--more);
            }
        }

        swap(data,more,R); //
        return new int[]{less+1,more};
    }

    private static void swap(int[] data, int index, int i) {

        if(i==index){
            return;
        }else {
            data[index] = data[index] ^ data[i];
            data[i] = data[index] ^ data[i];
            data[index] = data[index] ^ data[i];
        }
    }

    public static void quickSort(int[] data,int L,int R){

        if(L>=R){
            return;
        }

        int length = R-L+1;

        int index = new Random().nextInt(length);
        swap(data,L+index,R);
        int[] tmpResult = ThreeBound(data, L, R);

        quickSort(data,L,tmpResult[0]-1);
        quickSort(data,tmpResult[1]+1,R);


    }


    public static void main(String[] args) {

        int[] data = {5, 4, 3, 2, 1, 2, 3, 4, 5, 3};

//        process(data,0,data.length-1);

//        int[] res = ThreeBound(data, 0, data.length - 1);

//        System.out.println(Arrays.toString(res));

        quickSort(data,0,data.length-1);

        System.out.println("-----------------------------------");

        System.out.println(Arrays.toString(data));

    }


}