快速排序

快速排序

快速排序是目前已知的最快的排序算法，它是非稳定的，原地的。它的时间复杂度平均情况下是$O(nlogn)$,最差情况下是$O(n^2)$。虽然如此，但是最坏情况是非常难达到的，而因为快速排序非常的紧凑，所以他成了最快的排序算法。

不过，快速排序也有缺点，由于不是稳定的排序算法，所以在很多情况下不可以使用快速排序。

模版：

判题地址：acwing：785. 快速排序

c++代码：

#include <iostream>
using namespace std;

const int N = 1e5 + 5;
int q[N];
int n;

void quick_sort(int q[], int l, int r) {
    if (l >= r) return;
    int i = l - 1, j = r + 1, x = q[l + r >> 1];
    while ( i < j ) {
        do i ++ ; while (q[i] < x);
        do j -- ; while (q[j] > x);
        if (i < j) swap(q[i], q[j]);
    }
    quick_sort(q, l, j), quick_sort(q, j + 1, r);
}

int main() {
    scanf("%d", &n);
    for (int i = 0; i < n; i++) scanf("%d", &q[i]);
    quick_sort(q, 0, n - 1);
    for (int i = 0; i < n; i++) printf("%d ", q[i]);
    return 0;
}

Java代码：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

public class Main {
    public static void main(String[] args) throws IOException {
        InputStreamReader in = new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(in);

        int n = Integer.parseInt(br.readLine());
        int[] arr = new int[n];

        String[] res = br.readLine().split(" ");
        for (int i = 0; i < n; i++) {
            arr[i] = Integer.parseInt(res[i]);
        }

        quickSort(arr, 0, n - 1);

        for (int i = 0; i < n; i++) {
            System.out.print(arr[i] + " ");
        }
        br.close();
    }
    
    public static void quickSort(int[] arr, int l, int r) {
        if (l >= r) return;
        int i = l - 1, j = r + 1, x = arr[l + r >> 1];
        while ( i < j ) {
            do i ++ ; while (arr[i] < x);
            do j -- ; while (arr[j] > x);
            if (i < j) swap(arr, i, j);
        }
        quickSort(arr, l, j);
        quickSort(arr, j + 1, r);
    }
    
    public static void swap(int[] arr, int i, int j) {
        int t = arr[i];
        arr[i] = arr[j];
        arr[j] = t;
    }
}

Python代码：

import sys

def quick_sort(arr, l, r):
    if l >= r: return
    i, j, x = l - 1, r + 1, arr[l + r >> 1]
    while i < j:
        i += 1
        while arr[i] < x: i += 1
        j -= 1
        while arr[j] > x: j -= 1
        if i < j: arr[i], arr[j] = arr[j], arr[i]
    quick_sort(arr, l, j)
    quick_sort(arr, j + 1, r)


if __name__ == '__main__':
    nums = []
    for line in sys.stdin:
        nums.append(list(map(int, line.split())))
    num = nums[1]
    quick_sort(num,0, len(num)-1)
    print(" ".join(map(str,num)))

三向切分快速排序：

这是基于快速排序的一个扩展。方法和快速排序类似，不同处是快速排序用一个数作为分界点，而和它相同的数可能在左边，也可能在右边。三向切分快速排序是将所有和选中的这个数相同的所有值都放在一起，这样分界点不是一个值，而是一段值。

三向切分快速排序的速度和快速排序差不多，对于相同数字较多的数组，排序比快速排序快很多，而相同数字不多的情况速度比快速排序稍慢一点点。

模版：

判题地址：acwing：818. 数组排序

c++代码：

#include <iostream>
using namespace std;

const int N = 1e5 + 5;
int q[N];
int n, l, r;

void quick_3way_sort(int q[], int l, int r) {
    if (l >= r) return;
    int lt = l, i = l + 1, gt = r, x = q[l];
    while ( i <= gt ) {
        if (q[i] < x) swap(q[lt++], q[i++]);
        else if (q[i] > x) swap(q[i], q[gt--]);
        else i++;
    }
    quick_3way_sort(q, l, lt - 1), quick_3way_sort(q, gt + 1, r);
}

int main() {
    scanf("%d%d%d", &n, &l, &r);
    for (int i = 0; i < n; i++) scanf("%d", &q[i]);
    quick_3way_sort(q, l, r);
    for (int i = 0; i < n; i++) printf("%d ", q[i]);
    return 0;
}

Java代码：

import java.util.Scanner;
import java.io.BufferedInputStream;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(new BufferedInputStream(System.in));
        int n = in.nextInt(), l = in.nextInt(), r = in.nextInt();
        int[] arr = new int[n];
        for (int i = 0; i < n; i++) {
            arr[i] = in.nextInt();
        }

        quick3WaySort(arr, l, r);

        for (int i = 0; i < n; i++) {
            System.out.print(arr[i] + " ");
        }
    }
    
    public static void quick3WaySort(int[] arr, int l, int r) {
        if (l >= r) return;
        int lt = l, i = l + 1, gt = r, x = arr[l];
        while (i <= gt) {
            if (arr[i] < x) swap(arr, lt++, i++);
            else if (arr[i] > x) swap(arr, gt--, i);
            else i++;
        }
        quick3WaySort(arr, l, lt - 1);
        quick3WaySort(arr, gt + 1, r);
    }
    
    public static void swap(int[] arr, int i, int j) {
        int t = arr[i];
        arr[i] = arr[j];
        arr[j] = t;
    }
}

Python代码：

import sys

def quick_3way_sort(arr, l, r):
    if l >= r: return
    lt, i, gt, x = l, l + 1, r, arr[l]
    while i <= gt:
        if arr[i] < x:
            arr[i], arr[lt] = arr[lt], arr[i]
            i += 1
            lt += 1
        elif arr[i] > x:
            arr[i], arr[gt] = arr[gt], arr[i]
            gt -= 1
        else:
            i += 1
    quick_3way_sort(arr, l, lt - 1)
    quick_3way_sort(arr, gt + 1, r)

if __name__ == '__main__':
    nums = []
    for line in sys.stdin:
        nums.append(list(map(int, line.split())))
    num = nums[1]
    quick_3way_sort(num, nums[0][1], nums[0][2])
    print(" ".join(map(str,num)))