有序表查找实验报告

有序表查找实验报告

篇一：《数据结构》实验报告查找

实验四——查找

一、实验目的

1. 掌握顺序表的查找方法，尤其是折半查找方法；

2. 掌握二叉排序树的查找算法。

二、实验内容

1.

2.

3.

4. 建立一个顺序表，用顺序查找的方法对其实施查找；建立一个有序表，用折半查找的方法对其实施查找；建立一个二叉排序树，根据给定值对其实施查找；对同一组数据，试用三种方法查找某一相同数据，并尝试进行性能分析。

三、实验预习内容

实验一包括的函数有：typedef struct ，创建函数void create(seqlist & L)，输出函数void print(seqlist L)，顺序查找int find(seqlist L,int number)，折半查找int halffind(seqlist L,int number) 主函数main().

实验二包括的函数有：结构体typedef struct，插入函数void insert(bnode * & T,bnode * S)，void insert1(bnode * & T)，创建函数void create(bnode * & T)，

查找函数bnode * search(bnode * T,int number)，主函数main().

四、上机实验

实验一：

1. 实验源程序。

#include

#define N 80

typedef struct

{

int number; //关键字

char name[5];

char sex[2];

int age;

}record;

typedef struct

{

record stu[N];

int num;//记录人数

}seqlist;

//建顺序表

void create(seqlist & L)

{

int i;

L.num=0;

cout cout cin>>L.stu[1].number;

for(i=1;L.stu[i].number!=0;)

{

cin>>L.stu[i].name>>L.stu[i].sex>>L.stu[i].age; L.num++;

cout cin>>L.stu[++i].number;

}

}

//输出学生信息

void print(seqlist L)

{

int i;

cout for(i=1;i cout }

//顺序查找

int find(seqlist L,int number)

{

int i;

for(i=L.num;i>=0;i--)

if(L.stu[i].number==number)

return i;

}

//折半查找

int halffind(seqlist L,int number) {

int high=L.num,low=1,mid;

for(;low {

mid=(high+low)/2;

if(number==L.stu[mid].number) return mid;

else

if(number high=mid-1;

else

low=mid+1;

}

return 0;

}

void main()

{

int i,number;

seqlist L;

create(L);

print(L);

cout cout cin>>number;

if((i=halffind(L,number))!=0)

cout else

cout cout cout cin>>number; if((i=find(L,number))!=0)

cout else

cout }

实验二：

#include

typedef struct

{

int number; //关键字

char name[5];

char sex[2];

int age;

}record;

typedef struct node

{

record inf;

struct node *lchild,*rchild;

}bnode;

void insert(bnode * & T,bnode * S)

{

if(!T)

T=S;

else

if(S->inf.numberinf.number)

insert(T->lchild,S);

else

insert(T->rchild,S);

}

void insert1(bnode * & T)

{

int flag=1; int number; bnode * u; char ctinue; for(;flag==1;)

{

cout cout cin>>number;

while(number)

{

u=new bnode;

u->inf.number=number;

cin>>u->https://www.360docs.net/doc/e711600640.html,>>u->inf.sex>>u->inf.age;

u->lchild=u->rchild=NULL;

insert(T,u);

}

cout cin>>ctinue;

if(ctinue=='y'||ctinue=='y')

flag=1;

else

flag=0;

}

}

void create(bnode * & T)

{

bnode * u;

int number;

T=NULL;

cout cout cin>>number;

while(number)

{

u=new bnode;

u->inf.number=number;

cin>>u->https://www.360docs.net/doc/e711600640.html,>>u->inf.sex>>u->inf.age; u->lchild=u->rchild=NULL;

insert(T,u);

}

}

bnode * search(bnode * T,int number) {

if(T==NULL||T->inf.number==number) return T;

else

if(T->inf.number>number)

return search(T->lchild,number);

else

return search(T->rchild,number);

}

void main()

{

int number,flag=1,choice; char ctinue; bnode * T,*p;

for(;flag==1;)

{

cout cin>>choice;

switch(choice)

{

case 1:{create(T);cout case 2:{insert1(T);cout case 3:{cout有序表查找实验报告)学生的学号:";cin>>number;p=search(T,number);

if(p)

篇二：有序表二分查找法和二叉排序树的查找

重庆交通大学

综合性设计性实验报告

班级：

实验项目名称：

实验项目性质：

实验所属课程：

实验室(中心)：

指导教师：

实验完成时间：年月日

一、实验目的

应用线性结构、树形结构实现查找。

二、实验内容及要求

实验内容：

1）有序表的二分查找

2）二叉排序树的查找

实验要求

1）建立有序表，然后进行二分查找

2）建立二叉排序树，然后查找

三、实验设备及软件

Win7操作系统

Microsoft Visual Studio XX

四、设计方案

㈠题目（老师给定或学生自定）

有序表的二分查找和二叉排序树的查找

㈡设计的主要思路

有序表的二分查找：

定义模板类：COderTable，其中的bool Find(T &element,int &i)函数采用二分查找法实现对数据的查找。

㈢主要功能

1)、建立有序表，然后进行二分查找

2)、建立二叉排序树，然后查找

五、主要代码

有序表的二分查找：

声明并定义COderTable类:

#define CODERTABLE

template

class COderTable

{

private:

T Element[100];

int Maxnumber;

public:

COderTable();//构造函数

~COderTable();//析构函数

bool Initial();//初始化数组

bool Find(T &element,int &i);//查找元素element，如果查找成功，则返回查找点的位置i,反之，i=-1 };

实现查找的函数：

template

bool COderTable::Find(T &element,int &i) {

int low=0,height=99,mid=(height+low)/2; while(low {

if(Element[mid]==element)

{

i=mid+1;

return true;

}

if(Element[mid] low=mid+1;

if(Element[mid]>element)

height=mid-1;

mid=(low+height)/2;

}

return false;

}

二叉排序树的查找：

声明并定义相关类：

#define CELEMENT

篇三：有序表类查找及实现

有序表类及查找实现

（1）实验描述

查找是数据处理领域中的一个重要内容，查找的频率将直接影响到数据处理的效率。顺序查找一般是指在线性表中查找指定的元素，对分查找只适用于顺序储存的有序表，本实验通过对有序表类及查找实现的研究以巩固其相关知识。

（2）实验内容

线性表在链式存储结构下的顺序查找

输入：线性链表头指针HEAD以及存储空间V、NEXT；被查找的元素x。

有序线性表在顺序存储结构下的对分查找

输入：有序线性表长度n以及线性表的存储空间V；被查找的元素x。

（3）实验结果及分析

输出：被查找元素x的结点在线性链表中的存储序号k。如果在线性链表中不存在元素值为x的结点，

则输出k＝－1。

输出：被查找元素x在有序线性表中的序号k。如果在线性表中不存在元素x，则输出k＝－1。

（4）实验结论

两种情况下只能采用顺序查找：

(1)如果线性表为无序表（即表中元素的排列是无序的），则不是顺序存储结构还是链式存储结构，都只能用顺序查找。

(2)即使是有序线性表，如果采用链式存储结构，也只能用顺序查找。

顺序查找的效率

顺序查找的优点是对线性表结点的逻辑次序无要求，对线性表的存储结构无要求，缺点是平均检索长度长,为n/2。

程序//代码:

//SL_List.h

# include

//using namespace std;

template//模板声明，数据元素虚拟类型为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

SL_List::SL_List(int m)

{

mm=m;//存储空间容量

v=new T[mm];//动态申请存储空间

nn=0;//有序表长度

return;

}

//顺序有序表查找

template

int SL_List::search_SL_List(T x)

{

int i,j,k;

i=1;j=nn;

while(i {

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

int SL_List::insert_SL_List(T x)

{

int k;

if(nn==mm)//存储空间已满

{cout 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

int SL_List::delete_SL_List(T x)

{

int i,k;

k=search_SL_List(x);//查找删除元素的位置

if(k>=0)//表中有这个元素

{

for(i=k;i v[i]=v[i+1];//被删元素到最后一个元素之间的元素均前移

nn=nn-1;//长度减一

}

else//表中没有这个元素

cout return(k);//返回删除是否成功标志

}

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

template

void SL_List::prt_SL_List()

{

int i;

cout for(i=0;i cout return;

}

//有序表合并（运算符+重载为友元函数）template

SL_Listoperator+(SL_List &s1,SL_List &s2) { int k=0,i=0,j=0;

SL_Lists;

s.v=new T[s1.nn+s2.nn];//动态申请存储空间while((i {

if(s1.v[i] {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)//复制有序表s2中剩余的元素

for(i=j;i {s.v[k]=s2.v[i];k=k+1;}

else//复制有序表s1中剩余的元素

for(j=i;j {s.v[k]=s1.v[j];k=k+1;}

s.mm=s1.mm+s2.mm;

s.nn=s1.nn+s2.nn;

return(s);

}

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_Lists1(20);//建立容量为20长度为5的有序表对象s1 SL_Lists2(30);//建立容量为30长度为5的有序表对象s2 for(k=0;k s1.insert_SL_List(a[k]);

for(k=0;k s2.insert_SL_List(b[k]);

cout s1.prt_SL_List();//输出有序表对象s1

cout s2.prt_SL_List();// 输出有序表对象s1

SL_Lists3;//建立合并后的有序表对象s3

s3=s1+s2;//有序表合并

cout s3.prt_SL_List();//输出合并后的有序表对象s3

s3.delete_SL_List(a[0]);//在有序表s3中删除1.5 s3.delete_SL_List(b[0]);//在有序表s3中删除1.0 s3.delete_SL_List(123.0);//在有序表s3中删除123.0

cout s3.prt_SL_List();//输出合并后的有序表对象s3

return 0;

}