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

《算法设计与分析》实验报告实验一递归与分治策略应用基础学号:**************姓名:*************班级:*************日期:2014-2015学年第1学期第九周一、实验目的1、理解递归的概念和分治法的基本思想2、了解适用递归与分治策略的问题类型,并能设计相应的分治策略算法3、掌握递归与分治算法时间空间复杂度分析,以及问题复杂性分析方法二、实验内容任务:以下题目要求应用递归与分治策略设计解决方案,本次实验成绩按百分制计,完成各小题的得分如下,每小题要求算法描述准确且程序运行正确。
1、求n个元素的全排。
(30分)2、解决一个2k*2k的特殊棋牌上的L型骨牌覆盖问题。
(30分)3、设有n=2k个运动员要进行网球循环赛。
设计一个满足要求的比赛日程表。
(40分)提交结果:算法设计分析思路、源代码及其分析说明和测试运行报告。
三、设计分析四、算法描述及程序五、测试与分析六、实验总结与体会#include "iostream"using namespace std;#define N 100void Perm(int* list, int k, int m){if (k == m){for (int i=0; i<m; i++)cout << list[i] << " ";cout << endl;return;}else{for (int i=m; i<k; i++){swap(list[m], list[i]);Perm(list, k, m+1);swap(list[m], list[i]);}}}void swap(int a,int b){int temp;temp=a;a=b;b=temp;}int main(){int i,n;int a[N];cout<<"请输入排列数据总个数:";cin>>n;cout<<"请输入数据:";for(i=0;i<n;i++){cin>>a[i];}cout<<"该数据的全排列:"<<endl;Perm(a,n,0);return 0;}《算法设计与分析》实验报告实验二递归与分治策略应用提高学号:**************姓名:*************班级:*************日期:2014-2015学年第1学期一、实验目的1、深入理解递归的概念和分治法的基本思想2、正确使用递归与分治策略设计相应的问题的算法3、掌握递归与分治算法时间空间复杂度分析,以及问题复杂性分析方法二、实验内容任务:从以下题目中任选一题完成,要求应用递归与分治策略设计解决方案。
算法分析与设计实验报告--回溯法

算法分析与设计实验报告--回溯法实验目的:通过本次实验,掌握回溯法的基本原理和应用,能够设计出回溯法算法解决实际问题。
实验内容:1.回溯法概述回溯法全称“试探回溯法”,又称“逐步退化法”。
它是一种通过不断试图寻找问题的解,直到找到解或者穷尽所有可能的解空间技术。
回溯法的基本思路是从问题的某一个初始状态开始,搜索可行解步骤,一旦发现不满足求解条件的解就回溯到上一步,重新进行搜索,直到找到解或者所有可能的解空间已经搜索完毕。
2.回溯法的基本应用回溯法可用于求解许多 NP 问题,如 0/1 背包问题、八皇后问题、旅行商问题等。
它通常分为两种类型:一种是通过枚举所有可能的解空间来寻找解;另一种则是通过剪枝操作将搜索空间减少到若干种情况,大大减少了搜索时间。
3.回溯法的解题思路(1)问题分析:首先需要对问题进行分析,确定可行解空间和搜索策略;(2)状态表示:将问题的每一种状况表示成一个状态;(3)搜索策略:确定解空间的搜索顺序;(4)搜索过程:通过逐步试探,不断扩大搜索范围,更新当前状态;(5)终止条件:在搜索过程中,如果找到了满足要求的解,或者所有的可行解空间都已搜索完毕,就结束搜索。
4.八皇后问题八皇后问题是指在一个 8x8 的棋盘上放置八个皇后,使得任意两个皇后都不在同一行、同一列或同一对角线上。
通过回溯法可以求解出所有的可能解。
实验过程:回溯法的实现关键在于搜索空间的剪枝,避免搜索无用的解;因此,对于八皇后问题,需要建立一个二维数组来存放棋盘状态,以及一个一维数组来存放每行放置的皇后位置。
从第一行开始搜索,按照列的顺序依次判断当前的空位是否可以放置皇后,如果可以,则在相应的位置标记皇后,并递归到下一行;如果不能,则回溯到上一行,重新搜索。
当搜索到第八行时,获取一组解并返回。
代码实现:```pythondef is_valid(board, row, col):for i in range(row):if board[i] == col or abs(board[i] - col) == abs(i - row):return Falsereturn True实验结果:当 n=4 时,求得的所有可行解如下:```[[1, 3, 0, 2],[2, 0, 3, 1]]```本次实验通过实现回溯法求解八皇后问题,掌握了回溯法的基本原理和应用,并对回溯法的核心思想进行了深入理解。
算法课设实验报告(3篇)

第1篇一、实验背景与目的随着计算机技术的飞速发展,算法在计算机科学中扮演着至关重要的角色。
为了加深对算法设计与分析的理解,提高实际应用能力,本实验课程设计旨在通过实际操作,让学生掌握算法设计与分析的基本方法,学会运用所学知识解决实际问题。
二、实验内容与步骤本次实验共分为三个部分,分别为排序算法、贪心算法和动态规划算法的设计与实现。
1. 排序算法(1)实验目的:熟悉常见的排序算法,理解其原理,比较其优缺点,并实现至少三种排序算法。
(2)实验内容:- 实现冒泡排序、快速排序和归并排序三种算法。
- 对每种算法进行时间复杂度和空间复杂度的分析。
- 编写测试程序,对算法进行性能测试,比较不同算法的优劣。
(3)实验步骤:- 分析冒泡排序、快速排序和归并排序的原理。
- 编写三种排序算法的代码。
- 分析代码的时间复杂度和空间复杂度。
- 编写测试程序,生成随机测试数据,测试三种算法的性能。
- 比较三种算法的运行时间和内存占用。
2. 贪心算法(1)实验目的:理解贪心算法的基本思想,掌握贪心算法的解题步骤,并实现一个贪心算法问题。
(2)实验内容:- 实现一个贪心算法问题,如活动选择问题。
- 分析贪心算法的正确性,并证明其最优性。
(3)实验步骤:- 分析活动选择问题的贪心策略。
- 编写贪心算法的代码。
- 分析贪心算法的正确性,并证明其最优性。
- 编写测试程序,验证贪心算法的正确性。
3. 动态规划算法(1)实验目的:理解动态规划算法的基本思想,掌握动态规划算法的解题步骤,并实现一个动态规划算法问题。
(2)实验内容:- 实现一个动态规划算法问题,如背包问题。
- 分析动态规划算法的正确性,并证明其最优性。
(3)实验步骤:- 分析背包问题的动态规划策略。
- 编写动态规划算法的代码。
- 分析动态规划算法的正确性,并证明其最优性。
- 编写测试程序,验证动态规划算法的正确性。
三、实验结果与分析1. 排序算法实验结果:- 冒泡排序:时间复杂度O(n^2),空间复杂度O(1)。
算法分析与设计实验报告合并排序快速排序

算法分析与设计实验报告:合并排序与快速排序一、引言算法是计算机科学中非常重要的一部分,它涉及到解决问题的方法和步骤。
合并排序和快速排序是两种经典而常用的排序算法。
本文将对这两种排序算法进行分析和设计实验,通过对比它们的性能和效率,以期得出最优算法。
二、合并排序合并排序是一种分治算法,它将原始数组不断分解为更小的数组,直到最后细分为单个元素。
然后,再将这些单个元素两两合并,形成一个有序数组。
合并排序的核心操作是合并两个有序的数组。
1. 算法步骤(1)将原始数组分解为更小的子数组,直到每个子数组只有一个元素;(2)两两合并相邻的子数组,同时进行排序,生成新的有序数组;(3)重复步骤(2),直到生成最终的有序数组。
2. 算法性能合并排序的最优时间复杂度为O(nlogn),其中n为待排序数组的长度。
无论最好情况还是最坏情况,合并排序的复杂度都相同。
合并排序需要额外的存储空间来存储临时数组,所以空间复杂度为O(n)。
三、快速排序快速排序也是一种分治算法,它将原始数组根据一个主元(pivot)分成两个子数组,一个子数组的元素都小于主元,另一个子数组的元素都大于主元。
然后,递归地对这两个子数组进行排序,最后得到有序数组。
快速排序的核心操作是划分。
1. 算法步骤(1)选择一个主元(pivot),可以是随机选择或者固定选择第一个元素;(2)将原始数组根据主元划分为两个子数组,一个子数组的元素都小于主元,另一个子数组的元素都大于主元;(3)递归地对这两个子数组进行快速排序;(4)重复步骤(2)和(3),直到每个子数组只有一个元素,即得到最终的有序数组。
2. 算法性能快速排序的平均时间复杂度为O(nlogn),其中n为待排序数组的长度。
最坏情况下,当每次选择的主元都是最小或最大元素时,时间复杂度为O(n^2)。
快速排序是原地排序,不需要额外的存储空间,所以空间复杂度为O(1)。
四、实验设计为了验证合并排序和快速排序的性能和效率,我们设计以下实验:1. 实验目的:比较合并排序和快速排序的时间复杂度和空间复杂度。
算法分析与设计实验报告

算法分析与设计实验报告算法分析与设计实验报告一、引言算法是计算机科学的核心,它们是解决问题的有效工具。
算法分析与设计是计算机科学中的重要课题,通过对算法的分析与设计,我们可以优化计算机程序的效率,提高计算机系统的性能。
本实验报告旨在介绍算法分析与设计的基本概念和方法,并通过实验验证这些方法的有效性。
二、算法分析算法分析是评估算法性能的过程。
在实际应用中,我们常常需要比较不同算法的效率和资源消耗,以选择最适合的算法。
常用的算法分析方法包括时间复杂度和空间复杂度。
1. 时间复杂度时间复杂度衡量了算法执行所需的时间。
通常用大O表示法表示时间复杂度,表示算法的最坏情况下的运行时间。
常见的时间复杂度有O(1)、O(log n)、O(n)、O(n log n)和O(n^2)等。
其中,O(1)表示常数时间复杂度,O(log n)表示对数时间复杂度,O(n)表示线性时间复杂度,O(n log n)表示线性对数时间复杂度,O(n^2)表示平方时间复杂度。
2. 空间复杂度空间复杂度衡量了算法执行所需的存储空间。
通常用大O表示法表示空间复杂度,表示算法所需的额外存储空间。
常见的空间复杂度有O(1)、O(n)和O(n^2)等。
其中,O(1)表示常数空间复杂度,O(n)表示线性空间复杂度,O(n^2)表示平方空间复杂度。
三、算法设计算法设计是构思和实现算法的过程。
好的算法设计能够提高算法的效率和可靠性。
常用的算法设计方法包括贪心算法、动态规划、分治法和回溯法等。
1. 贪心算法贪心算法是一种简单而高效的算法设计方法。
它通过每一步选择局部最优解,最终得到全局最优解。
贪心算法的时间复杂度通常较低,但不能保证得到最优解。
2. 动态规划动态规划是一种将问题分解为子问题并以自底向上的方式求解的算法设计方法。
它通过保存子问题的解,避免重复计算,提高算法的效率。
动态规划适用于具有重叠子问题和最优子结构的问题。
3. 分治法分治法是一种将问题分解为更小规模的子问题并以递归的方式求解的算法设计方法。
算法设计与分析实验报告(中南民族大学)

院系:计算机科学学院专业:年级:课程名称:算法设计与分析基础班号:组号:指导教师:年月日实验结果及分析1.求最大数2.递归法与迭代法性能比较递归迭代3.改进算法1.利用公式法对第n项Fibonacci数求解时可能会得出错误结果。
主要原因是由于double类型的精度还不够,所以程序算出来的结果会有误差,要把公式展开计算。
2.由于递归调用栈是一个费时的过程,通过递归法和迭代法的比较表明,虽然递归算法的代码更精简更有可读性,但是执行速度无法满足大数问题的求解。
3.在当前计算机的空间较大的情况下,在一些速度较慢的问题中,空间换时间是一个比较周全的策略。
实验原理(算法基本思想)定义:若A=(a ij), B=(b ij)是n×n的方阵,则对i,j=1,2,…n,定义乘积C=A⋅B 中的元素c ij为:1.分块解法通常的做法是将矩阵进行分块相乘,如下图所示:二.Strassen解法分治法思想将问题实例划分为同一问题的几个较小的实例。
对这些较小实例求解,通常使用递归方法,但在问题规模足够小时,也会使用另一种算法。
如果有必要,合并这些问题的解,以得到原始问题的解。
求解矩阵相乘的DAC算法,使用了strassen算法。
DAC(A[],B[],n){If n=2 使用7次乘法的方法求得解ElseDivide(A)//把A分成4块Divide(B)//把B分成4块调用7次strassen算法求得解的4块合并这4块得到解并返回}伪代码Serial_StrassenMultiply(A, B, C) {T1 = A0 + A3;T2 = B0 + B3;StrassenMultiply(T1, T2, M1);T1 = A2 + A3;StrassenMultiply(T1, B0, M2);T1 = (B1 - B3);StrassenMultiply (A0, T1, M3);T1 = B2 - B0;StrassenMultiply(A3, T1, M4);T1 = A0 + A1;StrassenMultiply(T1, B3, M5);T1 = A2 – A0;T2 = B0 + B1;StrassenMultiply(T1, T2, M6);T1 = A1 – A3;T2 = B2 + B3;StrassenMultiply(T1, T2, M7);C0 = M1 + M4 - M5 + M7C1 = M3 + M5C2 = M2 + M4C3 = M1 - M2 + M3 + M6}实验结果及分析时间复杂度1.分块相乘总共用了8次乘法,因而需要Θ(n log28)即Θ(n3)的时间复杂度。
算法设计与分析:递归与分治法-实验报告(总8页)

算法设计与分析:递归与分治法-实验报告(总8页)实验目的:掌握递归与分治法的基本思想和应用,学会设计和实现递归算法和分治算法,能够分析和评价算法的时间复杂度和空间复杂度。
实验内容:1.递归算法的设计与实现3.算法的时间复杂度和空间复杂度分析实验步骤:1)递归定义:一个函数或过程,在其定义或实现中,直接或间接地调用自身的方法,被成为递归。
递归算法是一种控制结构,它包含了解决问题的基础情境,也包含了递归处理的情境。
2)递归特点:递归算法具有以下特点:①依赖于递归问题的部分解被划分为若干较小的部分。
②问题的规模可以通过递推式递减,最终递归终止。
③当问题的规模足够小时,可以直接求解。
3)递归实现步骤:①确定函数的定义②确定递归终止条件③确定递归调用的过程4)经典实例:斐波那契数列递推式:f(n) = f(n-1) + f(n-2)int fib(int n) {if (n <= 0)return 0;else}5)优化递归算法:避免重复计算例如,上述斐波那契数列的递归算法会重复计算一些中间结果,影响效率。
可以使用动态规划技术,将算法改为非递归形式。
int f1 = 0, f2 = 1;for (int i = 2; i <= n; i++) {f1 = f2;使用循环避免递归,重复计算可以大大减少,提高效率。
1)分治算法的定义:将原问题分解成若干个规模较小且类似的子问题,递归求解子问题,然后合并各子问题得到原问题的解。
2)分治算法流程:②将问题分解成若干个规模较小的子问题。
③递归地解决各子问题。
④将各子问题的解合并成原问题的解。
3)分治算法实例:归并排序归并排序是一种基于分治思想的经典排序算法。
排序流程:②分别对各子数组递归进行归并排序。
③将已经排序好的各子数组合并成最终的排序结果。
实现源代码:void mergeSort(int* arr, int left, int right) {if (left >= right)while (i <= mid && j <= right)temp[k++] = arr[i] < arr[j] ? arr[i++] : arr[j++];temp[k++] = arr[i++];1) 时间复杂度的概念:指完成算法所需的计算次数或操作次数。
算法设计与分析实验报告

算法设计与分析实验报告实验一全排列、快速排序【实验目的】1. 掌握全排列的递归算法。
2. 了解快速排序的分治算法思想。
【实验原理】一、全排列全排列的生成算法就是对于给定的字符集,用有效的方法将所有可能的全排列无重复无遗漏地枚举出来。
任何n个字符集的排列都可以与1~n的n个数字的排列一一对应,因此在此就以n 个数字的排列为例说明排列的生成法。
n个字符的全体排列之间存在一个确定的线性顺序关系。
所有的排列中除最后一个排列外,都有一个后继;除第一个排列外,都有一个前驱。
每个排列的后继都可以从它的前驱经过最少的变化而得到,全排列的生成算法就是从第一个排列开始逐个生成所有的排列的方法。
二、快速排序快速排序(Quicksort)是对冒泡排序的一种改进。
它的基本思想是:通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。
【实验内容】1.全排列递归算法的实现。
2.快速排序分治算法的实现。
【实验结果】1. 全排列:2. 快速排序:实验二最长公共子序列、活动安排问题【实验目的】1. 了解动态规划算法设计思想,运用动态规划算法实现最长公共子序列问题。
2. 了解贪心算法思想,运用贪心算法设计思想实现活动安排问题。
【实验原理】一、动态规划法解最长公共子序列设序列X=和Y=的一个最长公共子序列Z=,则:i. 若xm=yn,则zk=xm=yn且Zk-1是Xm-1和Yn-1的最长公共子序列;ii. 若xm≠yn且zk≠xm ,则Z是Xm-1和Y的最长公共子序列;iii. 若xm≠yn且z k≠yn ,则Z是X和Yn-1的最长公共子序列。
其中Xm-1=,Yn-1=,Zk-1=。
最长公共子序列问题具有最优子结构性质。
由最长公共子序列问题的最优子结构性质可知,要找出X=和Y=的最长公共子序列,可按以下方式递归地进行:当xm=yn时,找出Xm-1和Yn-1的最长公共子序列,然后在其尾部加上xm(=yn)即可得X和Y的一个最长公共子序列。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
算法设计与分析实验报告教师:学号:姓名:实验一:串匹配问题实验目的:(1) 深刻理解并掌握蛮力法的设计思想;(2) 提高应用蛮力法设计算法的技能;(3) 理解这样一个观点: 用蛮力法设计的算法, 一般来说, 经过适度的努力后, 都可以对算法的第一个版本进行一定程度的改良, 改进其时间性能。
三、实验要求:( 1) 实现BF 算法;(2 ) 实现BF 算法的改进算法: KMP 算法和BM 算法;(3 ) 对上述 3 个算法进行时间复杂性分析, 并设计实验程序验证分析结果。
#include "stdio.h"#include "conio.h"#include <iostream>//BF算法int BF(char s[],char t[]){ int i; int a; int b; int m,n; m=strlen(s); //主串长度n=strlen(t); //子串长度printf("\n*****BF*****算法\n");for(i=0;i<m;i++){ b=0; a=i; while(s[a]==t[b]&&b!=n){a++; b++; }if(b==n){ printf("查找成功!!\n\n"); return 0;}}printf("找不到%s\n\n",t); return 0; }//前缀函数值,用于KMP算法int GETNEXT(char t[],int b){ int NEXT[10]; NEXT[0]=-1;int j,k; j=0; k=-1; while(j<strlen(t)){if ((k==-1)||(t[j]==t[k])){j++;k++;NEXT[j]=k; }else k=NEXT[k];}b=NEXT[b];return b;}//KMP算法int KMP(char s[],char t[]){int a=0; int b=0;int m,n; m=strlen(s); //主串长度n=strlen(t); //子串长度printf("\n*****KMP算法*****\n");while(a<=m-n){while(s[a]==t[b]&&b!=n){a++;b++; }if(b==n){printf("查找成功!!\n\n");return 0;}b=GETNEXT(t,b);a=a-b;if(b==-1) b++;}printf("找不到%s\n\n",t);return 0; } //滑动距离函数,用于BM算法int DIST(char t[],char c){ int i=0,x=1;int n; n=strlen(t);while(x&&i!=n-1){if(t[i]==c)x=0;else i++;}if(i!=n-1)n=n-1-i;return n; } //BM算法结果分析与体会:glibc里的strstr函数用的是brute-force(naive)算法,它与其它算法的区别是strstr不对pattern(needle)进行预处理,所以用起来很方便。
理论复杂度O(mn), 实际上,平均复杂度为O(n), 大部分情况下高度优化的算法性能要优于基于自动机的匹配算法,BF有一个重要性质是事先不用知道串的长度,而基于跳跃的算法是需要用字符串长度来判断结束位置的。
实验二:最近对问题二、实验目的:( 1) 进一步掌握递归算法的设计思想以及递归程序的调试技术;(2 ) 理解这样一个观点: 分治与递归经常同时应用在算法设计之中。
三、实验要求:( 1) 分别用蛮力法和分治法求解最近对问题;(2 ) 分析算法的时间性能, 设计实验程序验证分析结论。
ClosestPair1.java //蛮力算法import java.util.*; public class ClosestPair1 {public static void main(String[] args) { /***输入需要比较的点的对数存在变量n中 */Scanner in=new Scanner(System.in);System.out.println("How many pairs of points to compare?(有多少对点需要比较?)"); int n=in.nextInt();int[] x=new int[n]; int[] y=new int[n]; /***输入这些点的横坐标和纵坐标分别存储在x[n]和y[n] */System.out.println("Please enter these points,X-coordinate(请输入这些点,横坐标):"); for(int i=0;i<n;i++) {x[i]=in.nextInt(); }System.out.println("Please enter these points,Y-coordinate(请输入这些点,纵坐标):"); for(int i=0;i<n;i++) {y[i]=in.nextInt(); }double minDist=Double.POSITIVE_INFINITY; double d; int indexI=0; int indexJ=0; /* **求解最近对距离存在minDist中 */double startTime=System.currentTimeMillis();//startTime for(int i=0;i<n-1;i++) {for(int j=i+1;j<n;j++) {d=Math.sqrt((x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j])); if(d<minDist) {minDist=d; indexI=i; indexJ=j; } } }double endTime=System.currentTimeMillis();//endTime /***打印输出最后求出的结果,最近的是哪两个点,以及最近距离和程序用的时间 */System.out.println("Theclosestpairis:("+x[indexI]+","+y[indexI]+")and("+x[indexJ]+","+y[indexJ]+")");System.out.println("The closest distance is "+minDist);System.out.println("Basic Statements take(基本语句用时) "+(endTime-startTime)+" milliseconds!"); }}ClosestPair2.java //分治算法import java.util.*; public class ClosestPair2 {public static void main(String[] args) { /***输入需要比较的点的对数存在变量n中 */Scanner in=new Scanner(System.in);System.out.println("How many pairs of points to compare?(有多少对点需要比较?)");int n=in.nextInt(); /***输入这些点的横坐标和纵坐标,存储在点数组S[n]中 */System.out.println("Please enter these points,X-coordinate and Y-coordinate.(请输入这些点,x 坐标和y坐标):");Point[] S=new Point[n];double startTime=System.currentTimeMillis();//starttimefor(int i=0;i<n;i++) {int x=in.nextInt(); int y=in.nextInt(); S[i]=new Point(x,y);System.out.println("("+S[i].getX()+","+S[i].getY()+")"); } /***求出这点的x坐标的中位数mid */int minX=(int)Double.POSITIVE_INFINITY; int maxX=(int)Double.NEGA TIVE_INFINITY; for(int i=0;i<n;i++) {if(S[i].getX()<minX) minX=S[i].getX(); if(S[i].getX()>maxX) maxX=S[i].getX(); } int mid=(minX+maxX)/2; /***以mid为界把S中的点分为两组分别存放在范型数组列表point1和point2中 */ArrayList<Point> point1=new ArrayList<Point>(); ArrayList<Point> point2=new ArrayList<Po int>(); for(int i=0;i<n;i++) {if(S[i].getX()<=mid) point1.add(S[i]); elsepoint2.add(S[i]); } /***将范型数组列表转换为数组类型S1和S2 */Point[] S1=new Point[point1.size()]; Point[] S2=new Point[point2.size()]; point1.toArray (S1); point2.toArray(S2); /***将S1和S2中的点按x 坐标升序排列 */ sortX(S1); sortX(S2); /***打印输出排序后S1和S2的点 */System.out.print("The points in S1 are:"); for(int i=0;i<S1.length;i++)System.out.print("("+S1[i].getX()+","+S1[i].getY()+") "); System.out.println();System.out.print("The points in S2 are:"); for(int i=0;i<S2.length;i++)System.out.print("("+S2[i].getX()+","+S2[i].getY()+") "); System.out.println(); /***求S1中点的最近对及其距离并打印输出结果 */double minDist1=Double.POSITIVE_INFINITY; int indexI1=0; int indexJ1=0;for(int i=0;i<S1.length-1;i++) {for(int j=i+1;j<S1.length;j++) { doubled=Math.sqrt(Math.pow((S1[i].getX()-S1[j].getX()),2)+Math.pow((S1[i].getY()-S1[j].getY()),2)); if(d<minDist1) {minDist1=d; indexI1=i; indexJ1=j; } } }System.out.println("The closest pair in S1 is: "+"("+S1[indexI1].getX()+","+S1[indexI1].getY()+ ")"+ "and("+S1[indexJ1].getX()+","+S1[indexJ1].getY()+")"+",and the distance is "+minDist1); /***求S2中点的最近对及其距离并打印输出结果 */double minDist2=Double.POSITIVE_INFINITY;int indexI2=0; int indexJ2=0;for(int i=0;i<S2.length-1;i++) {for(int j=i+1;j<S2.length;j++) { doubled=Math.sqrt(Math.pow((S2[i].getX()-S2[j].getX()),2)+Math.pow((S2[i].getY()-S2[j].getY()),2)); if(d<minDist2) {minDist2=d; indexI2=i; indexJ2=j; } } }System.out.println("The closest pair in S2 is: "+"("+S2[indexI2].getX()+","+S2[indexI2].getY()+ ")"+ "and("+S2[indexJ2].getX()+","+S2[indexJ2].getY()+")"+",and the distance is "+minDist2);double d1=Math.min(minDist1,minDist2); /***求出S1和S2中点的横坐标离小于d1的所有点分别存在P1[]和P2[]中 */ArrayList<Point> pp1=new ArrayList<Point>(); ArrayList<Point> pp2=new ArrayList<Point>( ); for(int i=0;i<S1.length;i++) {if((mid-S1[i].getX())<d1) pp1.add(S1[i]); }for(int i=0;i<S2.length;i++) {if((S2[i].getX()-mid)<d1) pp2.add(S2[i]); }Point[] P1=new Point[pp1.size()]; Point[] P2=new Point[pp2.size()]; pp1.toArray(P1); p p2.toArray(P2);/**将P1和P2中的点按Y坐标升序排列 */ sortY(P1); sortY(P2);/ *求解P1和P2两者之间可能的最近对距离 */double d2=Double.POSITIVE_INFINITY; for(int i=0;i<P1.length;i++){for(int j=0;j<P2.length;j++){if(Math.abs(P1[i].getY()-P2[j].getY())<d1){double temp=Math.sqrt(Math.pow((P1[i].getX()-P2[j].getX()),2)+Math.pow((P1[i].getX()-P2[j] .getX()),2));if(temp<d2)d2=temp;}}}double endTime=System.currentTimeMillis();//endtime /***打印输出最后求出的结果,最近的是哪两个点,以及最近距离和程序用的时间 */System.out.print("The points in P1 are:"); for(int i=0;i<P1.length;i++)System.out.print("("+P1[i].getX()+","+P1[i].getY()+") "); System.out.println();System.out.print("The points in P2 are:"); for(int i=0;i<P2.length;i++)System.out.print("("+P2[i].getX()+","+P2[i].getY()+") "); System.out.println();System.out.println("d2="+d2); double minDist=Math.min(d1,d2);System.out.println("The closest distance is "+minDist);System.out.println("Basic Statements take(基本语句用时) "+(endTime-startTime)+" milliseconds!"); } /***设计按点Point的x坐标升序排列的函数sortX */public static void sortX(Point[] p) {for(int i=0;i<p.length-1;i++) {for(int j=0;j<p.length-1-i;j++) {if(p[j].getX()>p[j+1].getX()) {int t=p[j].getX();p[j].setX(p[j+1].getX()); p[j+1].setX(t);int n=p[j].getY(); p[j].setY(p[j+1].getY()); p[j+1].setY(n); } } } } /***设计按点Point的y坐标升序排列的函数sortY */public static void sortY(Point[] p) {for(int i=0;i<p.length-1;i++) {for(int j=0;j<p.length-1-i;j++) {if(p[j].getY()>p[j+1].getY()) {int t=p[j].getY(); p[j].setY(p[j+1].getY()); p[j+1].setY(t);int n=p[j].getX(); p[j].setX(p[j+1].getX()); p[j+1].setX(n); } } } } } /***建立自己的类Point */class Point implements Cloneable {public Point() { x=0; y=0; }public Point(int x,int y) {this.x=x; this.y=y; }public void setX(int x) {this.x=x; }public void setY(int y) {this.y=y; }public int getX() {return x; }public int getY() {return y; }private int x; private int y; }实验结果与结论:算法复杂度分析:为提高算法效率,在算法中采用预排序技术,即在使用分治法之前,预先将S中的n个点依其y坐标排序好。