《数据结构》实验报告三：几种查找算法的实现和比较

第三次实验报告：几种查找算法的实现和比较

//2019-12-4

//1.随机生成5万个整数，存入一个文件；

//2.算法实现：（1）顺序查找：读入文件中的数据，查找一个key，统计时间；

// （2）二分查找：读入文件，排序，二分查找key，统计时间；

// （3）分块查找：读入文件，分100块，每块300+数字，查找key，统计时间

// （4）二分查找树：读入文件，形成BST，查找key，统计时间

//二叉排序树：建立，查找

#include "stdio.h"

#include "time.h"

#include "stdlib.h"

struct JD

{//定义分块查找的链表结点结构

int data;

JD *next;

};

struct INDEX_T

{//定义分块查找中，索引表结构

int max;//这一块中最大的数字，

JD *block;//每一块都是一个单向链表，这是指向块的头指针};

INDEX_T myBlock[100];//这是索引表的100项

struct NODE

{//定义的二分查找树结点结构

int data;

NODE *left;

NODE *right;

};

const int COUNT=50000;//结点个数

int key=666;//待查找的关键字

int m=1;//

int *array2;

void createData(char strFileName[])

{//产生随机整数，存入文件

srand((unsigned int)time(0));

FILE *fp=fopen(strFileName,"w");

for(int i=1;i<=COUNT;i++)

fprintf(fp,"%d,",rand());

fclose(fp);

}

void createBST(NODE* &bst)

{//产生5万个随机整数，创建二叉排序树

FILE *fp=fopen("data.txt","r");

for(int i=1;i<=COUNT;i++)

{

int num;

fscanf(fp,"%d,",&num);//从文件中读取一个随机整数

//若bst是空子树，第一个结点就是根结点

//若bst不是空子树，从根结点开始左小右大，查找这个数字，找到了直接返回，

//找不到，就插入到正确位置

//创建一个结点

NODE* p=new NODE;

p->data=num;

p->left=0;

p->right=0;

if(0==bst)//空子树

{

bst=p;

continue;

}

//非空子树,//在bst中，查找给结点，

NODE *q=bst;//总是从根结点开始查找

while(1)

{

if(p->data == q->data)//找到了，直接退出break;

if(p->data < q->data && q->left==0)

{//小，往左找，且左边为空，直接挂在q之左q->left=p;

break;

}

if(p->data < q->data && q->left!=0)

{//小，往左找，且左边非空，继续往左边找q=q->left;

continue;

}

if(p->data > q->data && q->right==0)

{//大，往右找，且右边为空，直接挂在q之右q->right=p;

break;

}

if(p->data > q->data && q->right!=0)

{//大，往右找，且右边非空，继续往右边找q=q->right;

continue;

}

}

}

}

int BST_Search(NODE *bst,int key)

{//在bst中找key，

if(0==bst)

return -1;

//非空子树,//在bst中，查找给结点，

NODE *q=bst;//总是从根结点开始查找

while(1)

{

if(key == q->data)//找到了，直接退出

return 1;

if(key < q->data && q->left==0)//小，往左找，且左边为空，找不到

return -1;

if(key < q->data && q->left!=0)//小，往左找，且左边非空，继续往左边找

{

q=q->left;

continue;

}

if(key > q->data && q->right==0)//大，往右找，且右边为空，找不到

return -1;

if(key > q->data && q->right!=0)

{//大，往右找，且右边非空，继续往右边找

q=q->right;

continue;

}

}

}

void inOrder(NODE *bst)

{

if(bst!=0)

{

inOrder(bst->left);

array2[m]=bst->data;//反写回array数组，使数组有序

// printf("%7d",array2[m]);

m++;

inOrder(bst->right);

}

}

int getBSTHeight(NODE *bst)

{

if(bst==0)

return 0;

else

{

int hl=getBSTHeight(bst->left);

int hr=getBSTHeight(bst->right);

int h=hl>hr?hl:hr;

return h+1;

}

}

void makeArray(int array[],char strFileName[]) {//生成5万个随机整数

FILE *fp=fopen(strFileName,"r");

int i=1;

while(!feof(fp))

{

fscanf(fp,"%d,",&array[i]);

// printf("%6d",array[i]);

i++;

}

}

int Seq_Search(int array[],int key)

{//在无序顺序数组中，找data是否存在，-1=不存在，存在返回位置下标

//监视哨：把要找的那个数放到首部

array[0]=key;//

for(int i=COUNT;array[i]!=key;i--);

if(i>0)//找到了，返回下标

return i;

return -1;//查找不成功，返回-1

}

int Bin_Search(int array[],int key)

{//在有序存储的数组中查找key，找到返回位置，找不到返回-1 int low=1,high=COUNT,mid;

while(1)

{

if(low>high)//找不到

return -1;

mid=(low+high)/2;

if(key == array[mid])

return mid;

else if(key

high=mid-1;

else

low=mid+1;

}

}

void makeBlock(INDEX_T myBlock[],char strFileName[]) {//从文件中读取整数，分配到块中去

//1.初始化块索引表，分100块，400,800,1200，

for(int i=0;i<=99;i++)

{

myBlock[i].max=400+400*i;//400,800,1200, (40000)

myBlock[i].block=0;

}

//2.打开文件，读取整数，把每一个整数分配到相应的块中去FILE *fp=fopen(strFileName,"r");

while(!feof(fp))

{

int num=0;

fscanf(fp,"%d,",&num);

//把num分配到num/400块中，挂到该块链表第一个

int blockID=num/400;//求出应该挂在的块号

//生成一个新节点，把num放进去，挂上

JD *p=new JD;

p->data=num;

p->next=myBlock[blockID].block;

myBlock[blockID].block=p;

}

fclose(fp);

}

int Block_Search(INDEX_T myBlock[],int key)

{

int blockID=key/400;//找到块号

JD* p=myBlock[blockID].block;

while(p!=0)

{

if(p->data==key)

return blockID;//能找到

p=p->next;

}

return -1;//找不到

}

void main()

{

clock_t begin,end;

int pos=-1;

//1.生成文件，存入5万个随机整数

createData("data.txt");

//2.顺序查找

int *array=new int[COUNT+1];

makeArray(array,"data.txt");//从文件中读取数据begin=clock();

for(int k=1;k<=10000;k++)

pos=Seq_Search(array,key);

end=clock();

printf("顺序查找：%d所在的位置=%d.时间=%d毫秒\n",key,pos,end-begin);

//3.二分查找树

NODE *bst=0;

createBST(bst);//产生5万个随机数字，建立一个二叉排序树

begin=clock();

for(k=1;k<=10000;k++)

pos=BST_Search(bst,key);//在bst中找key，找到返回1，找不到返回-1

end=clock();

printf("二叉排序树查找：%d所在的位置=%d.时间=%d毫秒\n",key,pos,end-begin);

array2=new int[COUNT+1];

inOrder(bst);//中序输出bst

// int height=getBSTHeight(bst);//求出bst的高度

// printf("BST高度=%d.\n\n",height);

//4.二分查找，利用前面二叉排序树产生的array2，查找key begin=clock();

for(k=1;k<=10000;k++)

pos=Bin_Search(array2,key);

end=clock();

printf("二分查找：%d所在的位置=%d.时间=%d毫秒\n",key,pos,end-begin);

//5.分块查找，关键字范围[0,32767],分配到100块中去，每一块中存400个数字

makeBlock(myBlock,"data.txt");//从文件中读取数据，产生块

begin=clock();

for(k=1;k<=10000;k++)

pos=Block_Search(myBlock,key);//在block中查找key，找到返回块号，找不到返回-1

end=clock();

printf("分块查找：%d所在的块=%d.时间=%d毫秒

\n",key,pos,end-begin);

/*

for(k=0;k<=99;k++)

{

printf("\n\n\n第%d块<%d:\n",k,myBlock[k].max);

JD *q=myBlock[k].block;//让q指向第k块的第一个结点

while(q!=0)

{//输出第k块中所有数字

printf("%7d ",q->data);

q=q->next;

}

}

*/

}