蛮力法分治法求最近对

实验题目

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

实验目的

（1）进一步掌握递归算法的设计思想以及递归程序的调试技术；（2）理解这样一个观点：分治与递归经常同时应用在算法设计之中。

实验内容（包括代码和对应的执行结果截图）

#include

#include

#include

using namespace std;

typedef struct Node

{//定义一个点的结构，用于表示一个点

int x;

int y;

}Node;

typedef struct NList

{//定义一个表示点的集合的结构

Node* data;

int count;

}NList;

typedef struct CloseNode

{//用于保存最近两个点以及这两个点之间的距离

Node a;

Node b;

double space;

}CloseNode;

int max;

void create(NList & L)

{

cout<<"请输入平面上点的数目:\n";

cin>>max;

L.count=max;

L.data = new Node[L.count];//====================动态空间分配

cout<<"输入"<

for(int i=0;i

cin>>L.data[i].x>>L.data[i].y;

}

//求距离平方的函数

double Distinguish2(Node a,Node b)

{

return ((a.x-b.x)*(a.x-b.x))+((a.y-b.y)*(a.y-b.y));

}

//蛮力法求最近对

void BruteForce(const NList & L,CloseNode & cnode,int begin,int end)

{

for(int i=begin;i<=end;i++)

for(int j=i+1;j<=end;j++)

{

double space = Distinguish2(L.data[i],L.data[j]);

if(space

{

cnode.a=L.data[i];

cnode.b=L.data[j];

cnode.space=space;

}

}

}

//归并排序

void Merge(Node SR[],Node TR[],int i,int m,int n)

{//将有序的SR[i..m]和SR[m+1..n]归并为有序的TR[i..n]

int j,k;

for(j=m+1,k=i;i<=m&&j<=n;k++)

if(SR[i].x<=SR[j].x) TR[k]=SR[i++];

else TR[k]=SR[j++];

while(i<=m) TR[k++]=SR[i++];

while(j<=n) TR[k++]=SR[j++];

}

void Msort(Node SR[],Node TR1[],int s,int t)

{//将SR[s..t]归并排序为TR1[s..t]

if(s==t) TR1[s]=SR[s];

else

{

int m = (s+t)/2;

Node *TR2=new Node[max];//new Node[t-s+1];//这个空间挂挂的,从s到t，

这里是从0到t-s

Msort(SR,TR2,s,m);

Msort(SR,TR2,m+1,t);

Merge(TR2,TR1,s,m,t);

}

}

void MergeSort(NList L)

{

Msort(L.data,L.data,0,L.count-1);

}

//分治法求最近对中间2d对称区的算法

void Middle(const NList & L,CloseNode & cnode,int mid,int midX)

{

int i,j;

int d = sqrt(cnode.space);

i=mid;

while(i>=0&&L.data[i].x>=(midX-d))

{

j=mid;

while(L.data[++j].x<=(midX+d)&&j<=L.count)

{//1,j++ 2<=,>=

if(L.data[j].y<(L.data[i].y-d)||L.data[j].y>(L.data[i].y+d))

continue;

double space = Distinguish2(L.data[i],L.data[j]);

if(cnode.space>space)

{

cnode.a=L.data[i];

cnode.b=L.data[j];

cnode.space=space;

}

}

i--;

}

}

// ----------------------------------------------

//分治法求最近对

void DivideAndConquer(const NList &L,CloseNode & closenode,int begin,int end) {

if((end-begin+1)<4) BruteForce(L,closenode,begin,end);

else

{

int mid = (begin+end)/2;

int midX = L.data[mid].x;

DivideAndConquer(L,closenode,begin,mid);