数据结构_经典查找算法(3)

四、索引查找

　　索引查找（index search）又称分级查找。

       索引存储的基本思想是：首先把主表按照一定的关系划分成若干个子表，为每个子表建立一个索引项，由所有的这些索引项构成主表的一个索引表，然后，可以采用顺序或者链接的方式来存储索引表和每个子表。

　　索引表中的每个索引项通常包含三个域（至少包含前两个域）：一是索引值域（index），用来存储标识对应子表的索引值，相当于记录的关键字；二是子表的开始位置域（start），用来存储对应子表的第一个元素的存储位置；三是子表长度域（length），用来存储对应子表的元素个数。

注意：有bug待修改~

#include <iostream>
using namespace std;
class IndexItem
{
public:
int key;
int start;
int length;
IndexItem(){key=0;start=0;length=0;}
};

class IndexTable
{
public:
int index_key;
int id;
//IndexItem index_item;
};

void InsertIndex(IndexItem* indexitem,int m,int A[],int len)//形成索引表
{
int num=len/m+1;//索引表的长度
for (int j=0;j<m;j++)
{
	int i;
	int max=j*num;
	for ( i=0;i<num &&(j*num+i)<len;i++)
	{
		
		if (A[max]<A[j*num+i])
		{
			max=j*num+i;
		}
	}
	indexitem[j].key=A[max];
	indexitem[j].length=num;
	indexitem[j].start=j*num;
}
}

void SortIndex(IndexItem* indexitem,int m,IndexTable* indextable)
{
	for (int j=0;j<m;j++)
	{
		indextable[j].id=j;
		indextable[j].index_key=indexitem[j].key;
	}

	for (int j=0;j<m-1;j++)
	{
		for (int i=m-1;i>j;i--)
		{
			if (indextable[i].index_key<indextable[i-1].index_key)
			{
				int temp_id,temp_key;
				temp_id=indextable[i].id;
				temp_key=indextable[i].index_key;
				indextable[i].id=indextable[i-1].id;
				indextable[i].index_key=indextable[i-1].index_key;
				indextable[i-1].id=temp_id;
				indextable[i-1].index_key=temp_key;
			}
		}
	}
}

int SearchIndex(IndexItem* indexitem,IndexTable* indextable,int m,int value,int A[],int n)
{   
	int j;
	bool flag=false;
	for (j=0;j<m;j++)
	{
		if (value< indextable[j].index_key)
		{
			flag=true;
			break;
		}
	}
	if (flag==false)
	{
		return -1;
	}
	int id=indextable[j].id;
	int start=indexitem[id].start;
	int len=indexitem[id].length;
	bool flag2=false;
	int k=start;
	for (;k<(start+len)&&k<n;k++)
	{
		if (A[k]==value)
		{   
			flag2=true;
			return k;
		}
	}

	if (flag2==false)
	{
		return -1;
	}
}

int main()
{
	int A[20]={13, 29, 27, 28, 26, 30, 38, 54 , 68 ,36,125,52,54,86,25,34,79,63,14,17};
	IndexItem indexitem[4];
	InsertIndex(indexitem,4,A,20);
	IndexTable indextable[4];
	SortIndex(indexitem,4,indextable);

	int data;
	while (1)
	{

		cout<<"请输入要查找的数据： "<<endl;
		cin>>data;
		int result=SearchIndex(indexitem,indextable,4,data,A,20);
		if(result!=-1)
			cout<<"Find the key: "<<result<<endl;
		else
			cout<<"Can't Find the key! "<<endl;

	}
	system("pause");
	return 0;
}

分块查找

　　分块查找（blocking search）属于索引查找。它要求主表中每个子表（子表又称为块）之间是有序的（递增或递减）。

　　比如递增，即前块中的最大关键字必须小于后块中的最小关键字。但每个块中的元素排列次序可以是任意的。

　　它还要求索引表中的每个索引项的索引值域用来存储对应块中的最大关键字。

　　索引表是有序的，主表中的关键字域和索引表中的索引值域具有相同的数据类型，即为关键字所属的类型。

　　由于索引表是有序的，所以在索引表上既可采用顺序查找，又可采用二分查找，而每个块中的记录排列是任意的，所以在块内只能采用顺序查找