算法思想:分而治之(已选择排序为基础)
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();
}