排序算法之快速排序

最新推荐文章于 2021-07-27 06:45:20 发布

爱上口袋的天空

最新推荐文章于 2021-07-27 06:45:20 发布

阅读量413

点赞数 1

原文链接：http://blog.csdn.net/morewindows/article/details/6684558

版权

简介
快速排序算法是对冒泡排序的一种改进，它采用了一种分治的策略，通常称其为分治法。分治法的思想是：将原问题分解为若干个规模更小的但结构与原问题相似的子问题。递归地解这些子问题，然后将这些子问题的解组合为原问题的解。
即通过一趟排序将进行排序的数据分割成独立的两部分，其中一部分的数据比另一部分的数据都大，然后再按此访求对这两部分数据分别进行快速排序，这样循环往复，直到进行排序的数据按一定的顺序排列。
快速排序是C.R.A.Hoare于1962年提出的一种划分交换排序。它采用了一种分治的策略，通常称其为分治法(Divide-and-ConquerMethod)。
该方法的基本思想是：
1）先从数列中取出一个数作为基准数。
2) 分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。
3) 再对左右区间重复第二步，直到各区间只有一个数。
虽然快速排序称为分治法，但分治法这三个字显然无法很好的概括快速排序的全部步骤。因此我的对快速排序作了进一步的说明：挖坑填数+分治法：
理解快速排序算法的例子
以一个数组作为示例，取区间第一个数为基准数

0

1

2

3

4

5

6

7

8

9

72

6

57

88

60

42

83

73

48

85

初始时，i = 0; j = 9; X = a[i] = 72

由于已经将a[0]中的数保存到X中，可以理解成在数组a[0]上挖了个坑，可以将其它数据填充到这来。

从j开始向前找一个比X小或等于X的数。当j=8，符合条件，将a[8]挖出再填到上一个坑a[0]中。a[0]=a[8]; i++; 这样一个坑a[0]就被搞定了，但又形成了一个新坑a[8]，这怎么办了？简单，再找数字来填a[8]这个坑。这次从i开始向后找一个大于X的数，当i=3，符合条件，将a[3]挖出再填到上一个坑中a[8]=a[3]; j--;
数组变为：

0

1

2

3

4

5

6

7

8

9

48

6

57

88

60

42

83

73

88

85

i = 3; j = 7; X=72

再重复上面的步骤，先从后向前找，再从前向后找。

从j开始向前找，当j=5，符合条件，将a[5]挖出填到上一个坑中，a[3] = a[5]; i++;

从i开始向后找，当i=5时，由于i==j退出。

此时，i = j = 5，而a[5]刚好又是上次挖的坑，因此将X填入a[5]。

可以看出a[5]前面的数字都小于它，a[5]后面的数字都大于它。因此再对a[0…4]和a[6…9]这二个子区间重复上述步骤就可以了。

对挖坑填数进行总结

1．i =L; j = R; 将基准数挖出形成第一个坑a[i]。

2．j--由后向前找比它小的数，找到后挖出此数填前一个坑a[i]中。

3．i++由前向后找比它大的数，找到后也挖出此数填到前一个坑a[j]中。

4．再重复执行2，3二步，直到i==j，将基准数填入a[i]中。

照着这个总结很容易实现挖坑填数的代码：

代码实现

package com.iamp.admin.test;

import java.util.Arrays;

public class QuikShort {

    public static void main(String[] args) {
        int[] arr = { 49, 38, 65, 97, 23, 22, 76, 1, 5, 8, 2, 0, -1, 22 };
        quickSort(arr, 0, arr.length - 1);
        System.out.println("排序后:"+ Arrays.toString(arr));
    }

    /***
     * 快速排序:
     *
     * @param s:需要排序的数组
     * @param l：开始的数组下标
     * @param r：数组最大的下标
     */
    public static void quickSort(int s[], int l, int r)
    {
        if (l < r)
        {
            //定义i为下标0，j为数组最大下标，x为基准数
            int i = l, j = r, x = s[l];
            while (i < j)
            {
                while(i < j && s[j] >= x){// 从右向左找第一个小于x的数
                    j--;//如果➡右指针的数比坑里的数大，那就不交换，直接继续移动寻找
                }
                if(i < j){//找到了一个arr[j]比坑小,或者说i等于j啦，跳出了while循环
                    s[i] = s[j];//这样，j这边就有一个坑，需要左指针移动，找一个比坑的数大的填进来
                    i++;
                }
                while(i < j && s[i] < x) {//从左向右找第一个大于等于x的数
                    i++;
                }
                if(i < j){//将i填入j后，i这里就是一个新的坑
                    s[j] = s[i];
                    j--;//需要移动j来填
                }
            }
            s[i] = x;
            quickSort(s, l, i - 1); // 递归调用
            quickSort(s, i + 1, r);
        }
    }

}

程序运行结果：

排序后:[-1, 0, 1, 2, 5, 8, 22, 22, 23, 38, 49, 65, 76, 97]

性能测试：

package com.iamp.admin.test;

import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;

public class QuikShort {

    public static void main(String[] args) {
//        int[] arr = { 49, 38, 65, 97, 23, 22, 76, 1, 5, 8, 2, 0, -1, 22 };
//        quickSort(arr, 0, arr.length - 1);
//        System.out.println("排序后:"+ Arrays.toString(arr));

        // 创建要给80000个的随机的数组
        int[] arr = new int[8000000];
        for (int i = 0; i < 8000000; i++) {
            arr[i] = (int) (Math.random() * 8000000); // 生成一个[0, 8000000) 数
        }

        System.out.println("排序前");
        Date date1 = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String date1Str = simpleDateFormat.format(date1);
        System.out.println("排序前的时间是=" + date1Str);

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

        Date data2 = new Date();
        String date2Str = simpleDateFormat.format(data2);
        System.out.println("排序前的时间是=" + date2Str);

    }

    /***
     * 快速排序:
     *
     * @param s:需要排序的数组
     * @param l：开始的数组下标
     * @param r：数组最大的下标
     */
    public static void quickSort(int s[], int l, int r)
    {
        if (l < r)
        {
            //定义i为下标0，j为数组最大下标，x为基准数
            int i = l, j = r, x = s[l];
            while (i < j)
            {
                while(i < j && s[j] >= x){// 从右向左找第一个小于x的数
                    j--;//如果➡右指针的数比坑里的数大，那就不交换，直接继续移动寻找
                }
                if(i < j){//找到了一个arr[j]比坑小,或者说i等于j啦，跳出了while循环
                    s[i] = s[j];//这样，j这边就有一个坑，需要左指针移动，找一个比坑的数大的填进来
                    i++;
                }
                while(i < j && s[i] < x) {//从左向右找第一个大于等于x的数
                    i++;
                }
                if(i < j){//将i填入j后，i这里就是一个新的坑
                    s[j] = s[i];
                    j--;//需要移动j来填
                }
            }
            s[i] = x;
            quickSort(s, l, i - 1); // 递归调用
            quickSort(s, i + 1, r);
        }
    }

}

运行结果：数组长度为八百万的时候，排序时间约为1秒：

转载于：http://blog.csdn.net/morewindows/article/details/6684558