奇妙能力倩

最怕你一生碌碌无为 还安慰自己平凡可贵

快速排序( ̄o ̄) . z Z

前言

每件事的最后都会是好事 如果不是好事 说明还没到最后

经典快排

经典快排的思想其实就是:选择一个基准数,将大于这个基准数的数放在基准数的右边,小于等于的放在左边。然后再分别在这两个区域中选择基准数,再将这两个区域分别分为大于和小于等于两个区域,直到最后排好序。

  1. 首先我们将数组中的第一个数设为temp,也就是我们的基准数。将数组最后一个数设为j。
  2. 从j开始,一个个依次向前查找,找到第一个小于temp的数,停止。如图,第一个数3就小于基准数4,所以此时停下。
  3. 接着从第一个数依次向后查找,即图中的i。当找到第一个大于temp的数后,停下。
  4. 将i和j的数进行交换。
  5. 继续从j开始查找下一个小于temp的数。重复上面的 2 3 4。
  6. 当i和j相遇后,结束这次遍历。将i和temp进行交换后结束。
    这里写图片描述
    这样,我们一次操作就完成了。接下来,在进行递归,依次对两个区域进行上面的操作。最后整个数组将有序。

Code

 public void quicksort (int[] s,int left,int right){
        if (left>right){
            return;
        }
        int i = left;
        int j = right;
        int temp = s[left];
        while (i!=j){
            while (i<j&&s[j] >= temp) j--;
            while (i<j&&s[i] <= temp ) i++;
            if (i<j){
                int t = s[j];
                s[j] = s[i];
                s[i] = t;
            }
        }
        s[left] = s[i];
        s[i] = temp;
        System.out.println();
        quicksort(s,left,i-1);
        quicksort(s,i+1,right);
    }

改进后的快排

荷兰国旗问题

首先看一下经典的荷兰国旗问题。

现有红白蓝三个不同颜色的小球,乱序排列在一起,请重新排列这些小球,使得红白蓝三色的同颜色的球在一起。这个问题之所以叫荷兰国旗,是因为我们可以将红白蓝三色小球想象成条状物,有序排列后正好组成荷兰国旗。

将红白蓝三种颜色的球分别用0,1,2代替,我们就可以将这个问题视为一个数组排序问题。

解法一

遍历整个数组,记录下0,1,2的个数,再依次输出。

解法二

首先我们看另外一个题目

给定一个数组arr,和一个数num,请把小于num的数放在数组的 左边,等于num的数放在数组的中间,大于num的数放在数组的右边。

聪明的宝宝一定发现了,其实我们的荷兰国旗问题就是其中的Num=0的时候。那么,我们要怎么去做呢?

  1. 让cur指向数组的最左边,然后将less指向数组的最左边-1,more为最右边+1。(最左边-less的区域为小于区,more-最右边为大于区,所以一开始这两个区域都为0)
  2. 将cur和num进行比较,当大于num的时候就将more-1并与cur指向的数交换。小于num的时候就将less+1并与cur交换,交换后将cur+1。如果cur=num则直接Num++。
  3. 直到cur和more相遇则完成。假设图中的Num为3,执行情况将会如图所示。
    这里我们要注意的一个问题就是,当大于num的时候,我们的cur是不会+1的,因为此时我们无法确保交换过来的数是大于还是小于或者是等于Num,所以这个数还需要进行一次比较。但是如果与less+1的数交换,交换过来的数是之前比较过的,所以无需再比较,此时cur就需要+1。
    这里写图片描述
    Code:
public static int[] partition(int[] arr, int l, int r, int num) {
        int less = l - 1;
        int more = r + 1;
        while (l < more) {
            if (arr[l] < num) {
                swap(arr, ++less, l++);
            } else if (arr[l] > num) {
                swap(arr, --more, l);
            } else {
                l++;
            }
        }
        return new int[] { less + 1, more - 1 };
        //这里返回的是一个长度为2的数组,a[0]代表的是等于区域的第一个数,a[1]代表的是等于区域的最后一个数

改进快排

回顾一下普通快排,每一次它只解决了我们基准数一个数。假如我们用荷兰国旗问题来改进我们的过程,是不是就可以每一次解决多个相等的数呢?
Code:

    public static void quickSort(int [] a ){
        if (a==null||a.length < 2){
            return;
        }
        quickSort(a,0,a.length-1);
    }

    private static void quickSort(int[] a, int left, int right) {
        while(left<right){
            int[] p = partiction(a ,left,right);
            quickSort(a,left,p[0]-1);
            quickSort(a,p[1]+1,right);
        }
    }

    private static int[] partiction(int[] a, int left, int right) {
        //和最右边的数进行比较
        int less = left -1;
        int more = right;
        int cur = left;
        while(cur<more){
            if (a[cur]<a[right]){
                swap(a,++less,cur++);
            }else if (a[cur]>a[right]){
                swap(a,--more,cur);
            }else {
                cur++;
            }
        }
        swap(a,more,right);
        return new int[] {less+1 , more };
    }
    public static void swap(int[] arr, int i, int j) {
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }

随机快排

因为我们无法确保每一次划分的时候,正好划分在中间位置。所以我们采用随机快排,将数据状况变成一个概率问题。(通过长期期望证明复杂度为0(nlogn))

public static void quickSort(int[] arr, int l, int r) {
        if (l < r) {
            swap(arr, l + (int) (Math.random() * (r - l + 1)), r);//就是只要加这一行就好啦o(* ̄▽ ̄*)ブ
            int[] p = partition(arr, l, r);
            quickSort(arr, l, p[0] - 1);
            quickSort(arr, p[1] + 1, r);
        }
    }
阅读更多
上一篇堆排序(●'◡'●)
下一篇深入理解java虚拟机(第二版)读书笔记(更新ing)
想对作者说点什么? 我来说一句

俄罗斯方块

2018年04月12日 18KB 下载

VC++打飞机游戏

2018年02月28日 629KB 下载

实现远程关机的程序.

2009年05月24日 235KB 下载

WPF创建文件夹的例子

2018年05月09日 3.76MB 下载

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

关闭
关闭