排序算法-快速排序

快速排序（Quick Sort）是一种常用的排序算法，它的基本思想是：选择一个基准元素（pivot），通过一趟排序将待排序的元素分成两部分，其中一部分的所有元素都比基准元素小，另一部分的所有元素都比基准元素大，然后再递归地对这两部分元素分别进行快速排序，直到整个序列有序。

快速排序的具体实现如下：

1. 选择一个基准元素（pivot），一般选择第一个元素或最后一个元素。

2. 通过一趟排序将待排序的元素分成两部分，其中一部分的所有元素都比基准元素小，另一部分的所有元素都比基准元素大。这个过程叫做划分（partition）。

3. 然后再递归地对这两部分元素分别进行快速排序，直到整个序列有序。

具体的划分过程如下：

1. 定义两个指针left和right，分别指向序列的最左端和最右端。

2. 选定基准元素pivot，将pivot存放到一个临时变量中，空出pivot所在的位置。

3. 从left开始向右遍历，找到第一个大于等于pivot的元素，记为i。

4. 从right开始向左遍历，找到第一个小于等于pivot的元素，记为j。

5. 如果i < j，则交换i和j的位置。

6. 如果i >= j，则跳出循环。

7. 将pivot放回到i所在的位置。

8. 递归地对左半部分和右半部分进行快速排序。

快速排序的时间复杂度为O(nlogn)，空间复杂度为O(logn)。在大多数情况下，快速排序是最优秀的排序算法之一，但在极端情况下，比如待排序的序列已经有序或者基本有序时，快速排序的性能会下降到O(n^2)，因此需要对其进行优化，如随机选择基准元素、三数取中等。

---

Java代码实现

public class QuickSort {
    public void quickSort(int[] nums, int left, int right) {
        if (left >= right) {
            return;
        }
        int pivot = partition(nums, left, right);
        quickSort(nums, left, pivot - 1);
        quickSort(nums, pivot + 1, right);
    }
    
    private int partition(int[] nums, int left, int right) {
        int pivot = nums[left];
        int i = left, j = right;
        while (i < j) {
            while (i < j && nums[j] >= pivot) {
                j--;
            }
            if (i < j) {
                nums[i] = nums[j];
                i++;
            }
            while (i < j && nums[i] < pivot) {
                i++;
            }
            if (i < j) {
                nums[j] = nums[i];
                j--;
            }
        }
        nums[i] = pivot;
        return i;
    }
}

---

C++代码实现

void quickSort(vector<int>& nums, int left, int right) {
    if (left >= right) {
        return;
    }
    int pivot = partition(nums, left, right);
    quickSort(nums, left, pivot - 1);
    quickSort(nums, pivot + 1, right);
}

int partition(vector<int>& nums, int left, int right) {
    int pivot = nums[left];
    int i = left, j = right;
    while (i < j) {
        while (i < j && nums[j] >= pivot) {
            j--;
        }
        if (i < j) {
            nums[i] = nums[j];
            i++;
        }
        while (i < j && nums[i] < pivot) {
            i++;
        }
        if (i < j) {
            nums[j] = nums[i];
            j--;
        }
    }
    nums[i] = pivot;
    return i;
}

---

Python代码实现

def quick_sort(nums, left, right):
    if left >= right:
        return
    pivot = partition(nums, left, right)
    quick_sort(nums, left, pivot - 1)
    quick_sort(nums, pivot + 1, right)

def partition(nums, left, right):
    pivot = nums[left]
    i, j = left, right
    while i < j:
        while i < j and nums[j] >= pivot:
            j -= 1
        if i < j:
            nums[i] = nums[j]
            i += 1
        while i < j and nums[i] < pivot:
            i += 1
        if i < j:
            nums[j] = nums[i]
            j -= 1
    nums[i] = pivot
    return i

---

无论哪种语言实现，快速排序的基本思路都是相同的。其中，partition函数用于划分序列，并返回基准元素的下标，quickSort函数则是递归调用自身，对划分后的子序列进行排序。时间复杂度为O(nlogn)，是一种高效的排序算法。