实验8查找与排序算法的实现和应用Word格式.docx
《实验8查找与排序算法的实现和应用Word格式.docx》由会员分享，可在线阅读，更多相关《实验8查找与排序算法的实现和应用Word格式.docx（20页珍藏版）》请在冰豆网上搜索。
二分查找又称折半查找，优点是比较次数少，查找速度快，平均性能好；
其缺点是要求待查表为有序表，且插入删除困难。
因此，折半查找方法适用于不经常变动而查找频繁的有序列表。
首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；
否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。
重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。
2.哈希查找：
哈希查找的操作步骤：
⑴用给定的哈希函数构造哈希表；
⑵根据选择的冲突处理方法解决地址冲突；
⑶在哈希表的基础上执行哈希查找。
哈希查找的本质是先将数据映射成它的哈希值。
哈希查找的核心是构造一个哈希函数，它将原来直观、整洁的数据映射为看上去似乎是随机的一些整数。
哈希查找的产生有这样一种背景——有些数据本身是无法排序的（如图像），有些数据是很难比较的（如图像）。
如果数据本身是无法排序的，就不能对它们进行比较查找。
如果数据是很难比较的，即使采用折半查找，要比较的次数也是非常多的。
因此，哈希查找并不查找数据本身，而是先将数据映射为一个整数（它的哈希值），并将哈希值相同的数据存放在同一个位置一即以哈希值为索引构造一个数组。
在哈希查找的过程中，只需先将要查找的数据映射为它的哈希值，然后查找具有这个哈希值的数据，这就大大减少了查找次数。
如果构造哈希函数的参数经过精心设计，内存空间也足以存放哈希表，查找一个数据元素所需的比较次数基本上就接近于一次。
3.排序算法:
排序（Sorting）是计算机程序设计中的一种重要操作，它的功能是将一个数据元素（或记录）的任意序列，重新排列成一个关键字有序的序列。
流程图：
是
否
实验代码：
1、顺序查找
#include<
stdio.h>
#defineMAX100
typedefintkeytype;
typedefstruct
{keytypekey;
}elemtype;
{elemtypeelem[MAX+1];
intlength;
}SStable;
voidcreate_seq（SStable*list）;
intseq_search（SStable*list,keytypek）;
voidmain（）
{SStable*list,table;
keytypekey;
inti;
list=&
table;
printf（"
请输入顺序表的长度：
"
）;
scanf（"
%d"
&
list->
length）;
create_seq（list）;
创建的顺序表内容：
\n"
for（i=0;
i<
length;
i++）
printf（"
list.elem[%d].key=%d\n"
i+1,list->
elem[i].key）;
输入查找关键字：
key）;
seq_search（list,key）;
}
voidcreate_seq（SStable*list）
{inti;
请输入顺序表的内容：
{printf（"
list.elem[%d].key="
i+1）;
}
intseq_search（SStable*list,keytypek）
{inti=0,flag=0;
while（i<
length）
{if（list->
elem[i].key==k）
查找成功.\n"
flag=1;
i+1,k）;
i++;
if（flag==0）
没有找到数据%d!
k）;
return（flag）;
2、折半查找
#include<
{intelem[MAX+1];
intlength;
}Stable;
voidcreat_seq（Stable*list）;
intsort_seq（Stable*list）;
intbin_search（Stable*list,intk,intlow,inthigt）;
voidmain（）
{Stable*list,table;
inti,key;
list=&
printf（"
请输入线性表的长度：
scanf（"
creat_seq（list）;
sort_seq（list）;
排列后的数据\n"
for（i=1;
=list->
i,list->
elem[i]）;
\n请输入查找的值:
bin_search（list,key,1,list->
voidcreat_seq（Stable*list）
请输入顺序表的内容:
{printf（"
i）;
intsort_seq（Stable*list）
{inti,j,flag;
{flag=0;
for（j=1;
j<
length-i+1;
j++）
if（list->
elem[j]>
elem[j+1]）
{list->
elem[0]=list->
elem[j+1];
elem[j+1]=list->
elem[j];
elem[j]=list->
elem[0];
flag=1;
if（flag==0）return1;
intbin_search（Stable*list,intk,intlow,inthigh）
{intmid;
if（low>
high）
{printf（"
没有找到要查找的值\n"
return（0）;
mid=（low+high）/2;
if（list->
elem[mid]==k）
查找成功\n"
list[%d]=%d\n"
mid,k）;
return（mid）;
else
elem[mid]<
k）
return（bin_search（list,k,mid+1,high））;
return（bin_search（list,k,low,mid-1））;
3、二叉树查找
stdlib.h>
typedefstructbitnode
{
intkey;
structbitnode*lchild;
structbitnode*rchild;
}bnode;
voidins_bitree（bnode*p,intk）
bnode*q;
if（p->
key>
k&
&
p->
lchild）
ins_bitree（p->
lchild,k）;
else
if（p->
key<
=k&
rchild）
ins_bitree（p->
rchild,k）;
else
{
q=（bnode*）malloc（sizeof（bnode））;
q->
key=k;
lchild=NULL;
q->
rchild=NULL;
if（p->
key>
p->
lchild=q;
else
p->
rchild=q;
}
voidbit_search（bnode*p,intk）
bit_search（p->
else
if（p->
key==k）
查找成功!
%d不存在!
voidinorder（bnode*p）
if（p）
{
inorder（p->
lchild）;
%4d"
p->
rchild）;
voidmain（）
{intk;
bnode*p;
p=NULL;
请输入二叉树结点的值，输入0结束:
k）;
p=（bnode*）malloc（sizeof（bnode））;
while（k>
0）
ins_bitree（p,k）;
二叉树排序的结果:
inorder（p）;
bit_search（p,k）;
4、哈希表查找
#defineMAX11
voidins_hash（inthash[],intkey）
intk,k1,k2;
k=key%MAX;
if（hash[k]==0）
hash[k]=key;
return;
else
{k1=k+1;
while（k1<
MAX&
hash[k1]!
=0）
k1++;
if（k1<
MAX）
hash[k1]=key;
k2=0;
while（k2<
hash[k2]!
k2++;
if（k2<
hash[k2]=key;
voidout_hash（inthash[]）
MAX;
if（hash[i]）
printf（"
hash[%d]=%d\n"
i,hash[i]）;
voidhash_search（inthash[],intkey）
intk,k1,k2,flag=0;
if（hash[k]==key）
hash[%d]=%d"
k,key）;
flag=1;
k1=k+1;
while（k1<
=key）
k1++;
if（k1<
k1,key）;
k2=0;
if（!
flag）
{while（k2<
k2++;
if（k2<
k2,key）;
if（flag）
查找成功！
return;
}else
查找失败！
{inti,key,k,sum=0;
inthash[MAX];
for（i=0;
hash[i]=0;
请输入数据，以0结束：
sum++;
while（key&
sum<
{ins_hash（hash,key）;
out_hash（hash）;
请输入查找的值：
hash_search（hash,k）;
time.h>
#definesize11
typedefchardatatype;
typedefstruct
{intkey;
datatypeothers;
}rectype;
voidINSERTSORT（rectypeR[]）
{inti,j;
for（i=2;
=size;
{R[0]=R[i];
j=i-1;
while（R[0].key<
R[j].key）
{R[j+1]=R[j];
j--;
R[j+1]=R[0];
voidSHELLSORT（rectypeR[],intn）
{inti,j,h;
rectypetemp;
h=n/2;
while（h>
{for（j=h;
=n-1;
{temp=R[j];
i=j-h;
while（（i>
=0）&
temp.key<
R[i].key）
{R[i+h]=R[i];
i=i-h;
R[i+h]=temp;
h=h/2;
intPARTITION（rectypeR[],intl,inth）
{inti,j;
i=1;
j=h;
temp=R[i];
do
{while（（R[j].key>
=temp.key）&
（i<
j））
if（i<
j）R[i++]=R[j];
while（（R[i].key<
i++;
j）R[j--]=R[i];
while（i!
=j）;
R[i]=temp;
returni;
voidQUICKSORT（rectypeR[],ints1,intt1）
if（s1<
t1）
{i=PARTITION（R,s1,t1）;
QUICKSORT（R,s1,i-1）;
QUICKSORT（R,i+1,t1）;
{rectypeR[size];
请输入使用插入算法排序的10个数据\n"
for（i=1;
size;
i++）scanf（"
R[i].key）;
\n插入排序之前\n"
i++）printf（"
%d\t"
R[i].key）;
INSERTSORT（R）;
\n插入排序之后\n"
\n请输入使用希尔顿算法排序的10个数据\n"
size-1;
\n希尔排序之前\n"
SHELLSORT（R,10）;
\n希尔排序之后\n"
请输入使用快速算法排序的10个数据\n"
\n快速排序之前\n"
QUICKSORT（R,1,10）;
\n快速排序之后\n"
实验结果
顺序查找：
折半查找：
二叉树查找：
哈希表查找：
排序：
实验小结：
此次操作证明可以用编程实现查找与排序，实验结果正确。
通过本次实验，我对查找排序与二分查找、哈希查找、二叉树查找等有了更加深刻的了解。
练习了指针，查找等操作，熟练掌握树的操作。
对各种算法有了更加深刻的理解。
通过这次写实验报告，我深切的理解了这门课的本质。
刚开始学这门课时，当时还不清楚这门课程的目的，现在，我真正的理解了：
数据结构像是身体的骨骼，而C语言是填充这骨骼的肉体，二者相结合才能使整个程序更加完整，健全。
数据结构是个框架，模型，抽象数据类型中列举了各种操作，而所用的C语言，将各种操作描述出来构成算法。
数据结构+算法=程序设计。
在这次设计的过程中，我还遇到了，很多的问题。
顺序表是按顺序存储的，用了一维数组来存储，又结合C语言的程序设计，但是，在执行时出现了问题。
后来问同学，指出我的错误，不过获益不少。
我又重新整理思路，把顺序表的基本操作写好了。
虽然走了很多弯路，但是让我认识到，一定要创新，大胆，不能按照旧的思路去干新的事情。
但是细节上出了问题。
比如说，有些变量的重复定义，有些变量又没有定义，在调用函数，就直接复制过来，没有改参数……通过修改，我深刻理解到：
细节决定成败，在以后，不管做任何事情都要认真，细心。
升级会员 