快速排序法-Quick Sort

【算法思想】
(1)在当前数组中选择一个数为基点，使它处于排好序的位置，并且这个数左边的数小于它，右边的数大于它。
在这里插入图片描述
(2)分别对这个基点左右两边的数进行相同操作。
【Partition】

(1)通常选取数组最左边的数作为分界点元素，这里我们标记为l，然后我们开始遍历剩余的数组，将其分为小于v的部分和大于v的部分，这两个部分的分界点我们用j来表示。当前访问的元素我们记为i。这样arr[l+1…j]<v,arr[j+1…i-1]>v。
(2)下面开始分两种情况去讨论当前元素i如何变化才能保证数组保持这种性质。如果当前元素是比v还要大的，即e>v，这个元素直接放在>v部分的后面即可，此时i++，继续考虑下一个元素即可。在这里插入图片描述

如果当前元素小于v，则需要将j+1位置的元素和i位置的元素进行交换，j++，然后i++继续考虑下一个元素。

(3)最后，只需要将l位置的元素和j位置的元素交换位置即可。

【代码】
<quick_sort.cpp>

#include <iostream>
#include <algorithm>
#include "MergeSort.h"
#include "SortTestHelper.h"
using namespace std;
//对arr[l...r]部分进行partition操作
//返回p，使得arr[l...p-1] < arr[p] ; arr[p+1...r] > arr[p]
template <typename T>
int __partition(T arr[], int l, int r) {
    swap(arr[l], arr[rand()%(r-l+1)+l]);
    T v = arr[l];
    //arr[l+1...j] < v ; arr[j+1...i) > v
    int j = l;
    for(int i = l + 1; i <= r; i++) {
        if(arr[i] < v) {
            swap(arr[j+1], arr[i]);
            j++;
        }
    }
    swap(arr[l], arr[j]);
    return j;
}
//对arr[l...r]部分进行快速排序
template <typename T>
void __quickSort(T arr[], int l, int r) {
    /*
    //当数据量较小时，可以使用插入排序做优化
    if(l >= r) {
		insertionSort(arr, l, r);
		reuturn;
	}
	*/
    if(l >= r)
        return;
    int p = __partition(arr, l, r);
    __quickSort(arr, l, p - 1);
    __quickSort(arr, p + 1, r);
}
template <typename T>
void quickSort(T arr[], int n) {
    __quickSort(arr,0, n - 1);
}

int main() {
    int n = 1000000;
    cout << "Test for Random Array, size = " << n << ", random range [0, " << n << "]" << endl;
    int* arr1 = SortTestHelper::generateRandomArray(n, 0, n);
    int* arr2 = SortTestHelper::copyIntArray(arr1, n);
    SortTestHelper::testSort("Merge Sort", mergeSort, arr1, n);
    SortTestHelper::testSort("Quick Sort", quickSort, arr2, n);
    delete[] arr1;
    delete[] arr2;
    return 0;
}

<MergeSort.h>

#ifndef SORTALGORITHM_MERGESORT_H
#define SORTALGORITHM_MERGESORT_H
#include <iostream>
#include <algorithm>
#include "SortTestHelper.h"
#include "InsertionSort.h"
using namespace std;
//将arr[l...mid]和arr[mid+1...r]两部分进行归并
template <typename T>
void __merge(T arr[], int l, int mid, int r) {
    T aux[r - l + 1];
    for(int i = l; i <= r; i++) {
        aux[i - l] = arr[i]; //辅助数组
    }
    int i = l, j = mid + 1;
    for(int k = l; k <= r; k++) {
        if(i > mid) {
            arr[k] = aux[j - l];
        }
        else if(j > r) {
            arr[k] = aux[i - l];
            i++;
        }
        else if(aux[i - l] < aux[j - l]) {
            arr[k] = aux[i - l];
            i++;
        }
        else {
            arr[k] = aux[j - l];
            j++;
        }
    }
}
//递归使用归并排序，对arr[l...r]的范围进行排序
template <typename T>
void __mergeSort(T arr[], int l, int r) {
//    if(l >= r)
//        return;
//引入插入排序改进归并排序
    if(r - l <= 15) {
        insertionSort(arr, l, r);
        return;
    }
    int mid = (l + r) / 2;
    __mergeSort(arr, l, mid);
    __mergeSort(arr, mid + 1, r);
    if(arr[mid] > arr[mid + 1])
        __merge(arr, l, mid, r);
}

template <typename T>
void mergeSort(T arr[], int n) {

    __mergeSort(arr, 0, n - 1);
}
#endif //SORTALGORITHM_MERGESORT_H

<SortTestHelper.h>

#ifndef SELECTIONSORT_SORTTESTHELPER_H
#define SELECTIONSORT_SORTTESTHELPER_H

#include <iostream>
#include <ctime>
#include <cassert>
using namespace std;
namespace SortTestHelper {
    int* generateRandomArray(int n, int rangeL, int rangeR) {
        assert(rangeL <= rangeR);
        int *arr = new int[n];
        srand(time(NULL));
        for(int i = 0; i < n; i++) {
            arr[i] = rand() % (rangeR - rangeL + 1) + rangeL;
        }
        return arr;
    }
    template <typename T>
    void printArray(T arr[], int n) {
        for(int i = 0; i < n; i++) {
            cout << arr[i] << " ";
        }
        cout << endl;
        return;
    }
    template <typename T>
    bool isSorted(T arr[], int n) {
        for(int i = 0; i < n - 1; i++) {
            if(arr[i] > arr[i + 1])
                return false;
        }
        return true;
    }

    template <typename T>
    void testSort(string sortName, void(*sort)(T[], int), T arr[], int n) {
        clock_t startTime = clock();
        sort(arr, n);
        clock_t endTime = clock();
        assert(isSorted(arr, n));
        cout << sortName << " : " << double(endTime - startTime) / CLOCKS_PER_SEC << " s" << endl;
        return;
    }

    int* copyIntArray(int a[], int n) {
        int* arr = new int[n];
        copy(a, a+n, arr);
        return arr;
    }

    int *generateNearlyOrderedArray(int n, int swapTimes) {
        int *arr = new int[n];
        for(int i = 0; i < n; i++) {
            arr[i] = i;
        }
        srand(time(NULL));
        for(int i = 0; i < swapTimes; i++) {
            int posx = rand()%n;
            int posy = rand()%n;
            swap(arr[posx], arr[posy]);
        }
        return arr;
    }
}
#endif //SELECTIONSORT_SORTTESTHELPER_H

【随机化快速排序】
【注】当对近乎有序的数组进行排序是，快速排序的效率比归并排序效率低很多。
在这里插入图片描述
归并排序是将一个数组不断地一分为二，一共log(n)层，处理每层需要n，所以是O(nlogn)级别的算法。

归并排序是将一个数组平均分为两个部分的，而快速排序却不能保证均分，导致整个递归树平衡性很差，并且我们不能保证这棵树的高度是log(n)，当对一个完全有序的数组进行快速排序，将退化为O(n²)级别的算法，递归树的高度为n，处理每层需要n。
在这里插入图片描述
【改进方法】
随机基准点，而不是每次以数组第一个元素为基准点，这样该算法退化为O(n²)的可能性几乎为0。
【随机化快速排序法代码】

//对arr[l...r]部分进行partition操作
//返回p，使得arr[l...p-1] < arr[p] ; arr[p+1...r] > arr[p]
template <typename T>
int __partition(T arr[], int l, int r) {
    swap(arr[l], arr[rand()%(r-l+1)+l]);
    T v = arr[l];
    //arr[l+1...j] < v ; arr[j+1...i) > v
    int j = l;
    for(int i = l + 1; i <= r; i++) {
        if(arr[i] < v) {
            swap(arr[j+1], arr[i]);
            j++;
        }
    }
    swap(arr[l], arr[j]);
    return j;
}
//对arr[l...r]部分进行快速排序
template <typename T>
void __quickSort(T arr[], int l, int r) {
    if(l >= r)
        return;

    int p = __partition(arr, l, r);
    __quickSort(arr, l, p - 1);
    __quickSort(arr, p + 1, r);
}
template <typename T>
void quickSort(T arr[], int n) {
    srand(time(NULL));
    __quickSort(arr,0, n - 1);
}

来源：CSDN

作者：King && Coder

链接：https://blog.csdn.net/weixin_41462017/article/details/104736052

标签

sort