快速排序.

快速排序

快速排序法介绍

快速排序(Quicksort)是对冒泡排序的一种改进,基本思想是:通过一趟排序将要排序的数据分割成独立两部分,其中一部分的所有数据都比另外一部分的所有数据小,然后在按照此方法对两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列.

快速排序的示意图

我们从图中可以看出,这个图示以数字11进行的分析,我们快速排序其实和它有一点点不一样,我们是以中间的位置,就是下标所在的位置进行的分离,但是本质上没有什么区别,我们每次用位置进行分离,不一定是大约中间数值的那个数,你可能回想一直取到最小的那个数怎么办,那么我们取完就排序完成啊,我们放在就是一直重复,递归得到答案.

快速排序的实例

package sort;

import java.util.Arrays;

public class QuickSort {
    public static void main(String[] args) {
      int[] arr={-9,78,0,23,-567,70};
     quickSort(arr,0,arr.length-1);
        System.out.println(Arrays.toString(arr));

        //快速排序的速度测试
        int[] arr2=new int[80000];
        for (int i=0;i<80000;i++){
            arr2[i]=(int)(Math.random()*40000);//生成一个[0,20000)的随机整数
        }
        long startTime=System.currentTimeMillis();
        quickSort(arr2,0,arr2.length-1);
        long endTime=System.currentTimeMillis();
        System.out.println("排序用的时间:"+(endTime-startTime));
    }

    public static void quickSort(int [] arr,int left,int right){
        int l=left;//左边的下标
        int r=right;//右边的下标
        //pivot 中轴
        int pivot=arr[(left+right)/2];//这里我们用加法,我们找的是中间值,而不是中间的差值.
      int temp=0;//作为交换时使用
        //while循环的目的是让比pivot值小的放到它的左边
        //比它大的值放到右边
        while (l<r){
            //在pivot的左边一直找,找到大于或等于pivot的值才退出
            while (arr[l]<pivot){
                l+=1;
            }
            //在piot的右边一致找,找到一个小于等于pivot的值才退出
            while (arr[r]>pivot){
                r-=1;
            }
            //如果l>=r,说明pivot的左右两边的值,已经安装左边全部是
            //小于等于pivot值,右边全部是大于等于pivot的值.
            if(l>=r){
                break;
            }

            //交换
            temp=arr[l];
            arr[l]=arr[r];
            arr[r]=temp;

            //如果交换完后,发现arr[l]==pivot值,r--,前移一步
            if(arr[l]==pivot){
                r-=1;
            }
            //如果交换往后,我们发现arr[r]==pivot值,l++,后移
            if(arr[r]==pivot){
                l+=1;
            }
        }


        //如果1==r,必须l++,r--,否则栈溢出
        if(l==r){
            l+=1;
            r-=1;
        }
        //向左递归
        if(left<r){
            quickSort(arr,left,r);
        }
        //向有递归
        if(right>l){
            quickSort(arr,l,right);
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

对于上面中轴值,其实我们什么值都可以,可能很多人一开始陷入一个误区,那就是中轴值我们用的中轴下标,但是我们的值是最小的怎么办,其实很好理解,我们要的其实是中轴这个位置,因为我们用的递归,每次我们取中间这个位置,不可能每次都是最小的,即使有一次是最小的值,大不了就是我们左边0个数,右边全部数,下一次递归,我们递归右边,这个时候,我们又从右边的中轴开始取数字,作为我们的值进行分界,然后在分别在向左和向右递归进行排序就行.

空间换时间

这里我们就是明显的空间换时间,因为我们递归的次数多了,那么我们占用的空间就更多,但是我们的时间也是明显的有了很大的提示.