快速排序

Posted 2020-11-15 oumae

　　快速排序是从冒泡排序演变而来，但比冒泡排序高效的多，所以叫做快速排序。同冒泡排序一样，快速排序也属于交换排序，通过元素之间的比较和交换位置来达到排序的目的。不同的是它采用了分治法。

　　冒泡排序在每一轮只把一个元素冒泡到数列的一端，而快速排序在每一轮挑选一个基准元素，并让其他比它大的元素移动到数列一边，比它小的元素移动到数列的另一边，从而把数列拆解成了两个部分。

 

1.挖坑法

 1 public static <T extends Comparable<? super T>> void quickSort(T[] arr, int start, int end) {
 2     int i = start;
 3     int j = end;
 4     T key = arr[start];
 5     while (i < j) {
 6         /*按j--方向遍历目标数组，直到比key小的值为止*/
 7         while (i < j && arr[j].compareTo(key) >= 0)
 8             j--;
 9         if (i < j) {
10             arr[i++] = arr[j];
11         }
12         /*按i++方向遍历目标数组，直到比key大的值为止*/
13         /*此处一定要小于等于零，假设数组之内有一亿个1,0交替出现的话，而key的值又恰巧是1的话，那么这个小于等于的作用就会使下面的if语句少执行一亿次。*/
14         while (i < j && arr[i].compareTo(key) <= 0)
15             i++;
16         if (i < j) {
17             arr[j--] = arr[i];
18         }
19     }
20     /*此时i==j*/
21     arr[i] = key;
22     if (i - 1 > start) {
23         quickSort(arr, start, i - 1);/*递归调用，把key前面的完成排序*/
24     }
25     if (j + 1 < end) {
26         quickSort(arr, j + 1, end);/*递归调用，把key后面的完成排序*/
27     }
28 }

 

2.指针交换法

 1 public static void quickSort(int[] arr, int start, int end) {
 2     int pivot = arr[start];
 3     int i = start;
 4     int j = end;
 5     while (i < j) {
 6         while ((arr[j] > pivot) && (i < j)) {
 7             j--;
 8         }
 9         while ((arr[i] < pivot) && (i < j)) {
10             i++;
11         }
12         if ((arr[i] == arr[j]) && (i < j)) {
13             i++;
14         } else if (i < j) {
15             arr[i] = arr[i] ^ arr[j];
16             arr[j] = arr[i] ^ arr[j];
17             arr[i] = arr[i] ^ arr[j];
18         }
19     }
20     if (i - 1 > start) {
21         quickSort(arr, start, i - 1);
22     }
23     if (j + 1 < end) {
24         quickSort(arr, j + 1, end);
25     }
26 }