实验2 分治法算法设计

《算法分析与设计》实验报告

实验2 分治法算法设计

姓名XXX 学号XXX 班级XXXXXX

时间：XXXX-XX-XX 地点：XXX

同组人：无

指导教师：XXX

实验目的

a)掌握分治法算法设计的一般思想和方法。

b)理解并掌握二分查找、归并分类、快速分类算法。

c)能熟练运用分治法求解问题。

d)实验中所准备的数据是有代表性的。

实验内容

a)写一个顺序查找算法，将其与二分查找算法一起转换成程序，上机验证。

b)选择不同规模的数据集运行上二程序，统计它们的时间开销并比较。

c)归并分类、快速分类算法转换成程序并验证之。

d)选择不同规模的数据集运行上二程序，统计它们的时间开销并比较。

e)准备一定规模的数据集用于实验。此数据集越大越有得于验证算法，可以

考虑最终的数据个数超过10000个。

f)编写归并分类、快速分类程序，将上数据集中的数据分类。可以使用较少

的数据调试程序时。

g)用规模从小到大的数据集运行上述程序，统计它们的运行时间，并作对比

分析。

h)编写顺序查找、二分查找程序。

i)将查找程序与分类程序结合起来，用不同规模的数据集运行，统计程序运

行时间。

实验环境

硬件：Intel(R) Pentium(R) CPU RAM:4G

软件：Myeclipse2013

实验前准备

2、程序设计：见附1

实验步骤

a)准备一定规模的随机数据集用于实验，存于数组A中，A为全程数组，此

数据集越大越有得于验证算法，可以考虑最终的数据个数超过10000个。

使用randomInt(int min, int max, int num)方法产生不小于min，小于max 的num个随机数(其中A[0]和A[n]作为数组的上界和下界，供方便排序用，不参与实际排序)，在分析程序效率时可修改num来达到产生不同数量的随机数：

b)分别编写归并分类MergeSort、快速分类程序QuickSort()，将上数据集中

的数据分类。可以使用较少的数据调试程序时。

/* 使用辅助数组归并两个已分类的集合 */

private void Merge(int low,int mid,int high){

// arry[n]是一个全程数组

int[] B =new int[high - low +1];

int h = low;// 子序列第一个开始等待进入B数组中

int i =0;// B数组接收两个子序列进队

int j = mid +1;// 子序列从第一个开即行等等待进入B数组中

while(h <= mid && j <= high){// 当两个集合都没取尽时

if(A[h]<= A[j]){// 集合1的小时集合1的进队B

B[i]= A[h];

h++;

}else{// 集合2的小时集合2的进队B

B[i]= A[j];

j++;

}

i++;

}

if(h > mid)// 处理剩余元素

for(int k = j; k <= high; k++){

B[i]= A[k];

i++;

}

else

for(int k = h; k <= mid; k++){

B[i]= A[k];

i++;

}

for(int k = low; k <= high; k++){// 将已归并的集合复制到A A[k]= B[k - low];

}

}

// 改进后的归并排序

private int Merge1(int q,int r){

// TODO Auto-generated method stub

int i = q;

int j = r;

int k =0;

while(i !=0&& j !=0){

if(A[i]<= A[j]){

Link[k]= i;

k = i;

i = Link[i];

}else{

Link[k]= j;

k = j;

j = Link[j];

}

}

if(i ==0)

Link[k]= j;

else

Link[k]= i;

return Link[0];

}

public int MergeSort1(int low,int high){

if(high - low +1<16){

return this.insertionSort(low, high);

}else{

int mid =(low + high)/2;

int q =this.MergeSort1(low, mid);

int r =this.MergeSort1(mid +1, high);

return this.Merge1(q, r);

}

}

// 插入排序

public int insertionSort(int low,int high){

int item;

Link[0]= low;

for(int j = low +1; j <= high; j++){

item = A[j];

int p =0;

int q = Link[p];

while(q !=0&& item > A[q]){

p = q;

q = Link[p];

}

Link[p]= j;

Link[j]= q;

}

return Link[0];

}

/* 快速排序，在主程序中的调用为f.QuickSort(0,f.getSize()); */ public void QuickSort(int low,int high){

if(low < high){

int mid = high +1;

mid =this.partition(low, mid);// 进行一次划分，并返回划分点this.QuickSort(low, mid -1);// 对划分的前半部分进行快速排序

this.QuickSort(mid +1, high);// 对划分的后半部分进行快速排序}

}

// 划分，并返回划分元素所在的下标

private int partition(int low,int high){

int temp = A[low];// A[m]是划分元素

int i = low;

while(true){

do{

low++;

}while(A[low]< temp);

do{

high--;

}while(A[high]> temp);

if(low < high){

int t = A[low];

A[low]= A[high];

A[high]= t;

}else

break;

}

A[i]= A[high];// 划分元素在位置high

A[high]= temp;

return high;

}

c)用规模从小到大的数据集运行上述程序，统计它们的运行时间，并作对比分

析，即改变n的值，使每次随机产生的数的个数不同，并将其复制三份，统计三种算法M（默认100）次的排序时间

int M =100;

int a=0,b=10000;

int n=10000;

for(int i =0; i < M; i++){

FenZhi f =new FenZhi(a, b,n);//new一个对象,n决定每次排序的规模

FenZhi f1 =(FenZhi) f.clone();//复制三份，以保证三次排序的条件相同

FenZhi f2 =(FenZhi) f.clone();

FenZhi f3 =(FenZhi) f.clone();

t1 = System.currentTimeMillis();

f1.MergeSort(1, f1.getSize()-1);//归并排序

t2 = System.currentTimeMillis();

f2.MergeSort1(1, f2.getSize());//改进后的归并排序

t3 = System.currentTimeMillis();

f3.QuickSort(1, f2.getSize()-1);//快速排序

t4 = System.currentTimeMillis();

T1 += t2 - t1;

T2 += t3 - t2;

T3 += t4 - t3;

}

System.out.println("归并排序执行所需要的时间为："+(T1)

+"毫秒\n改进后的归并排序执行所需要的时间为："+(T2 )

+"毫秒\n快速排序执行所需要的时间为："+(T3 )+"毫秒");

}

d)可以明显看到快速排序最快，改进后的归并排序次之，最慢的是普通的归并

排序：

d)编写顺序查找、二分查找程序。

// 顺序查找

public int srch(int x){

for(int i =0; i

if(x == A[i]){

return i;

}

}

return-1;

}

// 二分查找;

public int binSrch(int x){

int low =0;

int high =this.size;

int mid;

while(low <= high){

mid =(low + high)/2;

if(x < A[mid]){

high = mid -1;

}else if(x > A[mid]){

low = mid +1;

}else

return mid;

}

return-1;

}

e)将查找程序与分类程序结合起来，用不同规模的数据集运行，统计程序运行

时间,因为查找所需要的时间极短，所以我们统计查找10000次的结果，放大时间效果，并且数据规模的起始值设为50000，每次增10000

f)附加实验与思考：

设有n个运动员要进行网球循环赛。设计一个满足以下要求的比赛日程表。

①每个选手必须与其它n-1选手各赛一次；

②每个选手一天只能赛一次。

最终实验程序：附2

注意到当n是偶数时，循环赛进行n-1天，当n是奇数时，由于总有一个队伍轮空，循环赛进行n天；

采用分治法的思想：当n为偶数时，可以讲问题分为两个部分n/2; 然后继续划分，知道最后剩余两名选手单独比赛，这时只需要让这两名对手比赛就可以了。当n为奇数时，增设一个虚拟选手，运动员为n+1个，将问题转化为是偶数的情形。当选手与虚拟选手比赛时，表示轮空，因此只需要关注n为偶数的情形。

在这里算法设计的难点就是分开治理后的合并问题，可以从以下例子中看出，将6个选手分为对等的两组，每组3个选手。每组增设一个虚拟的选手，然后再递归的将3个选手分为对等两组，每组2个选手。

在2个选手情况下，这两个选手比赛。可以得到两个选手的日程安排表是：

1 2

2 1

接下来的任务是合并这两组2个选手的日程表得到3个选手的日程安排表，这里我先假设有4个选手参加比赛则：

1 2

2 1

3 4

4 3

接下来的比赛里，第二天让1和3比赛，2和4比赛；第三天让1和4比赛，2和3比赛，即让前一组的选手，循环的和后一组的选手比赛，可得到比赛日程安排表是：

1 2 3 4

2 1 4 3

3 4 1 2

4 3 2 1

这里要得到的是3个选手的日程安排表，则第4个选手是假想的选手将其用0来表示则得到3个选手的日程安排表：

1 2 3 0

2 1 0 3

3 0 1 2

接下来的任务是合并这两个3个选手的日程安排表得到6个选手的日程安排表，这里我们的两组选手前3天的比赛情况如下：

1 2 3 0

2 1 0 3

4 5 6 0

5 4 0 6

6 0 4 5

其中第一天选手3和选手6都没有对手，让他们两个比赛；第二天选手2和选手5没有对手，让他们两个比赛，；第三天选手1和选手4没有对手，让他们两个比赛。这就可以得到合并后6个选手前三天的比赛日程安排表：

1 2 3 4

2 1 5 3

3 6 1 2

4 5 6 1

5 4 2 6

6 3 4 5

将在前三天比过赛的两组的选手对应的列出来：

1 2 3

4 5 6

在这里可以看到合并的两组中3和6，2和5，1和4都已经比过了，这里就跳过这些选手的比赛，然后两个组循环比赛即：

1 2 3

5 6 4

和

1 2 3

这样就得到了6个选手的比赛完整的日程安排表：

1 2 3 4 5 6

2 1 5

3 6 4

3 6 1 2

4 5

4 5 6 1 3 2

5 4 2

6 1 3

6 3 4 5 2 1

最终实验程序：附2

第1列表示每支队伍，以后几列对表示第1天到第n-1或n天的对战情况：当n取8时，结果：

n取11时，注12表示本轮轮空：

实验结果及其分析

通过实验可以看出，分治法可以有效快速的解决一些问题，如二分查找可大大缩短查找速度。在二分查找，归并分类，快速分类的实验中体会到分治法的思想是统一的，都需要我们在解决问题时将一个复杂的问题分解到一个个不可分解的小问题来解决，大而化小，再合并解决，一个小问题往往容易解决而难的总是将其合并起来，需要实际问题实际对待。

归并排序，改进的归并排序，快速排序，这三种算法的速度依次提高，并随着数据量的

增多差距有增大的趋势。

附1：最终程序

public class FenZhi implements Cloneable {

int min;

int max;

int size;

int A[];

int Link[];

public static void main(String[] args){

long T1 =0, T2 =0, T3 =0, t1 =0, t2 =0, t3 =0, t4 =0;

long T4=0,T5=0,t5=0,t6=0,t7=0;

int M =100;

int a=0,b=10000;

int n=50000;

for(int i =0; i < M; i++){

FenZhi f =new FenZhi(a, b,n);//new一个对象,n决定每次排序的规模

FenZhi f1 =(FenZhi) f.clone();//复制三份，以保证三次排序的条件相同

FenZhi f2 =(FenZhi) f.clone();

FenZhi f3 =(FenZhi) f.clone();

t1 = System.currentTimeMillis();

f1.MergeSort(1, f1.getSize()-1);//归并排序

t2 = System.currentTimeMillis();

f2.MergeSort1(1, f2.getSize());//改进后的归并排序

t3 = System.currentTimeMillis();

f3.QuickSort(1, f2.getSize()-1);//快速排序

t4 = System.currentTimeMillis();

T1 += t2 - t1;

T2 += t3 - t2;

T3 += t4 - t3;

int x=(int)(Math.random()*(f2.max-f2.min)-f2.min);

t5 = System.currentTimeMillis();

f1.srch(x);//顺序查找

t6 = System.currentTimeMillis();

f1.binSrch(x);//十分查找

t7 = System.currentTimeMillis();

T4 += t6 - t5;

T5 += t7 - t6;

}

System.out.println("归并排序执行所需要的时间为："+(T1)

+"毫秒\n改进后的归并排序执行所需要的时间为："+(T2 )

+"毫秒\n快速排序执行所需要的时间为："+(T3 )+"毫秒");

System.out.println("顺序查找所需要的时间为："+T4+"毫秒\n十分查找所需要的时间为:"+T5+"毫秒\n");

}

public FenZhi(int min,int max,int size){

this.min = min;

this.max = max;

this.size = size;

this.A =new int[this.size +1];

this.Link =new int[this.size +1];

this.randomInt();

}

public FenZhi(){

this.min =0;

this.max =1000;

this.size =200;

this.A =new int[this.size +2];

this.Link =new int[this.size +2];

this.randomInt();

}

// 复制一份

public FenZhi clone(){

FenZhi f =null;

try{

f =(FenZhi)super.clone();

f.A = A.clone();

}catch(CloneNotSupportedException e){ // TODO Auto-generated catch block

e.printStackTrace();

}

return f;

}

public int getMin(){

return min;

}

public void setMin(int min){

this.min = min;

}

public int getMax(){

return max;

}

public void setMax(int max){

this.max = max;

}

public int getSize(){

return size;

}

public void setSize(int size){

this.size = size;

}

public int[] getA(){

return A;

}

public void setA(int[] a){

A = a;

}

private void linkDisplay(){

int p =0;

int q = Link[p];

int i =0;

while(Link[q]!=0){

if(i %10==0&& i !=0)

System.out.println();

System.out.printf("%6d", A[Link[q]]); p = q;

q = Link[p];

i++;

}

}

public void display(){

for(int i =1; i < size; i++){

if(i %10==0&& i !=0)

System.out.println();

System.out.printf("%6d", A[i]);

}

}

/* 产生不小于min，小于max的num个随机数 */

private void randomInt(){

for(int i =0; i

A[i]=(int)(Math.random()*(this.max -this.min)+this.min);

}

A[size]=this.max;

A[0]=this.min -1;

}

/* 归并算法 */

public void MergeSort(int low,int high){

if(low < high){

int mid =(low + high)/2;// 求两个集合的分割点

this.MergeSort(low, mid);// 将一个子集合分类

this.MergeSort(mid +1, high);// 将另一个子集合分类

this.Merge(low, mid, high);// 归并两个已分类的子集合

}

}

/* 使用辅助数组归并两个已分类的集合 */

private void Merge(int low,int mid,int high){

// arry[n]是一个全程数组

int[] B =new int[high - low +1];

int h = low;// 子序列第一个开始等待进入B数组中

int i =0;// B数组接收两个子序列进队

int j = mid +1;// 子序列从第一个开即行等等待进入B数组中

while(h <= mid && j <= high){// 当两个集合都没取尽时

if(A[h]<= A[j]){// 集合1的小时集合1的进队B

B[i]= A[h];

h++;

}else{// 集合2的小时集合2的进队B

B[i]= A[j];

j++;

}

i++;

}

if(h > mid)// 处理剩余元素

for(int k = j; k <= high; k++){

B[i]= A[k];

i++;

}

else

for(int k = h; k <= mid; k++){

B[i]= A[k];

i++;

}

for(int k = low; k <= high; k++){// 将已归并的集合复制到A

A[k]= B[k - low];

}

}

/* 快速排序，在主程序中的调用为f.QuickSort(0,f.getSize()-1); */

public void QuickSort(int low,int high){

if(low < high){

int mid = high +1;

mid =this.partition(low, mid);// 进行一次划分，并返回划分点this.QuickSort(low, mid -1);// 对划分的前半部分进行快速排序

this.QuickSort(mid +1, high);// 对划分的后半部分进行快速排序}

// 划分，并返回划分元素所在的下标

private int partition(int low,int high){ int temp = A[low];// A[m]是划分元素

int i = low;

while(true){

do{

low++;

}while(A[low]< temp);

do{

high--;

}while(A[high]> temp);

if(low < high){

int t = A[low];

A[low]= A[high];

A[high]= t;

}else

break;

}

A[i]= A[high];// 划分元素在位置high

A[high]= temp;

return high;

}

// 顺序查找

public int srch(int x){

for(int i =1; i <=this.size; i++){

if(x == A[i]){

return i;

}

}

return-1;

}

// 二分查找;

public int binSrch(int x){

int low =1;

int high =this.size;

int mid;

while(low <= high){

mid =(low + high)/2;

if(x < A[mid]){

high = mid -1;

}else if(x > A[mid]){

low = mid +1;

}else

return mid;

}

return-1;

}

// 插入排序

public int insertionSort(int low,int high){ int item;

Link[0]= low;

for(int j = low +1; j <= high; j++){

item = A[j];

int p =0;

int q = Link[p];

while(q !=0&& item > A[q]){

p = q;

q = Link[p];

}

Link[p]= j;

Link[j]= q;

}

return Link[0];

public int MergeSort1(int low,int high){ if(high - low +1<16){

return this.insertionSort(low, high);

}else{

int mid =(low + high)/2;

int q =this.MergeSort1(low, mid);

int r =this.MergeSort1(mid +1, high);

return this.Merge1(q, r);

}

}

// 改进后的归并排序

private int Merge1(int q,int r){

// TODO Auto-generated method stub

int i = q;

int j = r;

int k =0;

while(i !=0&& j !=0){

if(A[i]<= A[j]){

Link[k]= i;

k = i;

i = Link[i];

}else{

Link[k]= j;

k = j;

j = Link[j];

}

}

if(i ==0)

Link[k]= j;

else

Link[k]= i;

return Link[0];

}

}

附2：

}

public static void tournament(int[][] a,int n){ // TODO Auto-generated method stub

if(n ==1){

a[1][1]=1;

return;

}

if(odd(n)){

tournament(a, n +1);

return;

}

tournament(a, n /2);

makecopy(a, n);

}

private static void makecopy(int[][] a,int n){ // TODO Auto-generated method stub

if(n /2>1&& odd(n /2))

copyodd(a, n);

else

copy(a, n);

}

private static void copyodd(int[][] a,int n){ // TODO Auto-generated method stub

int m = n /2;

int[] b=new int[n+1];

for(int i =1; i <= m; i++){

b[i]= m + i;

b[m + i]= b[i];

}

for(int i =1; i <= m; i++){

for(int j =1; j <= m +1; j++){

if(a[i][j]> m){

a[i][j]= b[i];

a[m + i][j]=(b[i]+ m)% n;

}else

a[m + i][j]= a[i][j]+ m;

}

for(int j =2; j <= m; j++){

a[i][m + j]= b[i + j -1];

a[b[i + j -1]][m + j]= i;

}