快速排序（Quicksort）

快速排序是对冒泡排序算法的一种改进。其基本思想是基于分治法的:在待排序表 L [ ln ]中任取一个元素 pivot 作为枢轴(或基准,通常取首元素),通过一趟排序将待排序表划分为独立的两部分 L [ lk —1]和 L [ k + ln ],使得 L [1k—1]中的所有元素小于 pivot , L [ k +1n]中的所有元素大于等于 pivot ,则 pivot 放在了其最终位置 L ( k )上,这个过程称为一趟快速排序(或一次划分)。然后分别递归地对两个子表重复上述过程,直至每部分内只有一个元素或空为止,即所有元素放在了其最终位置上。

1、实现原理：

1.1、动图展示：

在这里插入图片描述

1.2、实现步骤：

1、从数列中挑出一个元素，称为 “基准”（pivot）;

2、重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
3、递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序；

2、时间复杂度

快速排序的平均时间复杂度也是O(nlog2n)

3、代码实现：

3.1、JAVA 实现

public class QuickSort implements IArraySort {@Overridepublic int[] sort(int[] sourceArray) throws Exception {// 对 arr 进行拷贝，不改变参数内容int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);return quickSort(arr, 0, arr.length - 1);}private int[] quickSort(int[] arr, int left, int right) {if (left < right) {int partitionIndex = partition(arr, left, right);quickSort(arr, left, partitionIndex - 1);quickSort(arr, partitionIndex + 1, right);}return arr;}private int partition(int[] arr, int left, int right) {// 设定基准值（pivot）int pivot = left;int index = pivot + 1;for (int i = index; i <= right; i++) {if (arr[i] < arr[pivot]) {swap(arr, i, index);index++;}}swap(arr, pivot, index - 1);return index - 1;}private void swap(int[] arr, int i, int j) {int temp = arr[i];arr[i] = arr[j];arr[j] = temp;}}

3.2、C++实现

// 参考：http://www.dutor.net/index.php/2011/04/recursive-iterative-quick-sort/
struct Range {int start, end;Range(int s = 0, int e = 0) {start = s, end = e;}
};
template <typename T> // 整數或浮點數皆可使用,若要使用物件(class)時必須設定"小於"(<)、"大於"(>)、"不小於"(>=)的運算子功能
void quick_sort(T arr[], const int len) {if (len <= 0)return; // 避免len等於負值時宣告堆疊陣列當機// r[]模擬堆疊,p為數量,r[p++]為push,r[--p]為pop且取得元素Range r[len];int p = 0;r[p++] = Range(0, len - 1);while (p) {Range range = r[--p];if (range.start >= range.end)continue;T mid = arr[range.end];int left = range.start, right = range.end - 1;while (left < right) {while (arr[left] < mid && left < right) left++;while (arr[right] >= mid && left < right) right--;std::swap(arr[left], arr[right]);}if (arr[left] >= arr[range.end])std::swap(arr[left], arr[range.end]);elseleft++;r[p++] = Range(range.start, left - 1);r[p++] = Range(left + 1, range.end);}
}

3.3、C语言实现

typedef struct _Range {int start, end;
} Range;Range new_Range(int s, int e) {Range r;r.start = s;r.end = e;return r;
}void swap(int *x, int *y) {int t = *x;*x = *y;*y = t;
}void quick_sort(int arr[], const int len) {if (len <= 0)return; // 避免len等於負值時引發段錯誤（Segment Fault）// r[]模擬列表,p為數量,r[p++]為push,r[--p]為pop且取得元素Range r[len];int p = 0;r[p++] = new_Range(0, len - 1);while (p) {Range range = r[--p];if (range.start >= range.end)continue;int mid = arr[(range.start + range.end) / 2]; // 選取中間點為基準點int left = range.start, right = range.end;do {while (arr[left] < mid) ++left;   // 檢測基準點左側是否符合要求while (arr[right] > mid) --right; //檢測基準點右側是否符合要求if (left <= right) {swap(&arr[left], &arr[right]);left++;right--;               // 移動指針以繼續}} while (left <= right);if (range.start < right) r[p++] = new_Range(range.start, right);if (range.end > left) r[p++] = new_Range(left, range.end);}
}

3.4、C语言递归实现：

void swap(int *x, int *y) {int t = *x;*x = *y;*y = t;
}void quick_sort_recursive(int arr[], int start, int end) {if (start >= end)return;int mid = arr[end];int left = start, right = end - 1;while (left < right) {while (arr[left] < mid && left < right)left++;while (arr[right] >= mid && left < right)right--;swap(&arr[left], &arr[right]);}if (arr[left] >= arr[end])swap(&arr[left], &arr[end]);elseleft++;if (left)quick_sort_recursive(arr, start, left - 1);quick_sort_recursive(arr, left + 1, end);
}void quick_sort(int arr[], int len) {quick_sort_recursive(arr, 0, len - 1);
}