查找技术：有序表的对分查找（折半查找）类

一 查找技术相关总结：

1.顺序查找：（1）如果线性表为无序表（即表中元素的排序是无序的），则不管是顺序存储结构还是链式存储结构，都只能用顺序查找；（2）即使是有序线性表，如果采用链式存储结构，也只能用顺序查找。

2.有序表的对分查找：条件：顺序存储的有序表。

3.分块查找（又称索引顺序查找）：分块有序表结构分为两部分（1）线性表本身采用顺序存储结构（2）在建立一个索引表，在索引表中，对线性表的每个子表建立一个索引结点，每个结点包括两个域：一个数据域，用于存放对应子表中的最大元素值；二是指针域，用于指示对应子表的第一个元素在整个线性表中的序号。显然，索引表关于数据域是有序的。

4.二叉排序树查找

5.多层索引树查找（B-和B+树)

二 对分查找类：

1.对分查找类SL_Link.h

#include<iostream.h>
template <class T>
class SL_List
{
	private:
		int mm;//存储空间容量
		int nn;//表长度
		T *v;
	public:
		SL_List(){mm=0;nn=0;return;}//只定义对象
		SL_List(int);//顺序有序表初始化（指定存储空间容量）
		int search_SL_List(T);//顺序有序表查找
		int insert_SL_List(T);//顺序有序表插入
		int delete_SL_List(T);//顺序有序表删除
		void prt_SL_List();//顺序输出有序表中元素与有序表长度
		friend SL_List operator +(SL_List &,SL_List &);//有序表合并
};
//顺序有序表初始化（指定存储空间容量）
template <class T>
SL_List<T>::SL_List(int m)
{
	mm=m;
	v=new T[mm];
	nn=0;
	return;
}
//顺序有序表查找
template <class T>
int SL_List<T>::search_SL_List(T x)
{
	int i,j,k;
	i=1;j=nn;
	while(i<=j)
	{
		k=(i+j)/2;
		if(v[k-1]==x)
			return(k-1);
		if(v[k-1]>x)
			j=k-1;
		else i=k+1;
	}
	return -1;
}
//顺序有序表插入
template <class T>
int SL_List<T>::insert_SL_List(T x)
{
	int k;
	if(nn==mm)
	{
		cout<<"上溢！"<<endl;return -1;
	}
	k=nn-1;
	while(v[k]>x)
	{
		v[k+1]=v[k];
		k=k-1;
	}
	v[k+1]=x;
	nn=nn+1;
	return 1;
}
//顺序有序表删除
template <class T>
int SL_List<T>::delete_SL_List(T x)
{
	int i,k;
	k=search_SL_List(x);
	if(k>=0)
	{
		for(i=k;i<nn-1;i++)
			v[i]=v[i+1];
			nn=nn-1;	
	}
	else
		cout<<"没有这个元素！"<<endl;
	return k;
}


//顺序输出有序表中元素与有序表长度

template <class T>
void SL_List<T>::prt_SL_List()
{
	int i;
	cout<<"nn="<<nn<<endl;
	for(i=0;i<nn;i++)
		cout<<v[i]<<endl;
	return;

}
//有序表合并
template <class T>
SL_List<T> operator +(SL_List<T> &s1,SL_List<T> &s2)
{
	int k=0,i=0,j=0;
	SL_List<T> s;
	s.v=new T[s1.nn+s2.nn];
	while((i<s1.nn)&&(j<s2.nn))
	{
		if(s1.v[i]<=s2.v[j])
		{
			s.v[k]=s1.v[i];i=i+1;
		}
		else
		{
			s.v[k]=s2.v[j];j=j+1;
		}
		k=k+1;
	}
	if(i==s1.nn)
	{
		for(i=j;i<s2.nn;i++)
		{
			s.v[k]=s2.v[i];k=k+1;
		}
	}
	else
		for(j=i;j<s1.nn;j++)
		{	s.v[k]=s1.v[j];k=k+1;
		}
	
	s.nn=s1.nn+s2.nn;
	s.mm=s1.mm+s2.mm;
	return (s);
}

2.具体事例

#include "SL_List.h"
int main()
{
	int k;
	double a[5]={1.5,5.5,2.5,4.5,3.5};
	double b[7]={1.0,7.5,2.5,4.0,5.0,4.5,6.5};
	SL_List<double> s1(20);//建立容量为20 长度为5的有序表对象s1
	SL_List<double> s2(30);//建立容量为30 长度为7的有序表对象s2
	for(k=0;k<5;k++)//依次插入有序表的元素
		s1.insert_SL_List(a[k]);
	for(k=0;k<7;k++)
		s2.insert_SL_List(b[k]);
	cout<<"输出有序表对象s1："<<endl;
	s1.prt_SL_List();
	cout<<"输出有序表对象s2："<<endl;
	s2.prt_SL_List();
	SL_List<double> s3;
	s3=s1+s2;  //有序表合并
	cout<<"输出合并后的有序表对象s3："<<endl;
	s3.prt_SL_List();
	s3.delete_SL_List(a[0]);
	s3.delete_SL_List(b[0]);
	s3.delete_SL_List(100.0);
	cout<<"输出删除后的有序表s3："<<endl;
	s3.prt_SL_List();
	return 0;



}

3.实验结果