排序算法五：随机化快速排序(Randomized quicksort)

 1     protected void quicksort(int[] array, int first, int last) {
 2         int randomIndex = CommonUtils.getRandomInt(first, last);
 3         CommonUtils.swap(array, first, randomIndex);
 4 
 5         int pivot = array[first];
 6         int i = first;
 7         int j = last - 1;
 8         boolean serachBig = true;
 9         while (i < j) {
10             if (serachBig) {
11                 if (array[j] < pivot) {
12                     array[i] = array[j];
13                     i++;
14                     serachBig = false;
15                 } else {
16                     j--;
17                 }
18             } else {
19                 if (array[i] > pivot) {
20                     array[j] = array[i];
21                     j--;
22                     serachBig = true;
23                 } else {
24                     i++;
25                 }
26             }
27         }
28         array[i] = pivot;
29 
30         if (i - first > 1) {
31             quicksort(array, first, i);
32         }
33         if (last - i > 2) {
34             quicksort(array, i + 1, last);
35         }
36     }

 1 package com.cnblogs.riyueshiwang.sort;
 2 
 3 import java.util.Arrays;
 4 
 5 public class RandomizedQuickSort extends abstractSort {
 6     @Override
 7     protected void sort(int[] toSort) {
 8         quicksort(toSort, 0, toSort.length);
 9     }
10 
11     protected void quicksort(int[] array, int first, int last) {
12         int randomIndex = CommonUtils.getRandomInt(first, last);
13         CommonUtils.swap(array, first, randomIndex);
14 
15         int pivot = array[first];
16         int i = first;
17         int j = last - 1;
18         boolean serachBig = true;
19         while (i < j) {
20             if (serachBig) {
21                 if (array[j] < pivot) {
22                     array[i] = array[j];
23                     i++;
24                     serachBig = false;
25                 } else {
26                     j--;
27                 }
28             } else {
29                 if (array[i] > pivot) {
30                     array[j] = array[i];
31                     j--;
32                     serachBig = true;
33                 } else {
34                     i++;
35                 }
36             }
37         }
38         array[i] = pivot;
39 
40         if (i - first > 1) {
41             quicksort(array, first, i);
42         }
43         if (last - i > 2) {
44             quicksort(array, i + 1, last);
45         }
46     }
47 
48     public static void main(String[] args) {
49         for (int j = 0, n = 2500; j < 3; j++, n = n * 10) {
50             System.out
51                     .println("**************************************************");
52             System.out.println("Number to Sort is:" + n);
53             int[] array = CommonUtils.getRandomIntArray(n, 1000000);
54 
55             System.out.print("Randomized sequence to sort is:");
56             CommonUtils.printIntArray(array);
57 
58             int[] array1 = Arrays.copyOf(array, n);
59             new QuickSort().sortAndprint(array1);
60             int[] array2 = Arrays.copyOf(array, n);
61             new RandomizedQuickSort().sortAndprint(array2);
62 
63             System.out.print("Ordered sequence to sort is:");
64             CommonUtils.printIntArray(array1);
65             new QuickSort().sortAndprint(array1);
66             new RandomizedQuickSort().sortAndprint(array1);
67 
68         }
69 
70     }
71 }

 1 package com.cnblogs.riyueshiwang.sort;
 2 
 3 import java.util.Random;
 4 
 5 public class CommonUtils {
 6     private static Random random = new Random();
 7 
 8     public static void printIntArray(int[] array) {
 9         System.out.print(‘{‘);
10 
11         int length = Math.min(array.length, 10);
12         for (int i = 0; i < length; i++) {
13             System.out.print(array[i]);
14             if (i != length - 1) {
15                 System.out.print(‘,‘);
16             } else {
17                 if (array.length > 10) {
18                     System.out.print("...");
19                 }
20                 System.out.println(‘}‘);
21             }
22         }
23     }
24 
25     public static int[] getRandomIntArray(int size, int maxValue) {
26         int[] array = new int[size];
27         for (int i = 0; i < size; i++) {
28             array[i] = random.nextInt(maxValue);
29         }
30         return array;
31     }
32 
33     public static void swap(int[] toSort, int i, int j) {
34         int temp = toSort[i];
35         toSort[i] = toSort[j];
36         toSort[j] = temp;
37     }
38 
39     /**
40      * 
41      * @param first
42      *            begin value
43      * @param last
44      *            end value
45      * @return a pseudo random, uniformly distributed int value between first
46      *         (inclusive) and last (exclusive)
47      * 
48      */
49     public static int getRandomInt(int first, int last) {
50         return random.nextInt(last - first) + first;
51     }
52 }