一些常用的查找算法

/*顺序表查找*/

const int MaxSize = 50;

typedef int KeyType;

struct SeqList
{
	KeyType key;
	int data;
};

typedef SeqList ElemType;

ElemType A[MaxSize];

//顺序查找
#ifndef SEQSCH

int Seqsch(ElemType A[], int n, KeyType k)
{
	int i;
	for (i = 0; i < n; i++)
	{
		if(A[i].key == k)
			break;
	}
	if(i < n)
		return i;
	return -1;
}

//顺序查找改进
/*
可在表的尾端设置一个“岗哨”，即在查找之前把给定值K赋给
数组A中第n个位置的关键字域，这样每循环一次只需要进行元素比较，不需要比较下标是否越界，
当比较到第n个位置时，由于A[n].key==K成立，将自然退出循环
*/

int Seqsch1(ElemType A[], int n, KeyType k)
{
	A[n].key = k;  //设置岗哨
	int i = 0;
	for (;;i++)
	{
		if(A[i].key = k)
			break;
	}
	if(i < n)
		return i;
	return -1;
}

#endif

//二分查找（折半查找）
#ifndef BINSCH

/*
作为二分查找对象的表必须是顺序存储的有序表，
通常假定有序表是按关键字从小到大有序
*/

//二分递归查找
int Binsch(ElemType A[],int low,int high,KeyType k)
	//在A[low]~A[high]区间内二分递归查找关键字为K的元素，
	//low和high的初值应分别为0和n-1

{
	if(low < high)
	{
		int mid = (low + high) / 2;  //求出待查区间内中点元素的下标
		if(k == A[mid].key)
			return mid;   //查找成功返回元素的下标
		else if(k < A[mid].key)
			return Binsch(A,low,mid-1,k);  //在左子表上继续查找
		else
			return Binsch(A,mid+1,high,k);   //在右子表上继续查找
	}
	else
		return -1;
}

//二分非递归查找
int Binsch1(ElemType A[],int n,KeyType k)
	//在A[0]~A[n-1]区间内二分查找关键字为K的元素
{
	int low = 0, high = n-1;
	while (low <= high)
	{
		int mid = (low+high)/2;
		if(k == A[mid].key)
			return mid;
		else if(k < A[mid].key)
			high = mid - 1;
		else
			low = mid + 1;
	}
	return -1;
}

#endif

/*索引查找（分级查找）*/
#ifndef INDSCH

/*
主表←一级索引←二级索引。。。
*/

typedef int IndexKeyType;

const int ILMaxSize = 50;

//索引项的类型和顺序存储的索引表的类型
struct IndexItem
{
	IndexKeyType index;
	int start;  //子表中第一个元素所在的下标位置
	int length;  //子表的长度域
};

typedef IndexItem indexlist[ILMaxSize];

//若所有子表(合称为主表)被顺序存储或静态链接存储在同一个数组中
//则该数组的类型可定义为:
typedef ElemType mainlist[MaxSize];

int Indsch(mainlist A, indexlist B,int m,IndexKeyType k1,IndexKeyType k2)
{
	int i,j;
	for(i = 0; i < m; i++)
	{
		if(k1 == B[i].index)
			break;
	}
	if(i == m)
		return -1;
	j = B[i].start;
	//主表A采用顺序存储
	while(j < B[i].start + B[i].length)
	{
		if(k2 == A[i].key)
			break;
		else
			j++;
	}
	if(j < B[i].start + B[i].length)
		return j;
	else
		return -1;
}

#endif

/*分块查找*/
#ifndef BLOKSCH
/*
对主表和索引表的要求:
一、索引表是按索引值递增(或递减)有序的，即索引表是一个有序表,主表中块与块之间是递增有序的
二、主表中的关键字域和索引表中的索引值域具有相同的数据类型，即为关键字所属的类型。
*/
int Blocksch(mainlist A, indexlist B, int m, KeyType k)
{
	int i,j;
	for(i = 0; i < m; i++)
	{
		if(k <= B[i].index)
			break;
	}
	if(i == m)
		return -1;
	j = B[i].start;
	while(j < B[i].start + B[i].length)
	{
		if(k == A[j].key)
			break;
		else
			j++;
	}
	if(j < B[i].start + B[i].length)
		return j;
	else
		return -1;
}

#endif