快速排序是对冒泡排序的一种改进。
它的基本思想是:通过一次排序将数据分割成两部分,其中一部分的数据都比另外一部分的数据都要小,然后在对这两部分进行相同操作
基本流程
1.先从数列中取出一个数作为基准数。
2.分区过程,将比这个数大的数全放到它的右边,小于或等于它的数全放到它的左边。
3.再对左右区间重复第二步,直到各区间只有一个数。
动态演示
python实现
def quickSort(datas: list):
def func(begin: int, end: int):
if begin == end or begin == end + 1: return
front: int = begin
rear: int = end
pivot = datas[front]
while front < rear:
while front < rear and datas[rear] >= pivot: rear -= 1
datas[front] = datas[rear]
while front < rear and datas[front] <= pivot: front += 1
datas[rear] = datas[front]
datas[front] = pivot
func(begin, front)
func(front + 1, end)
func(0, len(datas) - 1)
def main():
size: int = 20
l = []
for i in range(0, size):
l.append(math.floor(random() * size * 10))
print("排序前:", l)
quickSort(l)
print("排序后:", l)
数据量 | 10^4 | 10^5 | 10^6 | 10^7 |
---|---|---|---|---|
耗时/ms | 43.2 | 601.1 | 7179.9 | 87891.9 |
C++ 实现
template<typename T>
void quickSort(T* arr, int size) {
if (size == 0)return;
int front = 0, rear = size - 1;
T pivot = arr[0];
while (front < rear) {
while (front < rear && arr[rear] >= pivot) { --rear; }
arr[front] = arr[rear];
while (front < rear && arr[front] <= pivot) { ++front; }
arr[rear] = arr[front];
}
arr[front] = pivot;
quickSort(arr, front);
quickSort(arr + front + 1, size - 1 - front);
}
数据量 | 10^4 | 10^5 | 10^6 | 10^7 |
---|---|---|---|---|
耗时/ms | 0.8397 | 10.713 | 133.032 | 3680.29 |
java实现
public static <T extends Comparable<T>> void quickSort(T[] array) {
_quickSort(array, 0, array.length - 1);
}
private static <T extends Comparable<T>> void _quickSort(T[] array, int begin, int end) {
if (begin == end + 1 || begin == end) return;
int front = begin, rear = end;
T pivot = array[front];
while (front < rear) {
while (front < rear && array[rear].compareTo(pivot) >= 0) --rear;
array[front] = array[rear];
while (front < rear && array[front].compareTo(pivot) <= 0) ++front;
array[rear] = array[front];
}
array[front] = pivot;
_quickSort(array, begin, front - 1);
_quickSort(array, front + 1, end);
}
数据量 | 10^4 | 10^5 | 10^6 | 10^7 |
---|---|---|---|---|
耗时/ms | 4.0 | 115.3 | 440.5 | 4059.8 |
算法分析
平均时间复杂度 O(nlogn)
最坏时间复杂度 O(n²) 对一个降序序列排序,退化成冒泡排序
稳定性:不稳定