实验1++递归与分治算法

淮海工学院计算机工程学院实验报告书
课程名：《算法分析与设计》
题目：实验1 递归与分治算法
班级：
学号：
姓名：
实验1 递归与分治算法
实验目的和要求
（1）进一步掌握递归算法的设计思想以及递归程序的调试技术；
（2）理解这样一个观点：分治与递归经常同时应用在算法设计之中。

（3）分别用蛮力法和分治法求解最近对问题；
（4）分析算法的时间性能，设计实验程序验证分析结论。

实验内容
设p1=(x1, y1), p2=(x2, y2), …, pn=(xn, yn)是平面上n个点构成的集合S，设计算法找出集合S中距离最近的点对。

实验环境
Turbo C 或VC++
实验学时
2学时，必做实验
数据结构与算法
核心源代码
蛮力法：
#include <iostream.h>
#include <stdio.h>
#include <math.h>
int ClosestPoints(int x[ ], int y[ ], int n);
int main()
{
int x[3],y[3];
printf("请输入各点的横坐标: ");
for(int i=0;i<4;i++)
{
scanf("%d",&x[i]);
}
printf("请输入各点的纵坐标: ");
for(int j=0;j<4;j++)
{
scanf("%d",&y[i]);
}
ClosestPoints(x,y,4);
return 0;
}
int ClosestPoints(int x[ ], int y[ ], int n)
{
int index1, index2; //记载最近点对的下标
int d, minDist = 1000; //假设最大距离不超过1000 for (int i = 0; i < n - 1; i++)
for (int j = i + 1; j < n; j++) //只考虑i＜j的点对
{
d =sqrt ((x[i]-x[j])* (x[i]-x[j]) + (y[i]-y[j])* (y[i]-y[j]));
if (d < minDist) {
minDist = d;
index1 = i; index2 = j;
}
}
cout<<"最近的点对是："<<index1<<" 和"<<index2<<endl;
return minDist;
}
分治法：
#include <iostream.h>
#include <math.h>
const int n = 4;
struct point //定义点的结构体
{
int x, y;
};
double Closest(point S[ ], int low, int high);
double Distance(point a, point b);
int Partition(point r[ ], int first, int end);
void QuickSort(point r[ ], int first, int end);
int main()
{
point S[n] = {{1,1},{3,2},{5,4},{1,2}}; //存放点集合
double minDist = Closest(S,0,n-1);
cout<<"最近点对之间的距离为:"<<minDist<<endl;
return 0;
}
double Closest(point S[ ], int low, int high)
{
double d1, d2, d3, d;
int mid, i, j, index;
point P[n]; //存放P1和P2
if (high - low == 1) //只有两个点返回两点之间的距离return Distance(S[low], S[high]);
if (high - low == 2) //只有三个点求最近对距离
{
d1 = Distance(S[low], S[low+1]);
d2 = Distance(S[low+1], S[high]);
d3 = Distance(S[low], S[high]);
if ((d1 < d2) && (d1 < d3))
return d1;
else if (d2 < d3)
return d2;
else return d3;
}
mid = (low + high)/2; //计算中间点
d1 = Closest(S, low, mid); //递归求解子问题1
d2 = Closest(S, mid+1, high); //递归求解子问题2
if (d1 <= d2) d = d1; //以下为求解子问题3
else d = d2;
index = 0;
for (i = mid; (i >= low) && (S[mid].x - S[i].x < d); i--) //建立点集合p1 P[index++] = S[i];
for (i = mid + 1; (i <= high) && (S[i].x - S[mid].x < d); i++) //建立点集合p2 P[index++] = S[i];
QuickSort(P, 0, index-1); //对集合p1和p2按y坐标升序排列
for (i = 0; i < index; i++)//依次处理集合p1和p2中的点
{
for(j = i + 1; j < index; j++)
{
if (P[j].y - P[i].y >= d) //超出y坐标的范围，点p[i]处理完毕
break;
else
{
d3 = Distance(P[i], P[j]);
if (d3 < d)
d = d3;
}
}
}
return d;
}
//求两点之间的距离
double Distance(point a, point b)
{
return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}
int Partition(point r[ ], int first, int end) //划分
{
int i = first, j=end; //初始化待划分区间
while (i < j)
{
while (i < j && r[i].y <= r[j].y) j--; //右侧扫描
if (i < j) {
point temp = r[i]; r[i] = r[j]; r[j] = temp; //将较小记录交换到前面
i++;
}
while (i < j && r[i].y <= r[j].y) i++; //左侧扫描
if (i < j) {
point temp = r[i]; r[i] = r[j]; r[j] = temp; //将较大记录交换到后面
j--;
}
}
return i; // 返回轴值记录的位置
}
//快速排序
void QuickSort(point r[ ], int first, int end) //快速排序
{
int pivot;
if (first < end) {
pivot = Partition(r, first, end); //划分，pivot是轴值在序列中的位置
QuickSort(r, first, pivot-1); //求解子问题1，对左侧子序列进行快速排序QuickSort(r, pivot+1, end); //求解子问题2，对右侧子序列进行快速排序}
}
实验结果
实验体会
本次实验做的是集合之中距离最近的点对，首先对最近点对进行分析，可以用蛮力法和分治法解决。

蛮力法在处理比较少的数据时比较简单，个人感觉也比较简单易于理解。

主要是将各点的横坐标和纵坐标分别放入两个数组中，在两个for循环来计算两个点之间的距离，并记录距离较短的时候的点对坐标。

分治法的算法相对来说比较复杂，首先将问题进行划分，然后在求解子问题，最后在进行合并。

分治法是照着书上敲的，书上提供了最近点对和求距离的方法，在此基础上又写了快速排序和划分的方法，最后才完整的运行出来。

整体感觉自己的代码敲写能力还有待加强，算法设计的逻辑能力还欠缺，不能独立的解决问题。