四种常用的排序算法

快速排序
选择排序
插入排序
冒泡排序

快速排序是一种基于分治思想的排序算法，其核心算法可以概括为以下三个步骤：

选择一个基准元素（pivot），将待排序序列分成两部分，一部分元素值比基准元素小，另一部分元素值比基准元素大；
递归地对小于基准元素的子序列和大于基准元素的子序列进行排序；
将排好序的两部分序列合并起来，即可得到完整的有序序列。
具体实现时，可以采用多种方式选择基准元素，例如选择第一个元素、最后一个元素、中间的元素，或者随机选择一个元素作为基准元素。同时，还可以通过优化枢纽元素的选择，减少快排的最坏情况的时间复杂度。

void quicksort(vector<int>& nums, int left, int right) {
    if (left >= right) return;  // 基线条件

    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];
        while (i < j && nums[i] < pivot) i++;
        if (i < j) nums[j--] = nums[i];
    }
    nums[i] = pivot;  // 将基准元素放置在正确的位置

    quicksort(nums, left, i - 1);   // 递归排序左边的子序列
    quicksort(nums, i + 1, right);  // 递归排序右边的子序列
}

快速排序是一种经典的排序算法，其核心思想是通过递归分治的方式将问题规模不断缩小，最终实现对整个序列的排序。除了标准的快速排序算法外，还有一些变种的写法。

随机化快速排序：在标准快速排序算法中，选择的基准元素对算法的性能有很大的影响。为了减少这种影响，可以随机选择基准元素，从而提高算法的性能。

三路快速排序：在标准快速排序算法中，将整个序列分为两部分，一部分小于基准元素，一部分大于基准元素。但如果存在大量的相同元素，这种分割方式可能会导致递归树的不平衡，从而影响算法的性能。为了解决这个问题，可以将序列分成三部分，小于基准元素的部分、等于基准元素的部分和大于基准元素的部分。

双路快速排序：在标准快速排序算法中，对于小于等于基准元素的元素和大于等于基准元素的元素，分别在序列的左右两边，可能导致递归树的不平衡。为了解决这个问题，可以使用双路快速排序算法，即在序列的左右两端同时进行比较和交换。

这些变种的快速排序算法都是基于快速排序的基本思想，通过不同的分割方式、基准元素的选择等来提高算法的性能。您可以根据具体问题的特点选择适合自己的排序算法。

1.随机化快速排序

void quickSort(int arr[], int left, int right) 
{
    if (left >= right) {
        return;
    }
    int pivotIndex = rand() % (right - left + 1) + left; // 随机选择基准元素
    swap(arr[pivotIndex], arr[right]); // 将基准元素交换到序列末尾
    int i = left - 1;
    for (int j = left; j < right; j++) {
        if (arr[j] < arr[right]) {
            i++;
            swap(arr[i], arr[j]);
        }
    }
    i++;
    swap(arr[i], arr[right]); // 将基准元素交换到正确的位置
    quickSort(arr, left, i - 1);
    quickSort(arr, i + 1, right);
}

2.三路快速排序

void quickSort(int arr[], int left, int right)
 {
    if (left >= right) {
        return;
    }
    int lt = left, gt = right, i = left + 1;
    int pivot = arr[left];
    while (i <= gt) {
        if (arr[i] < pivot) {
            swap(arr[i], arr[lt]);
            i++;
            lt++;
        } else if (arr[i] > pivot) {
            swap(arr[i], arr[gt]);
            gt--;
        } else {
            i++;
        }
    }
    quickSort(arr, left, lt - 1);
    quickSort(arr, gt + 1, right);
}

3.双路快速排序

void quickSort(vector<int>& nums, int left, int right) {
    if (left >= right) return;

    int lt = left, gt = right;
    int i = left + 1;
    int pivot = nums[left];

    while (i <= gt) {
        if (nums[i] < pivot) {
            swap(nums[i], nums[lt]);
            i++;
            lt++;
        } else if (nums[i] > pivot) {
            swap(nums[i], nums[gt]);
            gt--;
        } else {
            i++;
        }
    }

    quickSort(nums, left, lt - 1);
    quickSort(nums, gt + 1, right);
}

选择排序是一种简单的排序算法，其核心思想是每次从未排序的元素中选择最小（或最大）的元素，将其放置到已排序的末尾。重复这个过程直到所有元素都排好序。

选择排序的实现步骤如下：

从序列中找出最小的元素，记为min；
将最小元素min与序列的第一个元素交换位置；
从剩余的n-1个元素中找出最小的元素，记为min2；
将min2与序列的第二个元素交换位置；
重复上述步骤，直到序列中所有元素都排好序。
选择排序的时间复杂度为O(n^2)，空间复杂度为O(1)。尽管选择排序的时间复杂度较高，但它比冒泡排序效率要高一些，因为它在每一轮排序中只需要交换一次元素。另外，选择排序是一种不稳定的排序算法，因为交换过程中可能会改变相同元素的相对顺序。

void selectionSort(vector<int>& arr, int n) 
{
    for (int i = 0; i < n - 1; i++) 
    {
        int minIdx = i;
        for (int j = i + 1; j < n; j++) 
        {
            if (arr[j] < arr[minIdx]) 
            {
                minIdx = j;
            }
        }
        if (minIdx != i) 
        {
            swap(arr[i], arr[minIdx]);
        }
    }
}

插入排序的基本思想是将数组分为已排序区间和未排序区间，初始已排序区间只有一个元素，每次取未排序区间的第一个元素，在已排序区间中从后向前扫描，找到相应位置并插入。重复这个过程，直到未排序区间为空。

void insertionSort(vector<int>& arr, int n) 
{
    for (int i = 1; i < n; i++) 
    {
        int j = i;
        while (j > 0 && arr[j] < arr[j - 1]) 
        {
            swap(arr[j], arr[j - 1]);
            j--;
        }
    }
}

冒泡排序（Bubble Sort）是一种简单的排序算法，它重复地走访过要排序的序列，一次比较两个元素，如果它们的顺序错误就把它们交换过来，直到没有元素再需要交换，排序完成。

冒泡排序的核心思想是比较相邻的两个元素，如果顺序不对就交换，这样一轮比较下来可以保证最大的元素被交换到了最后面，然后再对剩下的元素进行相邻两个元素的比较交换，直到整个序列有序为止。

void bubbleSort(vector<int>& arr)
{
    int n = arr.size();

    for (int i = 0; i < n-1; ++i)
        for (int j = 0; j < n-i-1; ++j)
            if (arr[j] > arr[j+1])
            {
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
}