快速排序-----傻子都看懂了。

快速排序

程序代码

package com.uplooking.bigdata.datastructure;

import java.util.Arrays;

public class QuickSort {

    public static void main(String[] args) {
        int[] arr = {8, -2, 3, 9, 0, 1, 7, 6};
        System.out.println("排序前:" + Arrays.toString(arr));
        quickSort(arr);
        System.out.println("排序后:" + Arrays.toString(arr));
    }

    public static void quickSort(int[] arr) {
        quickSort(arr, 0, arr.length - 1);
    }

    /**
     * 快速排序
     *  是一种分而治之的思想,以某一个基准元素为标准,将集合中比该基准元素小的都放到其左侧,反之放到其右侧。
     *  这样我们就能够找到该基准元素在该集合中所处的位置。
     *  同理,我们就能够找到每一个元素在集合中恰当的位置。
     *  有点类似于二分查找。
     *  一般这个基准元素就是第一个元素。
     *  设置两个指针,一个设置在开头,一个设置末尾,从末尾开始找,找到一个比基本元素小的便停下来,然后
     *  从左侧开始找,直到找到一个比基准元素大的元素,停下来,二者元素进行交换,直到两个指针碰头,本次循环结束
     *  指针指向的位置就是该基准元素在集合中应该所处的位置
     *  eg
     *      {8, -2, 3, 9, 0, 1, 7, 6}
     *  benchmark
     *  第一个bm=8
     *      end = length - 1 = 7
     *      start=0
     *      end--,我们发现6比8小,end指针停下来了,当前索引为j=7
     *      start++,直到元素为9的位置停下来,当前索引i=3
     *      将i和j所对应的元素进行交换
     *    {8, -2, 3, [6], 0, 1, 7, [9]}
     *                i             j
     * 循环继续
     *    end--,到索引为6的位置又停下来了
     *    start++,直到和end碰头都没有再找到比8大的元素,所以我们就能断定,碰头的这个位置就应该是8在该集合中应该在的位置
     *   交换8的索引和碰头的索引
     *   {8, -2, 3, 6, 0, 1, 7, 9}
     *                       i=j=6
     * 交换:{7, -2, 3, 6, 0, 1, 8, 9}
     * 同理,我们可以在8左侧重复上述操作,8的右侧也可以重复上述操作
     * 使用递归调用的方式来完成集合的排序
     * @param arr
     */
    public static void quickSort(int[] arr, int low, int high) {
        if(low > high) {
            return;
        }
        // 默认以[low, high]中的arr[low]作为基准值
        int index = arr[low];
        // 定义左指针
        int start = low;
        // 定义右指针
        int end = high;
        // 开始向基准值扫描,当start < end条件不满足时
        // 说明指针碰头,则需要将基准值与start进行交换
        // 即该基准值在整个元素集合中的位置已经确定
        // 其左边的值比基准值小,其右边的值比基准值大
        while (start < end) {
            // 按照前面算法的设计,先从右边开始扫描,直到找到比基准值小的数再停下来
            // (下面循环的意义就是,在start < end的前提下,如果end位置的值比index值大或等于,就继续往左边找)
            while (start < end && arr[end] >= index) {
                end--;
            }
            // 财从左边开始扫描,直到找到比基准值大的数再停下来
            // (下面循环的意义就是,在start < end的前提下,如果start位置的值比index值小或等于,就继续往右边找)
            while (start < end && arr[start] <= index) {
                start++;
            }
            if (start < end) {
                // 前面的循环结束后,如果start还是小于end
                // 那么就交换arr[start]和arr[end]的值
                swap(arr, start, end);
            }
        }
        // 上面的循环结束后,start指针和end指针碰头,交换arr[start]和基准值
        arr[low] = arr[start];
        arr[start] = index;
        // 交换后,arr[start]左边比它小,右边比它大,然后再以它为基准
        // 左边和右边进行相同的操作
        quickSort(arr, low, start - 1);
        quickSort(arr, start + 1, high);
    }

    /**
     * 位操作
     * 按位与(&)
     * 1&1=1
     * 1&0=0
     * 0&1=0
     * 0&0=0
     * 异或(^)
     * (值不同)就取真(1),否则为(0)
     * 1&1=0
     * 1&0=1
     * 0&1=1
     * 0&0=0
     * 非
     *
     * @param arr
     * @param i
     * @param j
     */
    private static void swap(int[] arr, int i, int j) {
        /*int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;*/
        arr[i] = arr[i] ^ arr[j];
        arr[j] = arr[i] ^ arr[j];
        arr[i] = arr[i] ^ arr[j];
    }

}

/*
交换a=3和b=5,不用第三方变量,效率最高
    方法一:
        a = a + b = 8
        b = a - b = (8 - 5) = 3
        a = a - b = (8 - 3) = 5
异或的方式
    a=3-->低8为0000 0011
    b=5-->低8为0000 0101

    a = a ^ b
         0000 0011
       ^ 0000 0101
       ---------------
         0000 0110 --->6
    b = a ^ b
         0000 0110
       ^ 0000 0101
       --------------
         0000 0011--->3
    a = a ^ b
         0000 0110
       ^ 0000 0011
      ---------------
         0000 0101--->5
*/

测试

执行结果如下:

排序前:[8, -2, 3, 9, 0, 1, 7, 6]
排序后:[-2, 0, 1, 3, 6, 7, 8, 9]

时间复杂度分析

1.在最快及平均情况下,时间复杂度为O(nlog2n)。
最坏情况就是每次挑中的中间值不是最大就是最小,其时间复杂度为O(n^2)。
说明:
平均的时间复杂度记住就好了。
但是最坏的情况确实是可以算出来的,
假设每次选的基准值都是最大的,那么对于end的操作,一开始就找到比index值小的数,
而对于start的操作,则要一直循环n-1次才能让循环停下来。

交换一次index值后,选择的基准值又是最大的,那么start的操作就是n-2次......

以此类推,直到排序完成,1 + 2 + ... + n - 1,所以数量级为n^2,这意味着,数据如果是倒序的,使用上面的实现,那么此时的时间复杂度就为O(n^2).

2.快速排序法不是稳定排序法。
可以考虑,当基准值index与arr[start]值进行交换时,假设arr[start - 1] == index时,那么可以看到,其确实是不稳定的。

3.快速排序法是平均运行时间最快的排序法。
阅读更多
换一批

没有更多推荐了,返回首页