【算法】排序详解-----快速排序

1、快速排序

快速排序是一种二叉树结构的交换排序算法。

快速排序的时间复杂度：

最优场景（假设每次划分都是均衡的）：O（N log2N）

最差场景： O(N^2)

2、方法一：

2.1 排序方法

1. 每次选一个基准值，这里简单起见，直接每次取要排序区域的最后一位数据作为基准值。
2. 设置两个指针，begin指针 指向要排序区域的起始位置，end指针 则指向要排序区域的最后位置。
3. begin指针寻找比基准值大的元素，end指针寻找比基准值小的元素。
4. 交换begin 指针与end 指针的内容。
5. 退出循环后，交换基准值与结束时begin,end指针所指向的值。

2.2 实现源码

#include<stdio.h>
#include<iostream>

using namespace std;

//左闭右闭区间
void QuickSort_temp1(int * start,int * last){
    if (last <= start)
        return;
    int *begin = start;
    int *end = last;
    int key = *last;
    while (end > begin){
        if (*begin < key)
            begin++;
        if (*end>key)
            end--;
        swap(*begin, *end);
    }
    swap(*begin, key);
    QuickSort_temp1(start, begin-1);
    QuickSort_temp1(begin+1, last);
}

void Print(int arr[],int size){
    for (size_t i = 0; i < size; i++){
        cout << arr[i] << "  ";
    }
    cout << endl;
}

int main(){
    int arr[] = { 2, 5, 4, 9, 3, 6, 8, 7, 1, 0 };
    int size = sizeof(arr) / sizeof(arr[0]);
    Print(arr, size);
    QuickSort_temp1(arr, arr + size - 1);
    cout << "QuickSort_temp1:" << endl;
    Print(arr, size);

    return 0;
}

2.3 实现结果

---

3、挖坑法

3.1 排序方法

1. 每次选一个基准值，这里简单起见，直接每次取要排序区域的最后一位数据作为基准值。
2. 设置两个指针，begin指针 指向要排序区域的起始位置，end指针 则指向要排序区域的最后位置。
3. begin指针寻找比基准值大的元素，将begin指针所指的值放入key的位置上。
4. end指针寻找比基准值小的元素，将end指针所指向的值放入空出的位置上。
5. 退出循环后，最后将key值填入空出的位置上。

3.2 实现代码

#include<stdio.h>
#include<iostream>

using namespace std;

int Partition(int arr[],int len,int start,int last){
    //挖坑法
    if (arr == NULL || len <= 0 || start < 0 || last >= len)
        throw new exception("Invalid Parameters");
    int begin = start;
    int end = last;
    int key = arr[last];
    while (begin < end){
        while (arr[begin] < key&&begin < end){
            begin++;
        }
        if (begin<end){
            arr[end] = arr[begin];
            end--;;
        }
        while (arr[end]>key&&begin<end){
            end--;
        }
        if (begin < end){
            arr[begin] = arr[end];
            begin++;
        }
    }
    arr[begin] = key;
    return begin;
}


void QuickSort(int arr[], int len, int start, int end){
    if (start == end)
        return;
    int index = Partition(arr, len, start, end);
    if (index>start)
        QuickSort(arr, len, start, index - 1);
    if (index < end)
        QuickSort(arr, len, index + 1, end);

}

void Print(int arr[],int size){
    for (size_t i = 0; i < size; i++){
        cout << arr[i] << "  ";
    }
    cout << endl;
}

int main(){
    int arr[] = { 2, 5, 4, 9, 3, 6, 8, 7, 1, 0 };
    int size = sizeof(arr) / sizeof(arr[0]);
    cout << "原数组：" << endl;
    Print(arr, size);
    QuickSort(arr, size,0,size-1);
    cout << "快速排序挖坑法:" << endl;
    Print(arr, size);

    return 0;
}

3.3 结果

---

4、前后指针法

可用于链表

【数据结构】快速排序优化版-前后指针法