问题引入
从底层原理去分析，快排也并不是太难。理解层次上不难，但是要写出来，还是得花时间的，边界有点烦人。
是否听过荷兰国旗的问题呢？
荷兰国旗1
荷兰国旗1：给定一个数组
arr，和一个数num,请把小于等于num的数放在数组的左边，大于num的数放在数组的右边。要求额外空间复杂度O(1)，时间复杂度O(N)
例如：给定一个数组[2,6,9,8,4,5,6,4,6,7,1]; 和
num = 5，根据这个num去划分这个数组，划分成两个区域<=num和>num。
如何实现分层呢？单指针
如何实现呢？一个指针
frontier指向小于等于的边界区域，frontier的初始值为-1，一个变量i指向第一个元素，用来遍历数组，当遍历到一个元素小于num，和小于等于区域外第一个元素交换，小于等于区域扩大一个元素（frontier自增），i自增，当不相等的时候，i自增，frontier不动。重复上述过程直到结束。
#include<stdio.h>
int main()
{
int arr[] = { 2,6,9,8,4,5,6,4,6,7,1 };
int sz = sizeof(arr) / sizeof(arr[0]);
int frontier = -1;//小于等于区域的边界
int i = 0;
int num = 5;
while (i < sz)6
{
if (arr[i] <= num)
{
int tmp = arr[i];
arr[i] = arr[frontier + 1];
arr[frontier + 1] = tmp;
frontier++;
i++;
}
else
{
i++;
}
}
for (i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
return 0;
}
荷兰国旗2
给定一个数组arr，和一个数num，请把小于num的数放在数组的左边，等于num的数放在数组的中间，大于num的数放在数组的右边。要求额外空间复杂度O(1)，时间复杂度O(N)。
例如：给定一个数组2,3,5,6,9,6,1,3,4,6,5,8]; 和
num = 5，根据这个num去划分这个数组，划分成三个区域<num和==num和>num。
如何实现分层呢？双指针
双指针：用两个变量对指针划分区域。
如何实现呢？一个指针less一个指针more，分别为小于区域，和大于区域的边界，初始值分别为-1和最大下标+1，另有一个变量i，去遍历数组。当小于num，和小于区域外的第一个元素交换，less和i都自增；如果等于num，i自增；当大于num，和大于区域外的第一个元素进行交换，more自减，i不能自增，因为换过来的数是一个新数，不能确定和num的关系。那循环结束的条件是什么呢？当i和more相遇的时候，是不是就意味着已经分好了呢。
#include<stdio.h>
int main()
{
int arr[] = { 2,3,5,6,9,6,1,3,4,6,5,8 };
int sz = sizeof(arr) / sizeof(arr[0]);
int less = -1;//小于区域的边界
int more = sz - 1;//大于区域的边界
int i = 0;
int num = 5;
while (i < more)
{
if (arr[i] < num)
{
int tmp = arr[i];
arr[i] = arr[less + 1];
arr[less + 1] = tmp;
i++;
less++;
}
else if (arr[i] > num)
{
int tmp = arr[i];
arr[i] = arr[more-1];
arr[more - 1] = tmp;
more--;
}
else
{
i++;
}
}
for (i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
printf("\n");
return 0;
}
快排
以上两个版本的荷兰国旗，就是快排的底层原理。
快排1.0
快排1.0根据荷兰国旗1进而改进的，荷兰国旗中的
num在快排中如何体现呢？是以数组下标最大的那个元素作为num，进行分层，当分层完成后，还需要将num和小于等于区域外层第一个数交换，才算完成了一次排序。换好之后，num作为为分界，对左右两边的部分数组重复上述过程。（本质是二叉树的遍历）
代码如下：
做了一些优化，需要熟悉自增，自减
#include<stdio.h>
void Swap(int* arr, int a ,int b)
{
int tmp = arr[a];
arr[a] = arr[b];
arr[b] = tmp;
}
int partition(int* arr, int left, int right)
{
int forntier = left - 1;
while (left < right)
{
if (arr[left] <= arr[right])
{
Swap(arr, left++, ++forntier);
}
else
{
left++;
}
}
Swap(arr, forntier + 1, right);
return forntier + 1;
}
void QuickSort(int* arr, int left, int right)
{
if (right <= left)
return;
int forntier = partition(arr, left, right);
QuickSort(arr, left, forntier - 1);
QuickSort(arr, forntier + 1 , right);
}
int main()
{
int arr[] = { 2,6,9,8,4,5,6,4,6,7,5 };
int sz = sizeof(arr) / sizeof(arr[0]);
int i = 0;
QuickSort(arr, 0, sz - 1);//参数传的时候要注意区间，传的是闭区间
for (i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
return 0;
}
第一次partition
和小于等于区域外的第一个数交换
这里是
left-1，每一次递归进来它的边界都是不同的，是左边界-1。
快排2.0
快排2.0依据荷兰国旗2进行改版的，同样是以数组下标最大的元素作为划分，划分成小于、等于、大于，三个区域，
partition过后，还需要将数组下标最大的元素和大于区域的第一个元素进行交换，并且返回两个边界，等于区域的左边界，和等于区域的右边界，在这以这两个边界为划分，重复上述过程。
这种方法比快排1.0快一点，可以一次排好多个值。
同样把荷兰国旗2的代码进行了优化，需要熟悉自增，自减
#include<stdio.h>
void Swap(int* arr, int a ,int b)
{
int tmp = arr[a];
arr[a] = arr[b];
arr[b] = tmp;
}
int* partition(int* arr, int left, int right)
{
int less = left - 1;
int more = right;
while (left < more)
{
if (arr[left] > arr[right])
{
Swap(arr, left, --more);
}
else if (arr[left] < arr[right])
{
Swap(arr, left++, ++less);
}
else
{
left++;
}
}
Swap(arr, more, right);
int* p = (int*)malloc(sizeof(int) * 2);
p[0] = less + 1;
p[1] = more;
return p;
}
void QuickSort(int* arr, int left, int right)
{
if (right <= left)
return;
int* p = partition(arr, left, right);
QuickSort(arr, left, p[0] - 1);
QuickSort(arr, p[0] + 1, right);
free(p);
}
int main()
{
int arr[] = { 2,3,5,6,9,6,1,3,4,6,5,5 };
int sz = sizeof(arr) / sizeof(arr[0]);
int i = 0;
QuickSort(arr, 0, sz - 1);//参数传的时候要注意区间，传的是闭区间
for (i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
return 0;
}
第一次
partition
和大于区域的第一个数交换，这也是为什么
more不用-1
原本不是等于区域的边界，但是交换后就是了。
返回等于区域的边界
快排3.0
不管是快排1.0，还是快排2.0，都能找到最坏的情况，已经有序（升序），那么时间复杂度是O(N^2)，像快排这种分层最好的情况是，这个划分值，是这些数中的中间值，这样可以把子问题的规模划分为n/2。
左边和右边是等规模的这种，如下图。这样是最好的情况。
其它规模…
如何改进呢？随机取
[left,right]中的一个元素作为划分值，这样划分值的选取就变成了概率事件，通过数学中的数学期望什么的计算，最终快排3.0版本的时间复杂度是O(N*logN)
是对快排2.0进行改版。
代码如下，同样的也是优化过后的
随机值
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
void Swap(int* arr, int a ,int b)
{
int tmp = arr[a];
arr[a] = arr[b];
arr[b] = tmp;
}
int* partition(int* arr, int left, int right)
{
int less = left - 1;
int more = right;
while (left < more)
{
if (arr[left] > arr[right])
{
Swap(arr, left, --more);
}
else if (arr[left] < arr[right])
{
Swap(arr, left++, ++less);
}
else
{
left++;
}
}
Swap(arr, more, right);
int* p = (int*)malloc(sizeof(int) * 2);
p[0] = less + 1;
p[1] = more;
return p;
}
void QuickSort(int* arr, int left, int right)
{
if (right <= left)
return;
Swap(arr, left + (rand() % (right - left + 1)), right);
int* p = partition(arr, left, right);
QuickSort(arr, left, p[0] - 1);
QuickSort(arr, p[0] + 1, right);
free(p);
}
int main()
{
srand((unsigned int)time(NULL));
int arr[] = { 2,3,5,6,9,6,1,3,4,6,5,5 };
int sz = sizeof(arr) / sizeof(arr[0]);
int i = 0;
QuickSort(arr, 0, sz - 1);//参数传的时候要注意区间，传的是闭区间
for (i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
return 0;
}
这种分层你学费了吗？
小试牛刀：力扣原题
int removeElement(int* nums, int numsSize, int val)
{
int left = -1;//不等于区域
int i = 0;
while (i < numsSize)
{
if (nums[i] != val)
{
int tmp = nums[i];
nums[i] = nums[left + 1];
nums[left + 1] = tmp;
left++;
i++;
}
else
i++;
}
return left + 1;
}
int main()
{
int arr[] = { 0,1,2,2,3,0,4,2 };
int sz = sizeof(arr) / sizeof(arr[0]);
int val = 2;
int ret = removeElement(arr, sz, val);
for (int i = 0; i < ret; i++)
{
printf("%d ", arr[i]);
}
return 0;
}
扫一扫
744
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
