分而治之算法应用.docx

分而治之算法应用.docx

《分而治之算法应用.docx》由会员分享，可在线阅读，更多相关《分而治之算法应用.docx（27页珍藏版）》请在冰豆网上搜索。

分而治之算法应用

2.2应用

2.2.1残缺棋盘

残缺棋盘（defectivechessboard）是一个有2k×2k个方格的棋盘，其中恰有一个方格残缺。

图2-3给出k≤2时各种可能的残缺棋盘，其中残缺的方格用阴影表示。

注意当k=0时，仅存在一种可能的残缺棋盘（如图14-3a所示）。

事实上，对于任意k，恰好存在22k种不同的残缺棋盘。

残缺棋盘的问题要求用三格板（triominoes）覆盖残缺棋盘（如图14-4所示）。

在此覆盖中，两个三格板不能重叠，三格板不能覆盖残缺方格，但必须覆盖其他所有的方格。

在这种限制条件下，所需要的三格板总数为（22k-1）/3。

可以验证（22k-1）/3是一个整数。

k为0的残缺棋盘很容易被覆盖，因为它没有非残缺的方格，用于覆盖的三格板的数目为0。

当k=1时，正好存在3个非残缺的方格，并且这三个方格可用图14-4中的某一方向的三格板来覆盖。

用分而治之方法可以很好地解决残缺棋盘问题。

这一方法可将覆盖2k×2k残缺棋盘的问题转化为覆盖较小残缺棋盘的问题。

2k×2k棋盘一个很自然的划分方法就是将它划分为如图14-5a所示的4个2k-1×2k-1棋盘。

注意到当完成这种划分后，4个小棋盘中仅仅有一个棋盘存在残缺方格（因为原来的2k×2k棋盘仅仅有一个残缺方格）。

首先覆盖其中包含残缺方格的2k-1×2k-1残缺棋盘，然后把剩下的3个小棋盘转变为残缺棋盘，为此将一个三格板放在由这3个小棋盘形成的角上，如图14-5b所示，其中原2k×2k棋盘中的残缺方格落入左上角的2k-1×2k-1棋盘。

可以采用这种分割技术递归地覆盖2k×2k残缺棋盘。

当棋盘的大小减为1×1时，递归过程终止。

此时1×1的棋盘中仅仅包含一个方格且此方格残缺，所以无需放置三格板。

可以将上述分而治之算法编写成一个递归的C++函数TileBoard（见程序14-2）。

该函数定义了一个全局的二维整数数组变量Board来表示棋盘。

Board[0][0]表示棋盘中左上角的方格。

该函数还定义了一个全局整数变量tile，其初始值为0。

函数的输入参数如下：

?

tr棋盘中左上角方格所在行。

?

tc棋盘中左上角方格所在列。

?

dr残缺方块所在行。

?

dl残缺方块所在列。

?

size棋盘的行数或列数。

TileBoard函数的调用格式为TileBoard（0,0,dr,dc,size），其中size=2k。

覆盖残缺棋盘所需要的三格板数目为（size2-1）/3。

函数TileBoard用整数1到（size2-1）/3来表示这些三格板，并用三格板的标号来标记被该三格板覆盖的非残缺方格。

令t（k）为函数TileBoard覆盖一个2k×2k残缺棋盘所需要的时间。

当k=0时，size等于1，覆盖它将花费常数时间d。

当k>0时，将进行4次递归的函数调用，这些调用需花费的时间为4t（k-1）。

除了这些时间外，if条件测试和覆盖3个非残缺方格也需要时间，假设用常数c表示这些额外时间。

可以得到以下递归表达式：

程序14-2覆盖残缺棋盘

voidTileBoard（inttr,inttc,intdr,intdc,intsize）

{//覆盖残缺棋盘

if（size==1）return;

intt=tile++,//所使用的三格板的数目

s=size/2;//象限大小

//覆盖左上象限

if（dr

//残缺方格位于本象限

TileBoard（tr,tc,dr,dc,s）;

else{//本象限中没有残缺方格

//把三格板t放在右下角

Board[tr+s-1][tc+s-1]=t;

//覆盖其余部分

TileBoard（tr,tc,tr+s-1,tc+s-1,s）;}

//覆盖右上象限

if（dr=tc+s）

//残缺方格位于本象限

TileBoard（tr,tc+s,dr,dc,s）;

else{//本象限中没有残缺方格

//把三格板t放在左下角

Board[tr+s-1][tc+s]=t;

//覆盖其余部分

TileBoard（tr,tc+s,tr+s-1,tc+s,s）;}

//覆盖左下象限

if（dr>=tr+s&&dc

//残缺方格位于本象限

TileBoard（tr+s,tc,dr,dc,s）;

else{//把三格板t放在右上角

Board[tr+s][tc+s-1]=t;

//覆盖其余部分

TileBoard（tr+s,tc,tr+s,tc+s-1,s）;}

//覆盖右下象限

if（dr>=tr+s&&dc>=tc+s）

//残缺方格位于本象限

TileBoard（tr+s,tc+s,dr,dc,s）;

else{//把三格板t放在左上角

Board[tr+s][tc+s]=t;

//覆盖其余部分

TileBoard（tr+s,tc+s,tr+s,tc+s,s）;}

}

voidOutputBoard（intsize）

{

for（inti=0;i

for（intj=0;j

cout<

cout<

}

}

可以用迭代的方法来计算这个表达式（见例2-20），可得t（k）=（4k）=（所需的三格板的数目）。

由于必须花费至少

（1）的时间来放置每一块三格表，因此不可能得到一个比分而治之算法更快的算法。

2.2.2归并排序

可以运用分而治之方法来解决排序问题，该问题是将n个元素排成非递减顺序。

分而治之方法通常用以下的步骤来进行排序算法：

若n为1，算法终止；否则，将这一元素集合分割成两个或更多个子集合，对每一个子集合分别排序，然后将排好序的子集合归并为一个集合。

假设仅将n个元素的集合分成两个子集合。

现在需要确定如何进行子集合的划分。

一种可能性就是把前面n-1个元素放到第一个子集中（称为A），最后一个元素放到第二个子集里（称为B）。

按照这种方式对A递归地进行排序。

由于B仅含一个元素，所以它已经排序完毕，在A排完序后，只需要用程序2-10中的函数insert将A和B合并起来。

把这种排序算法与InsertionSort（见程序2-15）进行比较，可以发现这种排序算法实际上就是插入排序的递归算法。

该算法的复杂性为O（n2）。

把n个元素划分成两个子集合的另一种方法是将含有最大值的元素放入B，剩下的放入A中。

然后A被递归排序。

为了合并排序后的A和B，只需要将B添加到A中即可。

假如用函数Max（见程序1-31）来找出最大元素，这种排序算法实际上就是SelectionSort（见程序2-7）的递归算法。

假如用冒泡过程（见程序2-8）来寻找最大元素并把它移到最右边的位置，这种排序算法就是BubbleSort（见程序2-9）的递归算法。

这两种递归排序算法的复杂性均为（n2）。

若一旦发现A已经被排好序就终止对A进行递归分割，则算法的复杂性为O（n2）（见例2-16和2-17）。

上述分割方案将n个元素分成两个极不平衡的集合A和B。

A有n-1个元素，而B仅含一个元素。

下面来看一看采用平衡分割法会发生什么情况：

A集合中含有n/k个元素，B中包含其余的元素。

递归地使用分而治之方法对A和B进行排序。

然后采用一个被称之为归并（merge）的过程，将已排好序的A和B合并成一个集合。

例2-5考虑8个元素，值分别为[10，4，6，3，8，2，5，7]。

如果选定k=2，则[10,4,6,3]和[8,2,5,7]将被分别独立地排序。

结果分别为[3,4,6,10]和[2,5,7,8]。

从两个序列的头部开始归并这两个已排序的序列。

元素2比3更小，被移到结果序列；3与5进行比较，3被移入结果序列；4与5比较，4被放入结果序列；5和6比较，.。

如果选择k=4，则序列[10,4]和[6,3,8,2,5,7]将被排序。

排序结果分别为[4,10]和[2,3,5,6,7,8]。

当这两个排好序的序列被归并后，即可得所需要的排序序列。

图2-6给出了分而治之排序算法的伪代码。

算法中子集合的数目为2，A中含有n/k个元素。

template

voidsort（TE,intn）

{//对E中的n个元素进行排序，k为全局变量

if（n>=k）{

i=n/k;

j=n-i;

令A包含E中的前i个元素

令B包含E中余下的j个元素

sort（A,i）;

sort（B,j）;

merge（A,B,E,i,j,）;//把A和B合并到E

}

else使用插入排序算法对E进行排序

}

图14-6分而治之排序算法的伪代码

从对归并过程的简略描述中，可以明显地看出归并n个元素所需要的时间为O（n）。

设t（n）为分而治之排序算法（如图14-6所示）在最坏情况下所需花费的时间，则有以下递推公式：

其中c和d为常数。

当n/k≈n-n/k时，t（n）的值最小。

因此当k=2时，也就是说，当两个子集合所包含的元素个数近似相等时，t（n）最小，即当所划分的子集合大小接近时，分而治之算法通常具有最佳性能。

可以用迭代方法来计算这一递推方式，结果为t（n）=（nlogn）。

虽然这个结果是在n为2的幂时得到的，但对于所有的n，这一结果也是有效的，因为t（n）是n的非递减函数。

t（n）=（nlogn）给出了归并排序的最好和最坏情况下的复杂性。

由于最好和最坏情况下的复杂性是一样的，因此归并排序的平均复杂性为t（n）=（nlogn）。

图2-6中k=2的排序方法被称为归并排序（mergesort），或更精确地说是二路归并排序（two-waymergesort）。

下面根据图14-6中k=2的情况（归并排序）来编写对n个元素进行排序的C++函数。

一种最简单的方法就是将元素存储在链表中（即作为类chain的成员（程序3-8））。

在这种情况下，通过移到第n/2个节点并打断此链，可将E分成两个大致相等的链表。

归并过程应能将两个已排序的链表归并在一起。

如果希望把所得到C++程序与堆排序和插入排序进行性能比较，那么就不能使用链表来实现归并排序，因为后两种排序方法中都没有使用链表。

为了能与前面讨论过的排序函数作比较，归并排序函数必须用一个数组a来存储元素集合E，并在a中返回排序后的元素序列。

为此按照下述过程来对图14-6的伪代码进行细化：

当集合E被化分成两个子集合时，可以不必把两个子集合的元素分别复制到A和B中，只需简单地在集合E中保持两个子集合的左右边界即可。

接下来对a中的初始序列进行排序，并将所得到的排序序列归并到一个新数组b中，最后将它们复制到a中。

图14-6的改进版见图14-7。

template

MergeSort（Ta[],intleft,intright）

{//对a[left:

right]中的元素进行排序

if（left

inti=（left+right）/2;//中心位置

MergeSort（a,left,i）;

MergeSort（a,i+1,right）;

Merge（a,b,left,i,right）;//从a合并到b

Copy（b,a,left,right）;//结果放回a

}

}

图14-7分而治之排序算法的改进

可以从很多方面来改进图14-7的性能，例如，可以容易地消除递归。

如果仔细地检查图14-7中的程序，就会发现其中的递归只是简单地重复分割元素序列，直到序列的长度变成1为止。

当序列的长度变为1时即可进行归并操作，这个过程可以用n为2的幂来很好地描述。

长度为1的序列被归并为长度为2的有序序列；长度为2的序列接着被归并为长度为4的有序序列；这个过程不断地重复直到归并为长度为n的序列。

图14-8给出n=8时的归并（和复制）过程，方括号表示一个已排序序列的首和尾。

初始序列[8][4][5][6][2][1][7][3]

归并到b[48][56][12][37]

复制到a[48][56][12][37]

归并到b[4568][1237]

复制到a[4568][1237]

归并到b[12345678]

复制到a[12345678]

图14-8归并排序的例子

另一种二路归并排序算法是这样的：

首先将每两个相邻的大小为1的子序列归并，然后对上一次归并所得到的大小为2的子序列进行相邻归并，如此反复，直至最后归并到一个序列，归并过程完成。

通过轮流地将元素从a归并到b并从b归并到a，可以虚拟地消除复制过程。

二路归并排序算法见程序14-3。

程序14-3二路归并排序

template

voidMergeSort（Ta[],intn）

{//使用归并排序算法对a[0:

n-1]进行排序

T*b=newT[n];

ints=1;//段的大小

while（s

MergePass（a,b,s,n）;//从a归并到b

s+=s;

MergePass（b,a,s,n）;//从b归并到a

s+=s;

}

}

为了完成排序代码，首先需要完成函数MergePass。

函数MergePass（见程序14-4）仅用来确定欲归并子序列的左端和右端，实际的归并工作由函数Merge（见程序14-5）来完成。

函数Merge要求针对类型T定义一个操作符<=。

如果需要排序的数据类型是用户自定义类型，则必须重载操作符<=。

这种设计方法允许我们按元素的任一个域进行排序。

重载操作符<=的目的是用来比较需要排序的域。

程序14-4MergePass函数

template

voidMergePass（Tx[],Ty[],ints,intn）

{//归并大小为s的相邻段

inti=0;

while（i<=n-2*s）{

//归并两个大小为s的相邻段

Merge（x,y,i,i+s-1,i+2*s-1）;

i=i+2*s;

}

//剩下不足2个元素

if（i+s

elsefor（intj=i;j<=n-1;j++）

//把最后一段复制到y

y[j]=x[j];

}

程序14-5Merge函数

template

voidMerge（Tc[],Td[],intl,intm,intr）

{//把c[l:

m]]和c[m:

r]归并到d[l:

r].

inti=l,//第一段的游标

j=m+1,//第二段的游标

k=l;//结果的游标

//只要在段中存在i和j，则不断进行归并

while（（i<=m）&&（j<=r））

if（c[i]<=c[j]）d[k++]=c[i++];

elsed[k++]=c[j++];

//考虑余下的部分

if（i>m）for（intq=j;q<=r;q++）

d[k++]=c[q];

elsefor（intq=i;q<=m;q++）

d[k++]=c[q];

}

自然归并排序（naturalmergesort）是基本归并排序（见程序14-3）的一种变化。

它首先对输入序列中已经存在的有序子序列进行归并。

例如，元素序列[4，8，3，7，1，5，6，2]中包含有序的子序列[4，8]，[3，7]，[1，5，6]和[2]，这些子序列是按从左至右的顺序对元素表进行扫描而产生的，若位置i的元素比位置i+1的元素大，则从位置i进行分割。

对于上面这个元素序列，可找到四个子序列，子序列1和子序列2归并可得[3,4,7,8]，子序列3和子序列4归并可得[1,2,5,6]，最后，归并这两个子序列得到[1,2,3,4,5,6,7,8]。

因此，对于上述元素序列，仅仅使用了两趟归并，而程序14-3从大小为1的子序列开始，需使用三趟归并。

作为一个极端的例子，假设输入的元素序列已经排好序并有n个元素，自然归并排序法将准确地识别该序列不必进行归并排序，但程序14-3仍需要进行[log2n]趟归并。

因此自然归并排序将在（n）的时间内完成排序。

而程序14-3将花费（nlogn）的时间。

2.2.3快速排序

分而治之方法还可以用于实现另一种完全不同的排序方法，这种排序法称为快速排序（quicksort）。

在这种方法中，n个元素被分成三段（组）：

左段left，右段right和中段middle。

中段仅包含一个元素。

左段中各元素都小于等于中段元素，右段中各元素都大于等于中段元素。

因此left和right中的元素可以独立排序，并且不必对left和right的排序结果进行合并。

middle中的元素被称为支点（pivot）。

图14-9中给出了快速排序的伪代码。

//使用快速排序方法对a[0:

n-1]排序

从a[0:

n-1]中选择一个元素作为middle，该元素为支点

把余下的元素分割为两段left和right，使得left中的元素都小于等于支点，而right中的元素都大于等于支点

递归地使用快速排序方法对left进行排序

递归地使用快速排序方法对right进行排序

所得结果为left+middle+right

图14-9快速排序的伪代码

考察元素序列[4,8,3,7,1,5,6,2]。

假设选择元素6作为支点，则6位于middle；4，3，1，5，2位于left；8，7位于right。

当left排好序后，所得结果为1，2，3，4，5；当right排好序后，所得结果为7，8。

把right中的元素放在支点元素之后，left中的元素放在支点元素之前，即可得到最终的结果[1,2,3,4,5,6,7,8]。

把元素序列划分为left、middle和right可以就地进行（见程序14-6）。

在程序14-6中，支点总是取位置1中的元素。

也可以采用其他选择方式来提高排序性能，本章稍后部分将给出这样一种选择。

程序14-6快速排序

template

voidQuickSort（T*a,intn）

{//对a[0:

n-1]进行快速排序

{//要求a[n]必需有最大关键值

quickSort（a,0,n-1）;

template

voidquickSort（Ta[],intl,intr）

{//排序a[l:

r]，a[r+1]有大值

if（l>=r）return;

inti=l,//从左至右的游标

j=r+1;//从右到左的游标

Tpivot=a[l];

//把左侧>=pivot的元素与右侧<=pivot的元素进行交换

while（true）{

do{//在左侧寻找>=pivot的元素

i=i+1;

}while（a[i]

do{//在右侧寻找<=pivot的元素

j=j-1;

}while（a[j]>pivot）;

if（i>=j）break;//未发现交换对象

Swap（a[i],a[j]）;

}

//设置pivot

a[l]=a[j];

a[j]=pivot;

quickSort（a,l,j-1）;//对左段排序

quickSort（a,j+1,r）;//对右段排序

}

若把程序14-6中do-while条件内的<号和>号分别修改为<=和>=，程序14-6仍然正确。

实验结果表明使用程序14-6的快速排序代码可以得到比较好的平均性能。

为了消除程序中的递归，必须引入堆栈。

不过，消除最后一个递归调用不须使用堆栈。

消除递归调用的工作留作练习（练习13）。

程序14-6所需要的递归栈空间为O（n）。

若使用堆栈来模拟递归，则可以把这个空间减少为O（logn）。

在模拟过程中，首先对left和right中较小者进行排序，把较大者的边界放入堆栈中。

在最坏情况下left总是为空，快速排序所需的计算时间为（n2）。

在最好情况下，left和right中的元素数目大致相同，快速排序的复杂性为（nlogn）。

令人吃惊的是，快速排序的平均复杂性也是（nlogn）。

定理2-1快速排序的平均复杂性为（nlogn）。

证明用t（n）代表对含有n个元素的数组进行排序的平均时间。

当n≤1时，t（n）≤d，d为某一常数。

当n<1时，用s表示左段所含元素的个数。

由于在中段中有一个支点元素，因此右段中元素的个数为n-s-1。

所以左段和右段的平均排序时间分别为t（s）,t（n-s-1）。

分割数组中元素所需要的时间用cn表示，其中c是一个常数。

因为s有同等机会取0~n-1中的任何一个值.

如对（2-8）式中的n使用归纳法，可得到t（n）≤knlogen，其中n>1且k=2（c+d），e～2.718为自然对数的基底。

在归纳开始时首先验证n=2时公式的正确性。

根据公式（14