用C++实现快速排序算法

一、C语言实现快速排序算法

C语言实现快速排序算法可以使用递归方式实现。基本思路是先取一个基准数，将数组分为两个部分，小于等于基准数的在左边，大于基准数的在右边，然后递归排序左右两部分，直到所有的子序列都有序。

void quick_sort(int arr[], int left, int right) {
    int i = left, j = right;
    int pivot = arr[(left + right) / 2];
    while (i <= j) {
        while (arr[i] < pivot) {
            i++;
        }
        while (arr[j] > pivot) {
            j--;
        }
        if (i <= j) {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
            i++;
            j--;
        }
    }
    if (left < j) {
        quick_sort(arr, left, j);
    }
    if (i < right) {
        quick_sort(arr, i, right);
    }
}

二、快速排序算法C++代码

快速排序算法的C++代码同样可以使用递归方式实现，但是C++使用STL提供的sort函数也可以实现快速排序。sort函数的默认实现使用快速排序算法，时间复杂度为O(nlogn)。

#include <bits/stdc++.h>

using namespace std;

int main() {
    int arr[] = {5, 3, 9, 7, 1, 8, 4, 6, 2};
    int n = sizeof(arr) / sizeof(arr[0]);
    sort(arr, arr + n);
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    return 0;
}

三、快速排序算法的时间复杂度

快速排序算法的平均时间复杂度为O(nlogn)，最坏时间复杂度为O(n^2)。最坏情况是当待排序序列已经有序，或者每次分割后的两个子序列大小差距比较大时，递归深度会达到序列长度n，导致时间复杂度退化。

四、快速排序算法代码

快速排序算法的代码如下：

void quick_sort(int arr[], int left, int right) {
    int i = left, j = right;
    int pivot = arr[(left + right) / 2];
    while (i <= j) {
        while (arr[i] < pivot) {
            i++;
        }
        while (arr[j] > pivot) {
            j--;
        }
        if (i <= j) {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
            i++;
            j--;
        }
    }
    if (left < j) {
        quick_sort(arr, left, j);
    }
    if (i < right) {
        quick_sort(arr, i, right);
    }
}

五、JS快速排序算法

JS快速排序算法的思路与C++快速排序算法类似，也是使用递归实现。代码如下：

function quickSort(arr) {
    if (arr.length <= 1) return arr;
    var pivotIndex = Math.floor(arr.length / 2);
    var pivot = arr.splice(pivotIndex, 1)[0];
    var left = [];
    var right = [];
    for (var i = 0; i < arr.length; i++) {
        if (arr[i] < pivot) {
            left.push(arr[i]);
        } else {
            right.push(arr[i]);
        }
    }
    return quickSort(left).concat([pivot], quickSort(right));
}

六、快速排序算法C语言

快速排序算法的C语言实现如下：

void quick_sort(int arr[], int left, int right) {
    int i = left, j = right;
    int pivot = arr[(left + right) / 2];
    while (i <= j) {
        while (arr[i] < pivot) {
            i++;
        }
        while (arr[j] > pivot) {
            j--;
        }
        if (i <= j) {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
            i++;
            j--;
        }
    }
    if (left < j) {
        quick_sort(arr, left, j);
    }
    if (i < right) {
        quick_sort(arr, i, right);
    }
}

七、快速排序算法的原理图解

快速排序算法的原理图解如下：

八、C语言快速排序算法代码

C语言快速排序算法的代码如下：

void quick_sort(int arr[], int left, int right) {
    int i = left, j = right;
    int pivot = arr[(left + right) / 2];
    while (i <= j) {
        while (arr[i] < pivot) {
            i++;
        }
        while (arr[j] > pivot) {
            j--;
        }
        if (i <= j) {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
            i++;
            j--;
        }
    }
    if (left < j) {
        quick_sort(arr, left, j);
    }
    if (i < right) {
        quick_sort(arr, i, right);
    }
}

九、快速排序算法代码C语言实现

快速排序算法代码的C语言实现如下：

void quick_sort(int arr[], int left, int right) {
    int i = left, j = right;
    int pivot = arr[(left + right) / 2];
    while (i <= j) {
        while (arr[i] < pivot) {
            i++;
        }
        while (arr[j] > pivot) {
            j--;
        }
        if (i <= j) {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
            i++;
            j--;
        }
    }
    if (left < j) {
        quick_sort(arr, left, j);
    }
    if (i < right) {
        quick_sort(arr, i, right);
    }
}