经典查找算法

顺序查找

顺序查找又称线性查找，从线性表的一端开始，顺序扫描线性表，依次将扫描到的结点关键字和给定值k相比较。如果当前扫描到的结点关键字与k相等，则查找成功；若扫描结束后，仍然未找到关键字等于k的结点，则查找失败。复杂度为O(n)

int seqSearch(int a[],int n,int k)
{
	for (int i = 1; i <= n; i++)
	{
		if (a[i] == k)
			return i;
	}
	return 0;
}

二分查找

要求：有序数组
思想：将n个元素分成大致相同的两半，取中值和值x比较，如果相等则找到，如果值x小于中值，则只在数组的左半部分继续搜索值x；如果值x大于中值，则只在数组右半部分继续搜索值x，这样递归下去，直到找到满足条件的结点或者该线性表中没有这样的结点为止
复杂度：最坏情况下需要O(logn)时间

//方法一
int BinSeek1(int a[],int n,int k)
{
	int mid;
	int min =1, max = n;
	while (min <= max)
	{
		mid = (min + max) / 2;
		if (k < a[mid]) max = mid - 1;
		else if (k > a[mid]) min = mid + 1;
		else return mid;
	}
	return 0;
}
//方法二
int BinSeek2(int a[],int min, int max, int k)
{
	if (min > max)return 0;
	else {
		int mid = (min + max) / 2;
		if (k < a[mid]) return BinSeek2(a,min, mid - 1, k);
		else if (k > a[mid])return BinSeek2(a, mid+1,max, k);
		else return mid;
	}
}

分块查找

分块查找又称索引顺序查找，其性能介于顺序查找和二分查找之间。分块查找是吧线性表分成若干快，每一块中的元素存储顺序是任意的，但快与快之间必须按关键字大小有序排列，即前一块中的最大关键字值小于后一块的最小关键字值。此外，还需要建立一个索引表，索引表中的一项对应线性表中的一块，索引项由键域和链域组成，键域存放响应块的最大关键字，链域存放指向本块第一个结点的指针。索引表按关键字值递增顺序排列。时间复杂度为O(根号n)

二叉排序树

二叉排序树又称二叉查找树，具有以下性质：
1）若它的左子树非空，则左子树上所有结点的值均小于根节点的值
2）若它的右子树非空，则右子树上所有结点的值均大于根节点的值
3）左，右子树本身又各是一棵二叉排序树
注：按中序遍历该二叉树所得到的中序遍历序列是一个递增有序的序列

#include
using namespace std;
template<class T>
class BSTNode {
public:
	BSTNode() { lchild = rchild = 0; }
	BSTNode(T e) { data = e; lchild = rchild = 0; }
	void Visit() { cout << key << "  "; }
	void InsertBST(BSTNode *&, BSTNode *);//数据元素的插入
	BSTNode<T>* CreateBST();//二叉排序树的生成
	BSTNode<T> * SearchBST(BSTNode*,int x);//查找
	void InOrder(BSTNode*);//中序遍历
private:
	int key;
	T data;
	BSTNode<T> * lchild, *rchild;
};
template<typename T>
void BSTNode<T>::InsertBST(BSTNode *&t, BSTNode *s)
{
	BSTNode *f=NULL, *p = t;
	while (p)
	{
		f = p;
		if (s->key < p->key)p = p->lchild;
		else p = p->rchild;
	}
	if (t == NULL)t = s;
	else if (s->key < f->key)f->lchild = s;
	else f->rchild = s;
	//cout << "成功插入" << endl;
}
BSTNode<char>*root=NULL;
template<typename T>
BSTNode<T>* BSTNode<T>::CreateBST()
{
	int key;
	BSTNode*p;
	cout << "请输入值，直到输入值为0时结束：" << endl;
	cin >> key;
	while (key)
	{
		p = new BSTNode;
		p->key = key;
		p->lchild = p->rchild = NULL;
		InsertBST(root, p);
		cin >> key;
	}
	return root;
}
template<typename T>
BSTNode<T>* BSTNode<T>::SearchBST(BSTNode * t,int x)
{
	if (t == NULL || t->key == x)
		return t;
	if (x < t->key)
		return SearchBST(t->lchild, x);
	else
		return SearchBST(t->rchild, x);
}
template<typename T>
void BSTNode<T>::InOrder(BSTNode* bt)
{
	if (bt)
	{
		bt->InOrder(bt->lchild);
		bt->Visit();
		bt->InOrder(bt->rchild);
	}
}
void main()
{
	BSTNode<char>*s = NULL,*t;
	s = s->CreateBST();
	s->InOrder(s);
	for (int i = 20; i < 40; i = i + 5)
	{
		t = s->SearchBST(s, i);
		if (t == NULL)
			cout << "\n不存在关键字" << i;
		else
		{
			cout << "\n找到关键字";
			t->Visit();
		}
	}
	cout << endl;
	system("pause");
}

运行程序并输入值得到结果：