【11月11日 】排序算法续--快速排序+彩蛋一

双十一小小的shopping了一把，终于上了ssd，居然有人屯颗粒导致价格上涨，表示简直不能忍。好在可以报销，不然真的真的吃土了。

前面介绍了集中基本的算法，大多数效率都不怎么高，除了shell。今天再来介绍一种比较高效的算法--快速排序算法，然后顺便就排序算法的效率做一个总结。

快速排序法(Quick Sort）

快速排序法的思想和冒泡算法类似，都是基于交换排序的思想。可以将快速排序法看成是冒泡的改良版本，效率大大提高。排序的流程如下：

（1）首先设定一个分界值。

（2）通过改值将数组分为左右两部分。将大于分界值的数集中在数组的右边，小于分界值的集中在数组的左边。即，分界值的左边都是小于其的数，分界值的右边都是大于其的数。

（3）然后，对于左边和后面的数可以单独进行排序。对于左侧的数据，又可以选取一个分界值，将左侧的数据分为两个部分。右边也可以做同样的处理。

（4）重复上述过程。可以看出，这是一个递归的过程。通过递归将左侧的数据排好之后，又可以递归的排好后侧的数据。

啊哈~~~这个说的有一点抽象，同样，为了方便理解，在下还来举个例子。

这个过程十分有意思，有点牛郎织女鹊桥相互的味道。

对于A数组69，62，89，37，97，17，28，49。

（1）首先取一个分界值，比如第一个数69。在变量i中保存数组的最小序号0，j保存最大序号7，base中保存分界值。

下标

0

1

2

3

4

5

6

7

数据

69

62

89

37

97

17

28

49

i=0，j=7,base=69

（2）从数组的右侧开始，逐个取出数据与分界值69比较，直到找到比69小的为止。这里，找到的A[j]的49就是比分界值小的数。

下标

0

1

2

3

4

5

6

7

数据

49

62

89

37

97

17

28

69

i=0,j=7,base=69

（3）接着，开始第二次比较，从左到右找比base大的数。找到A[2]上的89，将其与69交换位置。

下标

0

1

2

3

4

5

6

7

数据

49

62

69

37

97

17

28

89

i=2,j=7,base=69

（4）继续。

下标

0

1

2

3

4

5

6

7

数据

49

62

28

37

97

17

69

89

i = 2,j=6,base=69

(5)go on。

下标

0

1

2

3

4

5

6

7

数据

49

62

28

37

69

17

97

89

i = 4,j=6,base=69

(6)继续继续

下标

0

1

2

3

4

5

6

7

数据

49

62

28

37

17

69

97

89

i=4,j=5,base=69

(7)可以看出 ，再走下去就是七夕佳节到（i和j就会“碰面”），却看那鹊桥之上，兀那男子，粗衣草鞋，扁担这头挑着四岁的牛大宝，扁担那头挑着三岁的牛二宝；兀那妇人，来势汹汹，左携太白金星所赐延年益寿十尾报晓芦花鸡，右带嫦娥妃子相赠发家致富八爪戏水周黑鸭。两人相见，涕笑连连，分为欢喜，就地将这些上好的鸡鸭宰了煮熟，并着卫龙辣条、小当家方便面等一干天上美食，狼吐虎咽忆当年。真乃神仙眷侣也。

(8)上面的比较过程为一次循环，其结果是使：分界值左边都是比其小的数，分界值右边都是比其大的数。接下来，通过递归调用，分别将左侧和右侧的数进行排序即可。

 

算法实例：

public  static  void  quickSort(int[] a ,int left, int right){
    long starTime=System.currentTimeMillis();
    int f,t;
    int rtemp,ltemp;

    ltemp = left;
    rtemp = right;

    f = a[left];
    while(ltemp < rtemp){
        while (a[ltemp]<f){
            ++ltemp;
        }

        while(a[rtemp]>f){
           rtemp--;
        }

        if(ltemp <= rtemp){
            t = a[ltemp];
            a[ltemp]=a[rtemp];
            a[rtemp]=t;
            rtemp--;
            ltemp++;
        }
    }

    if(ltemp == rtemp){
        ltemp++;
    }

    //递归调用
    if(left<rtemp){
        quickSort(a,left,ltemp-1);
    }

    //递归调用
    if(ltemp<right){
        quickSort(a,rtemp+1,right);
    }
    
long endTime=System.currentTimeMillis();
int time =(int)((endTime - starTime)*100);
System.out.println("快速排序所用的时长为："+time);

}

 

 

留一个彩蛋，找了一道蛮有意思的面试题：

class Singleton  

{  

private static Singleton singleton = new Singleton();  

public static int counter1;  

public static int counter2 = 0;  

private Singleton()  

{  

counter1++;  

counter2++;  

}  

public static Singleton getInstance()  

{  

return singleton;  

}  

}  

public class Test  

{  

public static void main(String[] args)  

{  

Singleton singleton = Singleton.getInstance();  

System.out.println("counter1 = " + singleton.counter1);  

System.out.println("counter2 = " + singleton.counter2);  

}  

}  

请问会输出什么呢？