基础算法-快速排序

算法分析

• 时间复杂度：平均情况下为O(n㏒₂n)

• 空间复杂度：最好情况下为O(㏒₂n)，最坏情况下为O(n)

算法特点

• 记录非顺次的移动导致排序方法是不稳定的

• 排序过程中需要定位表的下界和上界，所以适合用于顺序结构，很难用于链式结构

• 当n较大时，在平均情况下快速排序是所有内部排序方法中速度最快的一种，所以其适合初始记录无序、n较大的情况

算法代码

#include<iostream>
#include<cstdio>
using namespace std;

#define MAXSIZE 100    //定义数组大小

void Quick_sort(int arr[], int low, int high);    //声明快速排序函数
void sort(int *a, int *b);    //声明值交换函数

int main()
{
    int arr[MAXSIZE];    //定义数组
    int n; cin >> n;    //输入需要的数组长度

    //for循环对每个值进行输入
    for (int i = 0; i < n; i++) cin >> arr[i];

    //快速排序
    Quick_sort(arr, 0, n - 1);

    //输出排序后的值
    for (int i = 0; i < n; i++) cout << arr[i] << " ";

    return 0;
}

//定义快速排序函数（从小到大），参数为数组arr[]，数组起始下标low， 数组终止下标high
void Quick_sort(int arr[], int low, int high)    
{
    //当low>=high时说明该区间不存在或只有一个值，不需要进行排序，直接返回
    if (low >= high) return;

    //定义变量pivotkey来表示数组区间的第一个值（默认以第一个值作为标准，也可以表示最后一个值等等）
    int pivotkey = arr[low];

    //定义变量l，h表示未进行排序部分的起始下标和终止下标，通过改变l，h的值来缩小排序的范围
    int l = low, h = high;

    //当 l < h 时进入循环排序
    /*
        这种快排的思想为：
        先从后往前找到第一个比标准值 pivotkey 小的值
        然后从前往后找到第一个比标准值 pivotkey 大的值
        如果此时依旧满足 l < h 的条件，则将两个值进行交换
        之后进入下一次循环，直到 l >= h 为止
        这是因为当 l >= h 时说明整个数组已经遍历结束了
        此时左半部分都是小于等于 pivotkey 的值
        右半部分都是大于等于 pivotkey 的值
    */
    while (l < h)
    {
        while (arr[h] > pivotkey) h--;
        while (arr[l] < pivotkey) l++;
        if (l < h) sort(&arr[h], &arr[l]);
    }

    //递归调用快排函数quick_sort，将其分为左半部分和右半部分分别调用
    Quick_sort(arr, low, l);
    Quick_sort(arr, l + 1, high);
}

void sort(int *a, int *b)    //值交换函数
{
    *a = *a + *b;
    *b = *a - *b;
    *a = *a - *b;
}

#include <iostream>
#include <cstdio>
using namespace std;

const int N = 10010;
int arr[N];

void Quict_sort(int arr[], int low, int high);

int main()
{
    int n; cin >> n;

    for(int i = 0; i < n; i++) cin >> arr[i];

    Quict_sort(arr, 0, n-1);

    for(int i = 0; i < n; i++) cout << arr[i] << " ";

    return 0;
}

void Quict_sort(int arr[], int low, int high)
{
    if(low >= high) return;

    int l = low, h = high;

    int pivotkey = arr[low];

    while(l < h)
    {
        while(arr[h] >= pivotkey && l < h) h--;
        arr[l] = arr[h];
        while(arr[l] <= pivotkey && l < h) l++;
        arr[h] = arr[l];
    }
    arr[l] = pivotkey;

    Quict_sort(arr, low, l-1);
    Quict_sort(arr, h+1, high);
}

/*
    这个快排思路和上面那个很类似，但是在细节上又略有不同
    这个快排也是把数组分为左右两部分
    但是它在循环中pivotkey的值位置被确定了
    不会进入接下来的嵌套循环
    而上面的快排pivotkey依然会进入接下来的嵌套循环
*/

欢迎大家探讨