上一章我们讲解了快速排序,其中快速排序一趟划分的算法Partition.Partition可不只用在快速排序中,还可Selection algorithm(在无序数组中寻找第K大的值)中.甚至有可能正是这种通过一趟扫描来进行分类的思想激发Edsger Dijkstra想出了Three-way Partitioning,高效的解决了Dutch national flag problem问题.接下来我们一起探索Partition算法.
Partition实现
快速排序中用到的partion算法思想很简单,首先从无序数组中选出枢轴点pivot,然后通过一趟扫描,以pivot为分界线将数组中的元素分为两部分:使得左边的数小于等于枢轴,右边的数大于等于枢轴(左右部分可能为空),最后返回枢轴在新数组中的位置.
Partition的一个直观简单实现如下(取数组第一个元素为pivot):
- <pre name="code" class="cpp">
- int partition(int array[], int nStart, int nEnd)
- {
- int pivot = array[nStart];
- int nPos = nStart;
-
- for (int i = nStart+1; i<=nEnd; i++)
- {
- if (array[i]<=pivot)
- {
- nPos++;
- Swap(array[i], array[nPos]);
- }
- }
- Swap(array[nPos], array[nStart]);
- return nPos;
- }
这种实现思路比较直观,但是其实并不高效.从直观上来说,每个小于piovt的值基本上都需要交换一次,而大于piovt的值可能要交换多次.
如果我们考虑用Two Pointers的思想,保持头尾两个指针向中间扫描,在头部找到大于piovt的值,同时在尾部找到小于piovt的值,把他们做一次交换。就可以一次把这两个数组放到最终的位置.
- template <class T>
- int Partition(T array[], int nStart, int nEnd)
- {
- int i = nStart;
- int j = nEnd;
- while (i < j)
- {
- while (i<j)
- {
-
- if (array[j] > array[i])
- {
- j--;
- }else
- {
- T temp = array[j];
- array[j] = array[i];
- array[i] = temp;
- i++;
- break;
- }
- }
- while (i<j)
- {
-
- if (array[i] < array[j])
- {
- i++;
- }else
- {
- T temp = array[j];
- array[j] = array[i];
- array[i] = temp;
- j--;
- break;
- }
- }
-
- }
- return i;
- }
Partition应用
除了用在快速排序,partition还可以用O(n)的平均时间复杂度从无序数组中寻找第k大的值.和快排一样,这里也用到了分而治之的思想.思路是,首先对数组进行一次Partition,得到坐标nPos:
如果nPos+1 == k,返回array[nPos];
如果nPos+1 > k,对数组左半部分继续进行Partition;
如果nPos+1 < k, 对数组右半部分继续进行Partition.
-
- int GetArrayMaxK(int array[], int nStart, int nEnd, int k)
- {
- if (k <= 0)
- {
- throw;
- }
- int nPos = -1;
- while (true)
- {
- nPos = Partition(array, nStart, nEnd);
- if ((nPos+1) == k)
- {
- return array[nPos];
- }else if ((nPos+1) > k)
- {
- nEnd = nPos - 1;
- }else
- {
- nStart = nPos + 1;
- }
- }
- }
Partition进阶
考虑如下一个问题:给定红,白,蓝三种颜色的小球若干,将其排成一列,使相同颜色的小球相邻,且三种颜色的先后顺序为红,白,蓝.这就是经典的Dutch national flag problem.
我们可以针对红,蓝,白三种颜色的球分别计数,然后根据计数结果重新放球.我们可以将问题进一步抽象,也就是说将一个数组按照某个target分为三部分,左边部分小于target,中间部分等于target,右边部分大于target.这样就不能简单计数来确定排序后的结果,这时候,可以用另一种partition算法:three-way-partition.它的思路稍微复杂一点,同三个指针将数组分为四个部分,通过一次扫描将数组分为<,=,>三部分.
-
- void three_way_partition(int array[], int nLen, int target)
- {
- int next_less_pos = 0;
- int next_bigger_pos = nLen - 1;
- int next_scan_pos = 0;
- while (next_scan_pos <= next_bigger_pos)
- {
- if (array[next_scan_pos] > target)
- {
- Swap(array[next_scan_pos], array[next_bigger_pos--]);
- }else if (array[next_scan_pos] < target)
- {
- Swap(array[next_scan_pos++],array[next_less_pos++]);
- }else
- {
- next_scan_pos++;
- }
- }
-
- }
这里主要的思想就是在一遍扫描中,通过交换不通位置的数字,使得数组可以维持一定的顺序.和前面快排用到的partition思想一致.区别在于快排通过pivot将数组分为两部分.而three-way-partition将数组分为<,=,>三部分.