课程设计4查找和排序.docx
《课程设计4查找和排序.docx》由会员分享，可在线阅读，更多相关《课程设计4查找和排序.docx（27页珍藏版）》请在冰豆网上搜索。
课程设计4查找和排序
题目：
查找和排序
内容：
1哈希表设计，2内部排序算法比较日期：
2012年5月12日
姓名：
学号：
1、哈希表设计
一．实习目的
树和图是两种非线性数据结构，通过本次课程设计，熟悉它们的特性，应用树和图解决具体问题。
二．问题描述
针对某个集体中人名设计一个哈希表，使得平均查找长度不超过R，并完成相应的建表和查表程序。
三．需求分析
假设人名为中国人姓名的汉语拼音形式。
待填入哈希表的人名共有30个，取平均查找长度的上限为2。
哈希函数用除留余数法构造，用线性探测再散列法或链地址法处理冲突。
四．概要设计
（1）、针对某个集体中的人名设计一个哈希表，使得平均查找长度不超过R，完成相应的建立和查表程序。
（2）、人名为汉语拼音形式，最长不超过19个字符。
（3）、假设待填入哈希表的人名有30个，平均查找长度的上限为2。
哈希表用除留余数法构造，用伪随机探测在散列法处理冲突。
（4）、在输入人名过程中能自动识别非法输入，并给与非法输入的反馈信息要求重新输入。
（5）、找成功时，显示姓名及关键字，并计算和输出查找成功的平均查找长度。
五．详细设计（给出算法的伪码描述）
1.存储结构设计
typedefstruct
{char*py;//名字的拼音
intk;//拼音所对应的整数
}NAME;
typedefstruct//哈希表
{char*py;//名字的拼音
intk;//拼音所对应的整数
intsi;//查找长度
}HASH;
2.主要算法设计
（1）姓名（结构体数组）初始化
名字以拼音的形式够成字符串，将字符串的各个字符所对应的ASCII码相加，所得的整数做为哈希表的关键字。
voidInitNameList（）
{char*f;
intr,s0,i;
NameList[0].py,"lgwlkk"）;
NameList[1].py,"menfg"）;
NameList[2].py,"duanxp"）;
NameList[3].py,"tianjjiu"）;
NameList[4].py,"liuguangwei"）;
NameList[5].py,"caixm"）;
NameList[6].py,"liujh"）;
NameList[7].py,"liukk"）;
NameList[8].py,"fanwd"）;
NameList[9].py,"fanweidong"）;
NameList[10].py,"fanxie"）;
NameList[11].py,"tanyiwen"）;
NameList[12].py,"lixu"）;
NameList[13].py,"renjh"）;
NameList[14].py,"lizhuquan"）;
NameList[15].py,"youhy"）;
NameList[16].py,"zhanwl"）;
NameList[17].py,"tangyaozh"）;
NameList[18].py,"xiayj"）;
NameList[19].py,"jingminrui"）;
NameList[20].py,"wanger"）;
NameList[21].py,"sandong"）;
NameList[22].py,"liboxian"）;
NameList[23].py,"tianshu"）;
NameList[24].py,"chouyuyan"）;
NameList[25].py,"liuerwei"）;
NameList[26].py,"liusanwei"）;
NameList[27].py,"wukang"）;
NameList[28].py,"mixing"）;
NameList[29].py,"lishi"）;
for（i=0;i{
s0=0;
f=NameList[i].py;
for（r=0;*（f+r）!
='\0';r++）
/*方法：
将字符串的各个字符所对应的ASCII码相加，所得的整数做为哈希表的关键字*/
s0=*（f+r）+s0;
NameList[i].k=s0;
}
（2）建立哈希表
（1）用除留余数法构建哈希函数
（2）用伪随机探测再散列法处理冲突
voidCreateHashList（）
{inti;
for（i=0;i{HashList[i].py="";
HashList[i].k=0;
HashList[i].si=0;
}
for（i=0;i{intsum=0;
intadr=（NameList[i].k）%M;//哈希函数
intd=adr;
if（HashList[adr].si==0）//如果不冲突
{HashList[adr].k=NameList[i].k;
HashList[adr].py=NameList[i].py;
HashList[adr].si=1;
}
else//冲突
{do
{d=（d+NameList[i].k%10+1）%M;//伪随机探测再散列法处理冲突
sum=sum+1;//查找次数加1
}while（HashList[d].k!
=0）;
HashList[d].k=NameList[i].k;
HashList[d].py=NameList[i].py;
HashList[d].si=sum+1;
}
}
}
（3）查找哈希表
在哈希表中进行查找，输出查找的结果和关键字，并计算和输出查找成功的平均查找长度
voidFindList（）//查找
{charname[20]={0};
ints0=0,r,sum=1,adr,d;
printf（"请输入姓名的拼音:
"）;
scanf（"%s",name）;
for（r=0;r<20;r++）//求出姓名的拼音所对应的整数（关键字）
s0+=name[r];
adr=s0%M;//使用哈希函数
d=adr;
if（HashList[adr].k==s0）//分3种情况进行判断
printf（"\n姓名:
%s关键字:
%d查找长度为:
1",HashList[d].py,s0）;
elseif（HashList[adr].k==0）
printf（"无此记录!
"）;
else
{intg=0;
do
{d=（d+s0%10+1）%M;//伪随机探测再散列法处理冲突
sum=sum+1;
if（HashList[d].k==0）
{printf（"无此记录!
"）;
g=1;
}
if（HashList[d].k==s0）
{printf（"\n姓名:
%s关键字:
%d查找长度为:
%d",HashList[d].py,s0,sum）;
g=1;
}
}while（g==0）;
}
}
（4）显示哈希表
显示哈希表的的格式：
\n地址\t关键字\t\t搜索长度\tH（key）\t姓名\n
voidDisplay（）
{inti;
floataverage=0;
printf（"\n地址\t关键字\t\t搜索长度\tH（key）\t姓名\n"）;//显示的格式
for（i=0;i<50;i++）
{printf（"%d",i）;
printf（"\t%d",HashList[i].k）;
printf（"\t\t%d",HashList[i].si）;
printf（"\t\t%d",HashList[i].k%M）;
printf（"\t%s",HashList[i].py）;
printf（"\n"）;
}
for（i=0;iaverage+=HashList[i].si;
average/=NAME_NO;
printf（"\n平均查找长度：
ASL（%d）=%f\n",NAME_NO,average）;
}
（5）主函数设计
voidmain（）
{charch1;
InitNameList（）;
CreateHashList（）;
do
{printf（"D.显示哈希表\nF.查找\nQ.退出\n请选择：
"）;
cin>>&ch1;
switch（ch1）
{
case'D':
Display（）;cout<case'F':
FindList（）;cout<case'Q':
exit（0）;
}
cout<<"comeon!
（y/n）:
";
cin>>&ch1;
}while（ch1!
='n'）;
}
六．测试分析
白盒测试：
查看代码完整性：
较为完整
黑盒测试：
结构是否完整：
结构完整。
七．使用说明
八．附录：
测试数据
查找“lgwlkk”
查找：
“liboxian”
九．附C语言实现源码
#include
#include
usingnamespacestd;
#defineHASH_LENGTH50//哈希表的长度
#defineM47//随机数
#defineNAME_NO30//人名的个数
typedefstruct
{char*py;//名字的拼音
intk;//拼音所对应的整数
}NAME;
NAMENameList[HASH_LENGTH];//全局变量NAME
typedefstruct//哈希表
{char*py;//名字的拼音
intk;//拼音所对应的整数
intsi;//查找长度
}HASH;
HASHHashList[HASH_LENGTH];//全局变量HASH
voidInitNameList（）//姓名（结构体数组）初始化
{char*f;
intr,s0,i;
for（i=0;i{
NameList[i].py=newchar[64];
NameList[i].py[0]=0;
}
NameList[0].py,"lgwlkk"）;
NameList[1].py,"menfg"）;
NameList[2].py,"duanxp"）;
NameList[3].py,"tianjjiu"）;
NameList[4].py,"liuguangwei"）;
NameList[5].py,"caixm"）;
NameList[6].py,"liujh"）;
NameList[7].py,"liukk"）;
NameList[8].py,"fanwd"）;
NameList[9].py,"fanweidong"）;
NameList[10].py,"fanxie"）;
NameList[11].py,"tanyiwen"）;
NameList[12].py,"lixu"）;
NameList[13].py,"renjh"）;
NameList[14].py,"lizhuquan"）;
NameList[15].py,"youhy"）;
NameList[16].py,"zhanwl"）;
NameList[17].py,"tangyaozh"）;
NameList[18].py,"xiayj"）;
NameList[19].py,"jingminrui"）;
NameList[20].py,"wanger"）;
NameList[21].py,"sandong"）;
NameList[22].py,"liboxian"）;
NameList[23].py,"tianshu"）;
NameList[24].py,"chouyuyan"）;
NameList[25].py,"liuerwei"）;
NameList[26].py,"liusanwei"）;
NameList[27].py,"wukang"）;
NameList[28].py,"mixing"）;
NameList[29].py,"lishi"）;
for（i=0;i{
s0=0;
f=NameList[i].py;
for（r=0;*（f+r）!
='\0';r++）
/*方法：
将字符串的各个字符所对应的ASCII码相加，所得的整数做为哈希表的关键字*/
s0=*（f+r）+s0;
NameList[i].k=s0;
}
}
voidCreateHashList（）//建立哈希表
{
inti;
for（i=0;i{
HashList[i].py=newchar[64];
HashList[i].py[0]=0;
HashList[i].k=0;
HashList[i].si=0;
}
for（i=0;i{
intsum=0;
intadr=（NameList[i].k）%M;
//哈希函数
intd=adr;
if（HashList[adr].si==0）//如果不冲突
{
HashList[adr].k=NameList[i].k;
HashList[adr].py=NameList[i].py;
HashList[adr].si=1;
}
else//冲突
{
while（HashList[d].k!
=0）
{
d=（d+NameList[i].k%10+1）%M;//伪随机探测再散列法处理冲突
sum=sum+1;//查找次数加1
};
HashList[d].k=NameList[i].k;
HashList[d].py=NameList[i].py;
HashList[d].si=sum+1;
}
}
}
voidFindList（）//查找
{
stringname;
ints0=0,r,sum=1,adr,d;
cout<<"请输入姓名的拼音:
"<cin>>name;;
for（r=0;r<20;r++）//求出姓名的拼音所对应的整数（关键字）
s0+=name[r];
adr=s0%M;//使用哈希函数
d=adr;
if（HashList[adr].k==s0）//分3种情况进行判断
cout<<"姓名:
"<"<1"<elseif（HashList[adr].k==0）
cout<<"无此记录!
"<else
{
intg=0;
while（g==0）
{
d=（d+s0%10+1）%M;//伪随机探测再散列法处理冲突
sum=sum+1;
if（HashList[d].k==0）
{
cout<<"无此记录!
"<g=1;
}
if（HashList[d].k==s0）
{
cout<<"姓名:
"<"<"<g=1;
}
};
}
}
voidDisplay（）//显示哈希表
{
inti;
floataverage=0;
cout<<"\n地址\t关键字\t\t搜索长度\tH（key）\t姓名\n";//显示的格式
for（i=0;i<50;i++）
{
cout<cout<<"\t"<cout<<"\t\t"<cout<<"\t\t"<<（HashList[i].k%M）<<"";
cout<<"\t"<cout<<"\n";
}
for（i=0;iaverage+=HashList[i].si;
average/=NAME_NO;
cout<<"平均查找长度：
ASL（"<}
intmain（）
{
charx;
InitNameList（）;
CreateHashList（）;
cout<<"**********************************************"<cout<<"*d:
显示哈希表f:
查找任意键退出请选择：
*"<cout<<"**********************************************"<while（cin>>x）
{
if（x=='d'）
{
Display（）;
cout<}
elseif（x=='f'）
{
FindList（）;
cout<}
elsebreak;
}
for（inti=0;i{
DeleteNameList[i].py;//释放
DeleteHashList[i].py;//释放
}
return0;
}
十．附程序运行结果截图
程序运行：
选择：
显示哈希表：
选择：
查找
2、内部排序算法比较
一．实习目的
树和图是两种非线性数据结构，通过本次课程设计，熟悉它们的特性，应用树和图解决具体问题。
二．问题描述
各种内部排序算法的时间复杂度分析结果只给出了算法执行时间的阶，或大概执行时间。
试通过随机的数据比较各算法的关键字比较次数和关键字移动次数，以取得直观感受。
三．需求分析
（1）、对以下6种常用的内部排序算法进行对比：
直接插入排序；希尔排序；起泡排序；快速排序；简单选择排序；堆排序；
（2）、待排序表的表长不少于100；其中的数据要用伪随机数产生程序产生；至少要用5组不同的输入数据作比较；对比的指标为关键字比较次数和关键字移动次数（1次关键字交换计为3次移动）。
（3）、测试数据由随机函数产生。
四．概要设计
五．详细设计（给出算法的伪码描述）
六．测试分析
白盒测试：
查看代码完整性：
较为完整
黑盒测试：
结构是否完整：
结构完整
七．使用说明
按程序的提示输入数据，程序自动给出各种排序算法的比较次数和移动次数。
如果输入数据超出范围，程序会有提示，并继续。
八．附录：
测试数据
表长为：
10000的显示结果：
数据超出提示：
九．附C语言实现源码
#include
#include
#include
#include
#defineLIST_INIT_SIZE10000
intbj1,yd1,n;
clock_tstart_t,end_t;
typedefstruct
{
intkey;
}ElemType;
typedefstruct
{
ElemType*elem;
intlength;
}SqList;
voidaddlist（SqList&L）
{
inti;
a:
printf（"请输入待排序的表长（10000>=表长>=100）:
"）;
scanf（"%d",&n）;
printf（"********************************************\n"）;
if（n>10000）
{
printf（"超出范围重新输入!
!
!
\n"）;
gotoa;
}
L.elem=（ElemType*）malloc（LIST_INIT_SIZE*sizeof（ElemType））;
if（!
L.elem）exit（0）;
L.length=0;
for（i=1;i{
b:
L.elem[i].key=rand（）;
if（L.elem[i].key>30000）gotob;
++L.length;
}
}
voidSelectSort（SqList&L）//选择排序
{
start_t=clock（）;
inti,j,k,bj=0,yd=0;
for（i=1;i{
k=i;
for（j=i+1;j{
bj++;
if（L.elem[j].key}
if（i!
=k）
{
L.elem[0].key=L.elem[i].key;
L.elem[i].key=L.elem[k].key;
L.elem[k].key=L.elem[0].key;
yd+=3;
}
}
end_t=clock（）;
printf（"比较次数为：
%d移动次数为：
%d\n",bj,yd）;
printf（"排序用时为：
%f\n",float（end_t-start_t）/CLK_TCK）;
}
voidqipao（SqList&L）//起泡排序
{
start_t=clock（）;
inti=1,j,bj=0,yd=0;
while（i{
for（j=1;j{
bj++;
if（L.elem[j].key>L.elem[j+1].key）
{
L.elem[0].key=L.elem[j].key;
L.elem[j].key=L.elem[j+1].key;
L.elem[j+1].key=L.elem[0].key;
yd+=3;
}
}
i++;
}
end_t=clock（）;
pr
升级会员 