【c++】快速排序

算法思想：分而治之（已选择排序为基础）
1、选取第一个数为基准
2、将比基准小的数交换到前面，比基准大的数交换到后面
3、对左右区间重复第二步，直到各区间只有一个数
我们从数组中选择一个元素，我们把这个元素称之为中轴元素吧，然后把数组中所有小于中轴元素的元素放在其左边，所有大于或等于中轴元素的元素放在其右边，显然，此时中轴元素所处的位置的是有序的。也就是说，我们无需再移动中轴元素的位置。
从中轴元素那里开始把大的数组切割成两个小的数组(两个数组都不包含中轴元素)，接着我们通过递归的方式，让中轴元素左边的数组和右边的数组也重复同样的操作，直到数组的大小为1，此时每个元素都处于有序的位置。

时间复杂度：O(NlogN)

#include <iostream>
#include <vector>
#include <cstdlib>
#include <ctime>
using std::cout;
using std::endl;
using std::vector;
const int numsLen = 10;
int partition_baseRight(vector<int>& nums, int left, int right) { //推荐
    //如果不是以最后一个元素为基准，则先执行一步交换
    //std::swap(nums[X, right]);
	int i, j;
	for (i = left, j = left; i < right; i++) {
		if (nums[i] < nums[right]) {
			std::swap(nums[i], nums[j]);
            ++j;
		}
	}
	std::swap(nums[j], nums[right]);
	return j;
}
int partition_baseLeft(vector<int>& nums, int left, int right) {
	int pivot = nums[left];
	//从后往前找比他小的放前面，从前往后找比它大的放后面
	//以第一个数为基准，必须先从后往前走，再从前往后走
	while (left < right && nums[right] >= pivot) {
		right--;
	}  //跳出此循环，代表right找到了比pivot小的数字，所以此时nums[left]=nums[right]
	if (left < right) {
		nums[left] = nums[right];
	}
	while (left < right && nums[left] <= pivot) {
		left++;
	}//同理
	if (left < right) {
		nums[right] = nums[left];
	}
	if (left == right) {
		nums[left] = pivot;
	}
	return left;
}
 
void quickSort(vector<int>& nums, int left, int right) {
	if (left < right) {
		//int pivot = partition_baseLeft(nums, left, right);
		int pivot = partition_baseRight(nums, left, right);
		quickSort(nums, left, pivot - 1);
		quickSort(nums, pivot + 1, right);
	}
}

void print(vector<int>& nums) {
	for (int i = 0; i < nums.size(); i++) {
		cout << nums[i] << ' ';
	}
	cout << endl;
}

void test() {
	std::srand(std::time(nullptr));
	vector<int> nums;
	for (int i = 0; i < numsLen; i++) {	//如果容器比较大且存储大量相同的数，47行可能反复入栈导致栈溢出
		nums.push_back(std::rand()%99);	
	}
	time_t beg = std::time(nullptr);
	//print(nums);
	quickSort(nums, 0, nums.size()-1);
	//print(nums);
	time_t end = std::time(nullptr);
	cout << end - beg << endl;
}

int main() {
	test();
}

如果容器比较大且存储大量相同的数，47行可能反复入栈导致栈溢出（递归导致的）

非递归的快速排序

#include <cstdlib>
void qsort (void* base, size_t num, size_t size, int (*compare)(const void*,const void*));

compar
Pointer to a function that compares two elements.
This function is called repeatedly by qsort to compare two elements. It shall follow the following prototype:

Taking two pointers as arguments (both converted to const void*). The function defines the order of the elements by returning (in a stable and transitive manner):

return value	meaning
<0	The element pointed to by p1 goes before the element pointed to by p2
0	The element pointed to by p1 is equivalent to the element pointed to by p2
>0	The element pointed to by p1 goes after the element pointed to by p2

int compare(const void *p1, const void *p2) {
    int *pleft = (int*)p1;
    int *pright = (int*)p2;
    return *pleft -*pright;
}
qsort(nums, numsLen, sizeof(int), compare);

注意第一个参数类型应该是数组类型，不能说vector

#include <iostream>
#include <vector>
#include <cstdlib>
#include <ctime>
using std::cout;
using std::endl;
using std::vector;

const int numsLen = 20000000;

int compare(const void* p1, const void* p2) {
	int* left = (int*)p1;
	int* right = (int*)p2;
	return *left - *right;
}

void test() {
	std::srand(std::time(nullptr));
	vector<int> nums;
	for (int i = 0; i < numsLen; i++) {
		nums.push_back(std::rand()%99);
	}
	time_t beg = std::time(nullptr);
	//print(nums);
	qsort(&nums[0], numsLen, sizeof(int), compare);
	//print(nums);
	time_t end = std::time(nullptr);
	cout << "共运行： " << end - beg << 's'<< endl;
}

int main() {
	test();
}