查找算法的应用

一、实验项目要求

1. 学习静态查找常用算法；
2. 学习动态查找常用算法；
3. 学习哈希查找算法。

二、理论分析或算法分析

1.静态查找

（1）定义student数据类型：包括sno、sname、score三个数据项，其中关键字为sno;

（2）定义顺序查找表数据类型sstable;

（3）定义函数input,创建学生信息查找表，输入学生信息；

（4）定义函数search,实现按学号sno经典顺序查找的算法，找到返回位置并输出该学生信息，没找到返回0；

（5）定义函数search2，实现按学号sno加哨兵顺序查找的算法，找到返回位置并输出该学生信息，没有找到返回0；

（6）定义函数sort,按学号对学生信息查找表排序；

（7）定义函数search3,实现按学号sno二分查找查找的算法，找到返回位置并输出该学生信息，没找到返回0；

（8）在main函数中调用调试。

2.动态查找

（1）定义二叉查找数数据类型bitree,包括data、lchild、rchild三个数据项，其中data为student类型；

（2）定义函数search4，按学号sno对学生信息二叉查找树查找，找到返回指针并输出该学生信息，没有返回NULL；

（3）定义函数insert，在学生信息二叉查找树中插入学生信息；

（4）定义函数create，创建学生信息二叉查找树，并输入学生信息；

（5）在main函数中调用调试。

三、实现方法

// 查找.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include<iostream>
#include<string>
#define MAXSIZE 20
using namespace std;
typedef string keytype;
typedef struct student 
{
	keytype key_sno;
	string name;
	float score;
}student;
typedef struct
{
	student elem[MAXSIZE];      //线性表占用的数组空间
	int last;      //最后一个元素的下标
}sstable;
void inputstudent(sstable *L,int i)     //输入学生的信息
{
	int x;
	cout<<"请输入学生的人数："<<endl;
	cin>>x;
	sum=x;
	for(int i=1;i<=x;i++)
	{
		cout<<"学号：姓名：成绩："<<endl;
		cin>>L->elem[i].key_sno;
		cin>>L->elem[i].name;
		cin>>L->elem[i].score;
	}
	L->last=x;
}
//逐个显示学生表中所有的相关信息
int show(sstable *L,int i)
{
	cout<<"所有的学生的相关信息为："<<endl;
	for(i=1;i<L->last;i++)
	{
		cout<<"学号： 姓名：   成绩："<<endl;
		cout<<L->elem[i].key_sno<<L->elem[i].name<<L->elem[i].score<<endl;
	}
	return 0;
}
//加哨兵的顺序查找
int search(sstable *L,string e)
{
	int k=MAXSIZE;
	while(L->elem[k].key_sno!=e)
		k--;
	return k;
}
//根据学号进行折半查找，成功返回该生学号和姓名
void search3(sstable *L)
{
	string key;
	cout<<"输入要查找的学生的学号："<<endl;
	cin>>key;
	int low=1,high=L->last;
	while(low<=high)
	{
		int mid=(low+high)/2;
		if(L->elem[mid].key_sno==key)
		{
			cout<<"学号：  姓名：   成绩："<<L->elem[mid].key_sno<<L->elem[mid].name<<L->elem[mid].score<<endl;
			return ;
		}
		else if(L->elem[mid].key_sno<key)
			low=mid+1;
		else if(L->elem[mid].key_sno>key)
			high=mid-1;
	}
	cout<<"错误！！没有此学生信息！"<<endl;
}
//快速排序
int sort(sstable *L,int low,int high)
{
	L->elem[0]=L->elem[low];
	string privokey=L->elem[low].key_sno;
	while(low<high)
	{
		while(low<high&&L->elem[high].key_sno>=privokey)
			--high;
		L->elem[low]=L->elem[high];
		while(low<high&&L->elem[low].key_sno<=privokey)
			++low;
		L->elem[high]=L->elem[low];
	}
	L->elem[low]=L->elem[0];
	return low;
}
//非递归查找算法
BSTNode *BST_Search(BiTree T,ElemType key,BSTNode *&p)
{
    //查找函数返回指向关键字值为key的结点指针，不存在则返回NULL
    p=NULL;
    while(T!=NULL&&key!=T->data)
    {
        p=T;                          //指向被查找结点的双亲
        if(key<T->data)
            T=T->lchild;              //查找左子树
        else
            T=T->rchild;              //查找右子树
    }
    return T;
}

//递归算法
Status Search_BST(BiTree T, int key, BiTree f, BiTree *p)
{
    //查找BST中是否存在key，f指向T双亲，其初始值为NULL
    //若查找成功，指针p指向数据元素结点，返回true；
    //若失败，p指向查找路径上访问的最后一个结点并返回false
    if(!T)
    {
        *p=f;
        return false;
    }
    else if(key==T->data)
    {                      //查找成功
        *p=T;
        return true;
    }
    else if(key<T->data)
        return Search_BST(T->lchild,key,T,p);   //递归查找左子树
    else
        return Search_BST(T->rchild,key,T,p);   //递归查找右子树
}
int _tmain(int argc, _TCHAR* argv[])
{
	sstable *L;
	int i,low,high;
	string e;
	cout<<"==============1.输入学生信息=============="<<endl;
	cout<<"==============2.显示学生信息=============="<<endl;
	cout<<"==============3.使用哨兵查找学生信息======"<<endl;
	cout<<"==============4.使用折半查找学生信息======"<<endl;
	cout<<"==============5.快速排序=================="<<endl;
	cout<<"==============5.非递归查找================"<<endl;
	cout<<"==============6.递归======================"<<endl;
	cout<<"==============7.退出======================"<<endl;
	int choice;
	cin>>choice;
	switch(choice)
	{
	case 1:
		inputstudent(L,i);
		break;
	case 2:
		show(L,i);
		break;
	case 3:
		search(L,e);
	case 4:
		search3(L);
	case 5:
		sort(L,low,high);
	/*case 6:
		BST_Search(T,key,*&p);
	case 7:
		Search_BST(T,key,f,*p);*/
	case 8:
		exit(0);
	}
	return 0;
}

四、实验结果分析

代码结果

实验收获

1.要经过多次调试之后才可以得到正确的结论；

2.要多实践；

完成实验的参考

同学的帮助，数据结构书，C++书；