简析快速排序

参考：百度百科-快速排序（Quicksort）

算法原理：（冒泡排序的改进版）

说明：设要排序的数组是A[0]...A[N-1]，首先任意选取一个数据（通常选用数组的第一个数）作为关键数据，

然后将所有 比它小的数都放到它左边，所有比它大的数都放在它右边，这个过程称为一趟快速排序。

算法：

1. 设置两个变量i,j，排序开始的时候i = 0, j = N-1;

2. 以第一个数组元素作为关键数据，赋值给key, 即key = A[0];

3. 从j开始向前搜索，即由后开始向前搜索(j--)，找到第一个小于key的值A[j],将A[j]和A[i]的值交换。

4. 从i开始向后搜索，即由前开始向后搜索(i++)，找到第一个大于key的A[i]，将A[i]和A[j]的值交换。

5. 重复3,4步，直到i == j；

备注：

3,4步中，没找到符合条件的值，即3中A[j]不小于key, 4中A[i]不大于key的时候改变j,i的值，

使得j = j-1,i = i+1,直到找到位置。找到符合条件的值，进行交换的时候i， j指针位置不变。

另外，i==j这一过程一定正好是i+或j-完成的时候，此时令循环结束。

 

Tips: 每次值交换的时候就是与key = A[0]做交换。即分割作用。

排序示例图：

算法分析：

时间复杂度：O(n²)

不稳定排序算法:根据比较基数值判断是否交换，且不是相邻元素来交换，在交换过程中可能改变相同元素的顺序

算法复杂度：O(n log n)

算法实现：

1. C语言版本：

#include "stdlib.h"
#include <stdio.h>

//打印数组元素
void printSelect(int arr[], int len){
    for (int i = 0; i<len; i++)
        printf("%d\t", arr[i]);
    printf("\n");
}

//快排
void quickSort(int arr[], int left, int right) {
    int i = left, j = right;
    int tmp = 0, key = 0;
    if (left > right)
        return;
    key = arr[left]; //temp中存的就是基准数
    while (i != j) { 
        //先从右边开始找
        while (arr[j] >= key && i < j) j--;
        //再找左边的
        while (arr[i] <= key && i < j) i++;
        //交换两个数在数组中的位置
        if (i < j){
            tmp = arr[i];
            arr[i] = arr[j];
            arr[j] = tmp;
        }
    }
    //最终将基准数归位
    arr[left] = arr[i];
    arr[i] = key;
    //继续处理左边的，这里是一个递归的过程
    quickSort(arr, left, i - 1);
    //继续处理右边的 ，这里是一个递归的过程
    quickSort(arr, i + 1, right);
}

//c语言qsort比较函数
int qsortCompare(const void *a, const void *b){
    return *(int *)a - *(int *)b;;
}

int main() {
    int arr[] = { 3, 5, 1, -7, 4, 9, -16, 8, 10, 4, -8 };
    int arrLen = sizeof(arr) / sizeof(arr[0]);
    //快速排序调用
    quickSort(arr, 0, arrLen - 1);
    //输出排序后的结果
    printSelect(arr, arrLen);
    
    //库函数
    int arrQSort[] = { 3, 5, 1, -7, 4, 9, -16, 8, 10, 4, -8 };
    arrLen = sizeof(arrQSort) / sizeof(arrQSort[0]);
    qsort(arrQSort, arrLen, sizeof(arrQSort[0]), qsortCompare);
    printSelect(arrQSort, arrLen);

    system("pause");
    return 0;
}

2. C++版本：

#include "cstdlib"
#include "iostream"
#include <cstdio>

using namespace std;
//打印数组元素
template<typename T> void printSelect(T arr[], int len){
    for (int i = 0; i<len; i++)
        cout << arr[i] << ' ';
    cout << endl;
}

//快排
template<typename T>void quickSort(T arr[], int left, int right) {
    int i = left, j = right;
    T tmp = 0, key = 0;
    if (left > right)
        return;
    key = arr[left]; //temp中存的就是基准数
    while (i != j) { 
        //先从右边开始找
        while (arr[j] >= key && i < j) j--;
        //再找左边的
        while (arr[i] <= key && i < j) i++;
        //交换两个数在数组中的位置
        if (i < j){
            tmp = arr[i];
            arr[i] = arr[j];
            arr[j] = tmp;
        }
    }
    //最终将基准数归位
    arr[left] = arr[i];
    arr[i] = key;
    //继续处理左边的，这里是一个递归的过程
    quickSort(arr, left, i - 1);
    //继续处理右边的 ，这里是一个递归的过程
    quickSort(arr, i + 1, right);
}


//借助c语言qsort
//c语言qsort比较函数
int qsortCompare(const void *a, const void *b){
    return *(int *)a - *(int *)b;
}

int main() {
    double arr[] = { 3, 5, 1, -7, 4, 9.45, -16, 8, 10, 4, -8 };
    int arrLen = sizeof(arr) / sizeof(arr[0]);
    //快速排序调用
    quickSort(arr, 0, arrLen - 1);
    //输出排序后的结果
    printSelect(arr, arrLen);

    //库函数
    int arrQSort[] = { 3, 5, 1, -7, 4, 9, -16, 8, 10, 6, -8 };
    arrLen = sizeof(arrQSort) / sizeof(arrQSort[0]);
    qsort(arrQSort, arrLen, sizeof(arrQSort[0]), qsortCompare);
    printSelect(arrQSort, arrLen);

    system("pause");
    return 0;
}