查找算法效率比较

{
public:
T data;
Link<T>* next;
Link<T>():next(0){}
Link<T>(T item):data(item),next(0){}
~Link<T>(){if(next) delete next;}
};
template<class T>
class LinkList
顺序查找
5767
二叉树查找
8
哈希查找
1
100000个随机数据
查找算法
关键字比较次数
实际运行时间
内存空间
顺序查找
16493
二叉树查找
19
哈希查找
13
1000000个随机数据
查找算法
关键字比较次数
实际运行时间
内存空间
顺序查找
78554
二叉树查找
20
哈希查找
3
程序的使用说明：1.运行程序时候首先选择数据总量和数据形式
assert(outstream.is_open() );
int j;
for( j=0;j<5;j++)
{
int n=rand()%1000000;
out<<n<<" "<<m<<endl;
int *a=new int[n];
for(int i=0;i<n;i++)
a[i]=rand()%1000000000;
else
return p->right=new (BintreeNode<T>)(key);
}
return NULL;
}//else
}//Find_bt
Bintree():root(0),num(0){}
~Bintree(){delete root;}
};
template<class T>
class Link
对程序进行分析评价运行效果总结遇到的问题及解决办法对于关键字比较次数由于数据是随机生成的待查找关键字也是随机生成的所以每次运行结果一般不一样但总体情况下顺序查找比较次数最多二叉树查找其次哈希查找比较次数最少而且数据量越大比较次数体现的越明显对于内存空间占用顺序查找占用最少只需分配一数组二叉树查找则要建立二叉树占用空间明显增大哈希表采用拉链法内存空间占用介于数组和二叉树之间程序运行时间大致与比较次数正相关所以一般情况下顺序查找时间最长二叉树查找其次哈希查找最快但考虑到二叉树查找需要建立二叉树哈希查找需要建立哈希表这些都要花费一定时间但总体来说哈希查找还是最快的数据量越大顺序查找越慢注
{
icmp=0;
if(root==0)
{
icmp++;
if(itype==0)
return NULL;
else
{
num++;
return root=new BintreeNode<T>(key);
}
}
else
{
BintreeNode<T>* ptr=root,*p;
while(ptr!=NULL)
{
注：各部分内容要求填写详尽，如空间不够可自行扩充。
template<class T>
class BintreeNode
{
public:
T data;
BintreeNode* left;
BintreeNode*right;
BintreeNode():left(0),right(NULL){}
BintreeNode(T item):data(item),left(NULL),right(NULL){}
{
hashlist=new LinkList<T>[n];
}
~Hash<T>(){delete []hashlist;}
void init_hash(T data[],int n)//初始化哈希查找表-----拉链法冲突调节
{
int t;
for(int i=0;i<n;i++)
{
int pos=data[i]%size;
icmp++;
p=ptr;
if(ptr->data==key)
return ptr;
else
{
if(ptr->data>key)
ptr=ptr->left;
else
ptr=ptr->right;
}
}
if(itype)
{
num++;
if(p->data>key)
return p->left=new BintreeNode<T>(key);
second=clock();
cout<<"二叉查找树查找时间"<<second-first<<endl;
first=clock();
Hash<int > hash(1000);
hash.init_hash(a,n);
cout<<"哈希表查找："<<endl;
cout<<"data:"<<((hash.Find_hash(key,icmp)==NULL)?-1:(hash.Find_hash(key,icmp))->data);
int main()
{
const int m=100;
clock_t first,second;
srand(time(0));
ofstream out,outstream;
out.open("datain.txt");
outstream.open("dataout.txt");
assert(out.is_open() );
{
icmp=0;
if(first==0)
{
icmp++;
if(ntype)
return first=new Link<T>(key);
else
return NULL;
}
else
{
Link<T>*ptr=first,*p;
while(ptr!=NULL)
{
icmp++;
p=ptr;
if(ptr->data==key)
数据结构选择（包括改进或给出）、算法设计：顺序查找采用数组，二叉树查找采用类，哈希查找采用元素为链表的数组；对于顺序查找采用for循环从前到后比较；对于二叉查找树查找，从根节点开始比较，若相等，返回比较结果，若小如根节点对应的数值，则与根节点的左儿子对应的数值进行比较，若大如根节点对应的数值，则与根节点右儿子对应数值进行比较，一直进行下去，返回比较结果；对于哈希查找，先确定关键字在哪条链表，然后遍历链表查找
hashlist[pos].Find_hash(data[i],t,1);
}
}
Link<T>* Find_hash(T key,int &icmp)//查找关键词采用除法杂凑函数
{
int pos=key%size;
return hashlist[pos].Find_hash(key,icmp);
}
};
1.数据全都是随机生成的，每次运行的结果不一样。
2.最后比较三种查找的性能结果直接输出到屏幕上。
总结：
（对程序进行分析、评价运行效果，总结遇到的问题及解决办法）
对于关键字比较次数，由于数据是随机生成的，待查找关键字也是随机生成的，所以每次运行结果一般不一样，但总体情况下，顺序查找比较次数最多，二叉树查找其次，哈希查找比较次数最少，而且，数据量越大，比较次数体现的越明显，对于内存空间占用，顺序查找占用最少，只需分配一数组，二叉树查找则要建立二叉树，占用空间明显增大，哈希表采用拉链法，内存空间占用介于数组和二叉树之间，程序运行时间大致与比较次数正相关，所以一般情况下顺序查找时间最长，二叉树查找其次，哈希查找最快，但考虑到二叉树查找需要建立二叉树，哈希查找需要建立哈希表，这些都要花费一定时间，但总体来说哈希查找还是最快的，数据量越大，顺序查找越慢
return ptr;
ptr=ptr->next;
}
if(ntype)
return p->next=new Link<T>(key);
return NULL;
}
}
};
template<class T>
class Hash
{
public:
LinkList<T>* hashlist;
int size;
Hash<T>(int n=113):size(n)
else outstream<<"YES"<<endl;
if(hash.Find_hash(key,icmp)==NULL)outstream<<"NO"<<endl;
else outstream<<"YES"<<endl;
}
}
out.close();
outstream.close();
return 0;
int Find_s(T data[], int n,T key,int &icmp)
//顺序查找(从n维数组中查找key,并且给出比较的次数icmp
{
icmp=0;
for(int i=0;i<n;i++)
{
icmp++;
if(data[i]==key)
return i;
}
return -1;
}
///以下是二叉查找树查找法
编程与程序清单：#include<iostream>
#include<time.h>
#include<fstream>
#include<string>
#include<cassert>
#include<stdlib.h>
#include<algorithm>
using namespace std;
template<class T>
btree.Find_bt(a[i],icmp,1);//未排序之前插入到二叉查找树中
cout<<"二叉查找树："<<endl;
cout<<"data:"<<(btree.Find_bt(key,icmp)==NULL?-1:btree.Find_bt(key,icmp)->data );
cout<<"\ticmp:"<<icmp<<endl;//"\tnum:"<<btree.num<<endl;
任务分工及进度安排：第一天做的工作：第一步解决数据生成，采用随机数很容易实现；第二步对数据进行预处理，如进行完全正序排序，逆序排序，将处理后的数据存入data.in中；第二天做的工作：第三步编写顺序查找函数，二叉树查找函数，哈希查找函数，最后读关键字查询，将查询结果输出到data.out文件中；第三天完善程序，写报告
{
int key=rand()%1000000000;
out<<key<<endl;
int icmp;
first=clock();
int j=Find_s(a,n,key,icmp);//使用顺序查找法查找key值的位置
cout<<"数据总数:"<<n<<"\t查找关健字key:"<<key<<
"\t查找比较次数:icmp\n顺序查找法：\npos:"
~BintreeNode(){
if(left!=0)
delete left;
if(right!=0)
delete right;
}
};
template<class T>
class Bintree
{
public:
int num;
BintreeNode<T>* root;
BintreeNode<T>* Find_bt(T key,int &icmp,int itype=0)//一个二叉树查找算法，itype=1时有插入功能（不同的值时）
cout<<"\ticmp:"<<icmp<<endl;
second=clock();
cout<<"哈希表查找时间"<<second-first<<endl;
if(j==-1)outstream<<"NO"<<endl;
else outstream<<"YES"<<endl;
if(btree.Find_bt(key,icmp)==NULL)outstream<<"NO"<<endl;
//对数组处理
stringБайду номын сангаасch;
cin>>ch;
if(ch=="sort")sort(a,a+n);
if(ch=="reverse")
{
sort(a,a+n);
reverse(a,a+n);
}
for(int i=0;i<n;i++)
out<<a[i]<<endl;
for(int i=0;i<m;i++)
<<j<<"\tdata:"<<a[j]<<" icmp:"<<icmp<<endl;
second = clock();
double duration;
cout<<"顺序查找时间"<<second-first<<endl;
first=clock();
Bintree<int> btree;
for(int i=0;i<n;i++)
《数据结构》课程设计报告
姓名杨方
学号53111512
实验室A209
座位号
组号
提交日期8.15
成绩
指导教师卢欣华
问题解析（对问题的分析、解题思路与解题方法）：问题告诉算法分两步，第一步从文件读数据建立查找表，那么首先要生成数据并建立文件，第二步读数据查找，对于顺序查找，不需要预处理直接进行查找，对于二叉查找树查找则必须先建立二叉树，对于哈希算法则必须先建立哈希表，做完预处理后再进行查找，统计比较次数，实际运行时间，占用内存空间等因素判断算法性能