算法导论习题7-6

最新推荐文章于 2019-03-26 22:16:27 发布

iteye_5282

最新推荐文章于 2019-03-26 22:16:27 发布

阅读量123

点赞数

题目：

考虑这样一种排序问题,即无法准确的知道等排序的各个数字到底是多大.对于其中的每个数字,我们只知道它落在实轴上的某个区间内.亦即,给定的 n 个形如[a_i, b_i ]的闭区间,其中a_i,≤b_i .算法的目标是对这些区间进行模糊排序(fuzzy-sort),亦即,产生各区间的一个排序<i₁, i₂, i₃, i₄,…i_n >,使得存在一个 c_j ∈[a_i, b_i ],满足c₁≤c₂≤…≤c_n .

a) 为n个区间的模糊排序设计一个算法,你的算法应该具有算法的一般结构,它可以快速排序左部端点(即各a_{i }),也要能充分利用重叠区间来改善运行时间.(随着各区间重叠得越来越多,对各区间的排序的问题会变得越来越容易,你的算法应该能充分利用这种重叠.)

b) 证明: 在一般情况下,你的算法的区望运行时间为 O(n*lgn),但当所有的区间都重叠时,期望的运行时间为O(n) (亦即,当存在一个值 x, 使得对所有的 i, 都有x∈[a_i, b_i ] ).你的算法不应显式的检查这种情况,而是应当随着重叠量的增加,性能自然地有所改善.

思考：

借用快排的划分思路，以某个元素为主元，把区域划分成三段，第一段都小于主元，第二段都等于主元

重点是划分，区间如果重叠的部分，就把它们看做是相等的，并提取公共部分继续划分

a.nodeb < b.nodea ==> a < b

a.nodea > b.nodeb ==> a > b

其它情况 ==> a = b

为了避免类似于(2,2) (7,7) (1,8)这样的情况，相等时要提取公因子，并更新主元（主元不一等是某个元素）

本代码采用面向对象思路对Node的操作进行了封装，Node.h对Node的操作进行了封装：

#include<iostream>
using namespace std;
#define Max 100
class Node
{
private:
	int nodea;
	int nodeb;
public:
	//无参构造函数
	Node()
	{
		nodea=-1;
		nodeb=-1;
	}
	//带参构造函数
	Node(int a,int b):nodea(a),nodeb(b)
	{}
	//判断区间根主元区间的大小
	bool operator <(const Node Na)const
	{
		if(nodeb<Na.nodea)
			return 1;
		return 0;
	}
	bool operator >(const Node Na)const
	{
		if(nodea>Na.nodeb)
			return 1;
		return 0;
	}
	bool operator ==(const Node Na)const
	{
		if((nodea<=Na.nodeb&&nodeb>=Na.nodea))
		{
			return 1;
		}
		return 0;
	}
	void Init(Node Na)
	{
		if(Na.nodea>Na.nodeb)
		{
			cout<<"wrong num!"<<endl;
			return;
		}
		nodea=Na.nodea;
		nodeb=Na.nodeb;
	}
	int Getnodea()
	{
		return nodea;
	}
	int Getnodeb()
	{
		return nodeb;
	}
	void Swap(Node *Na)
	{
		Node temp;
		temp.nodea=Na->nodea;
		Na->nodea=nodea;
		nodea=temp.nodea;
		temp.nodeb=Na->nodeb;
		Na->nodeb=nodeb;
		nodeb=temp.nodeb;
	}
	void Setnodea(int a)
	{
		nodea=a;
	}
	void Setnodeb(int b)
	{
		nodeb=b;
	}
	void Swapnode()
	{
		int temp;
		temp=nodea;
		nodea=nodeb;
		nodeb=temp;
	}
};

ReginSort.h实现了对数组区间进行模糊排序的功能，排序的依据是在排好序的数组的每一个区间中可以找到一个数字，这些数字为有序排列：

#include"Node.h"
#include<iostream>
using namespace std;
//将区间分三段打印
//打印分段为[0,na],[na+1,nb-1],[nb,lengtha-1]
void Print(Node*a,Node b,int lengtha)
{
	int i,na,nb;
	na=b.Getnodea();
	nb=b.Getnodeb();
	//如果存在第一段则打印，即打印小于主元的区间
	if(na>=0)
	{
		for(i=0;i<=na;i++)
		{
			cout<<"["<<a[i].Getnodea()<<","<<a[i].Getnodeb()<<"]  ";
		}
		cout<<endl;
	}
	//如果存在第二段则打印，即打印等于主元的区间
	if(nb>=0)
	{
		for(i=na+1;i<nb;i++)
		{
			cout<<"["<<a[i].Getnodea()<<","<<a[i].Getnodeb()<<"]  ";
		}
		cout<<endl;
	}
	//打印大于主元的区间
	if(nb>=0&&nb<lengtha)
	{
		for(i=nb;i<lengtha;i++)
		{
			cout<<"["<<a[i].Getnodea()<<","<<a[i].Getnodeb()<<"]  ";
		}
		cout<<endl;
	}
	cout<<endl;
}
//对区域的划分，算法的关键部分，按照选定的主元进行划分
//返回划分的Node，nodea左边的为小于主元的，nodeb右边的为大于主元的，nodea和nodeb之间的为等于主元的
Node DevideRegion(Node* a,int p,int r)
{
	Node devide,x;
	x=a[r];
	int i,j,k;
	i=p-1;j=r+1;
	k=p;
	while(k<=r&&k<j)
	{
		//小于主元，该元素则放到相等区域的前面
		if(a[k]<x)
		{
			i++;
			a[k].Swap(&a[i]);
			k++;
		}
		//在此判断语句中没有k++，因为a[j]与a[k]互换后，a[j]不一定比主元小
		//因此在下一次while循环中还要对刚刚换过来的a[j]进行比较
		else if(a[k]>x)
		{
			j--;
			a[k].Swap(&a[j]);
		}
		//如果相等，则不交换，但可缩小主元区间，这样缩小的主元可以更加准确的划分数组
		else
		{
			x.Setnodea(max(a[k].Getnodea(),x.Getnodea()));
			x.Setnodeb(min(a[k].Getnodeb(),x.Getnodeb()));
			k++;
		}
	}
	//将划分后的区域界线赋给devide
	if(i>=0)
	{
		devide.Setnodea(i);
	}
	if(j<=r)
	{
		devide.Setnodeb(j);
	}
	Print(a,devide,r-p+1);
	return devide;
}
void RegionSort(Node* a,int p,int r)
{
	if(p<r)
	{
		Node devide;
		devide=DevideRegion(a,p,r);
		int na=devide.Getnodea();
		int nb=devide.Getnodeb();
		//如果存在小于主元的区间则对该区间继续调用RegionSort
		if(na>=0)
		{
			RegionSort(a,p,na);
		}
		//如果存在大于主元的区间则对该区间继续调用RegionSort
		if(nb>=0)
		{
			RegionSort(a,nb,r);
		}
	}
}

test.cpp对该算法进行了测试，所用的数组区间为随机产生，具有代表性

#include"RegionSrt.h"
#include<iostream>
using namespace std;
int main()
{
	Node A[10];
	int i,temp;
	//随机产生数组区间
	for(i = 0; i <10 ; i++)  
    {  
		A[i].Setnodea( rand() % 100);  
		A[i].Setnodeb(rand() % 100);  
		if(A[i].Getnodea() > A[i].Getnodeb())  
		{
			A[i].Swapnode();
		}  
    } 
	cout<<"the original region is :"<<endl;
	//输出原始数组
	for(i=0;i<10;i++)
	{
		cout<<"["<<A[i].Getnodea()<<","<<A[i].Getnodeb()<<"] ";
	}
	cout<<endl<<endl;
	RegionSort(A,0,9);
	cout<<endl<<endl;
	//输出排序后数组
	for(i=0;i<10;i++)
	{
		cout<<"["<<A[i].Getnodea()<<","<<A[i].Getnodeb()<<"] ";
	}
	cout<<endl;
}