[数据结构和算法006]快速排序以及其衍生算法-优快云博客

本文链接：https://blog.youkuaiyun.com/jasonlu888/article/details/143353324

前言：

本文将介绍如何分别在数组和链表中实现快速排序，以及实现随机化快速排序。最后我们介绍一些由partition衍生出的算法:利用快速选择求出TOPK

一、快速排序的原理以及实现：

1.在数组中的实现：

思想：第一趟排序确定第一个元素（枢轴）的位置（理想状态中枢轴左边的数据比它都小，枢轴右边的数据比它都大）随后递归的确定左右区间中每个元素的位置，最后每个元素都处在自己的位置。

实现方法：使用函数partition（其功能可以使枢轴元素处于其排序后最终的位置），具体实现方法是采用两个指针，一个从头部向尾部出发，一个从尾部向头部出发，直到二者相遇。头指针指向的元素比枢轴元素pivot大的时候：该元素与枢轴元素交换位置，同时尾指针前移一个单位。当尾指针指向的元素比枢轴元素小的时候：该元素与枢轴元素交换位置，同时头指针后移一个单位。下面给出示意图：

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

随后我们确定了pivot元素的位置以后，我们把区间分为两部分，接下来我们递归调用排序函数即可

void quicksort(int* a, int left, int right) {
	if (right > left) {
		int mid = partition(a, left, right);
		quicksort(a, left, mid - 1);
		quicksort(a, mid + 1, left);
	}
}

2.在链表中实现：

首先该算法的局限性在于，我们必须有链表的尾指针，此外我们还需要在头节点之前创建一个哑巴结点；这里我们令枢轴元素为第一个元素，此外我们需要设计一个pre指针和p指针；与数组中的快速排序中同时从尾部和首部出发不同，在链表中我们仅从首部出发。下面是示意图：

此时枢轴元素4的右侧有0个记录，我们需要使用指针p向右遍历来找到比枢轴元素小的元素后放到枢轴右侧即可，随后递归调用函数对pivot两侧排序

#include <iostream>
#include <vector>
using namespace std;

struct ListNode {
    int val;
    ListNode* next;
    ListNode(int x) : val(x), next(NULL) {}
};

// 快速排序函数
ListNode* quicksort(ListNode* start, ListNode* end) {
    if (start == NULL || start == end || start->next == end) {
        return start;
    }
    ListNode* dummy = new ListNode(0);
    dummy->next = start;
    //pre是p的前驱，pivot是枢轴结点的指针。
    ListNode* pre = dummy, * pivot = start, * p = start->next, * r;
    while (p != end) {
        if (pivot->val > p->val) {
            p = p->next;
            r = dummy->next;
            dummy->next = pre->next;
            pre->next->next = r;
            pre->next = p;
        }
        else {
            pre = p;
            p = p->next;
        }
        
    }
    dummy->next = quicksort(dummy->next, pivot);
    pivot->next = quicksort(pivot->next, end);
    return quicksort(dummy, pivot);
}

二、随机化快速排序：

1.算法思想与实现：

由于当待排序数组本来为有序的时候我们使用快速排序会可能导致结果没有那么理想，快速排序也不会变得真正快速，我们选择从序列里随机的找一个元素而非总是使用第一个元素。我们首先生成在[left,right]直接随机的生成一个数据，随后令该位置与left交换位置后再进行快速排序即可。

#include <cstdlib> // for rand() and srand()
#include <ctime>   // for time()
#include <iostream> // for cout

using namespace std;

void swap(int& a, int& b) {
    int temp = a;
    a = b;
    b = temp;
}

int partition(int* a, int left, int right) {
    // Randomly select a pivot index between left and right
    int randomPivotIndex = left + rand() % (right - left + 1);
    // Swap the randomly selected pivot with the first element
    swap(a[left], a[randomPivotIndex]);
    
    int pivot = a[left];
    int i = left;
    int j = right;
    while (i < j) {
        while (i < j && a[j] > pivot) {
            j--;
        }
        if (i < j) {
            swap(a[i++], a[j]);
        }
        while (i < j && a[i] <= pivot) {
            i++;
        }
        if (i < j) {
            swap(a[i], a[j--]);
        }
    }
    return i;
}

void quickSort(int* a, int left, int right) {
    if (left < right) {
        int pi = partition(a, left, right);
        quickSort(a, left, pi - 1);
        quickSort(a, pi + 1, right);
    }
}

int main() {
    srand(time(0)); // Seed the random number generator
    
    int arr[] = {10, 7, 8, 9, 1, 5};
    int n = sizeof(arr) / sizeof(arr[0]);
    
    quickSort(arr, 0, n - 1);
    
    for (int i = 0; i < n; ++i) {
        cout << arr[i] << " ";
    }
    cout << endl;
    
    return 0;
}

三、利用快速排序解决TOPK：

1.算法思想与实现：

以下是利用快速排序解决TOP K问题的步骤：

选择基准点：从数组中选择一个元素作为基准点（pivot）。
分区操作：将数组分成两部分，一部分包含所有大于等于基准点的元素，另一部分包含所有小于基准点的元素。
递归处理：
- 如果基准点的位置正好是第K个位置，那么基准点及其左边的所有元素就是前K个最大的元素。
- 如果基准点的位置小于K，则在基准点的右边继续寻找第K大的元素。
- 如果基准点的位置大于K，则在基准点的左边继续寻找第K大的元素。
终止条件：当找到第K个位置时，停止递归

下面是一个前k小的实现案例

#include <iostream>
#include <vector>
#include <algorithm> // for std::swap

// Partition function as provided
int partition(int* a, int left, int right) {
    int pivot = a[left];
    int i = left;
    int j = right;
    while (i < j) {
        while (i < j && a[j] > pivot) {
            j--;
        }
        if (i < j) {
            std::swap(a[i++], a[j]);
        }
        while (i < j && a[i] > pivot) {
            i++;
        }
        if (i < j) {
            std::swap(a[i], a[j--]);
        }
    }
    return i;
}

// Quickselect function to find the k-th smallest element
void quickSelect(int* a, int left, int right, int k) {
    if (left < right) {
        int pi = partition(a, left, right);
        if (pi == k) {
            return;
        } else if (pi > k) {
            quickSelect(a, left, pi - 1, k);
        } else {
            quickSelect(a, pi + 1, right, k);
        }
    }
}

// Function to find the top k elements in an array
std::vector<int> findTopK(int* arr, int n, int k) {
    std::vector<int> result;
    for (int i = 0; i < k; ++i) {
        quickSelect(arr, 0, n - 1, i);
        result.push_back(arr[i]);
    }
    return result;
}

int main() {
    int arr[] = {3, 2, 1, 5, 6, 4};
    int n = sizeof(arr) / sizeof(arr[0]);
    int k = 3;
    std::vector<int> topK = findTopK(arr, n, k);

    std::cout << "Top " << k << " elements: ";
    for (int num : topK) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}