数据结构实验报告Word格式文档下载.docx
《数据结构实验报告Word格式文档下载.docx》由会员分享，可在线阅读，更多相关《数据结构实验报告Word格式文档下载.docx（17页珍藏版）》请在冰豆网上搜索。
s1,int&
s2）
{inti;
i=1;
while（i<
=k&
&
HT[i].parent!
=0）i++;
//下面选出权值最小的结点，用s1指向其序号
s1=i;
for（i=1;
i<
=k;
i++）
{
if（HT[i].parent==0&
HT[i].weight
}
//下面选出权值次小的结点，用s2指向其序号
i!
=s1）break;
s2=i;
=s1&
//构造Huffman树，求出n个字符的编码
voidHuffmanCoding（HuffmanTree&
HT,HuffmanCode&
HC,int*w,intn）
intm,c,f,s1,s2,i,start;
char*cd;
if（n<
=1）return;
m=2*n-1;
//n个叶子n-1个结点
HT=（HuffmanTree）malloc（（m+1）*sizeof（HTNode））;
//0号单元未用，预分配m+1个单元
HuffmanTreep=HT+1;
w++;
//w的号单元也没有值，所以从号单元开始
=n;
i++,p++,w++）
p->
weight=*w;
parent=p->
rchild=p->
lchild=0;
for（;
=m;
++i,++p）
weight=p->
for（i=n+1;
Select（HT,i-1,s1,s2）;
//选出当前权值最小的
HT[s1].parent=i;
HT[s2].parent=i;
HT[i].lchild=s1;
HT[i].rchild=s2;
HT[i].weight=HT[s1].weight+HT[s2].weight;
//从叶子到根逆向求每个字符的郝夫曼编码
HC=（HuffmanCode）malloc（（n+1）*sizeof（char*））;
//分配n个字符编码的头指针变量
cd=（char*）malloc（n*sizeof（char））;
//分配求编码的工作空间
cd[n-1]='
'
;
//编码结束符
i++）//逐个字符求郝夫曼编码
start=n-1;
//编码结束符位置
for（c=i,f=HT[i].parent;
f!
=0;
c=f,f=HT[f].parent）//从叶子到根逆向求编码
if（HT[f].lchild==c）cd[--start]='
0'
else
cd[--start]='
1'
HC[i]=（char*）malloc（（n-start）*sizeof（char））;
//为第i个字符编码分配空间
strcpy（HC[i],&
cd[start]）;
//从cd复制编码到HC
free（cd）;
//释放工作空间
voidmain
{intn,i;
int*w;
//记录权值
char*ch;
//记录字符
HuffmanTreeHT;
HuffmanCodeHC;
cout<
<
"
请输入待编码的字符个数n="
cin>
>
n;
w=（int*）malloc（（n+1）*sizeof（int））;
//记录权值，号单元未用
ch=（char*）malloc（（n+1）*sizeof（char））;
//记录字符，号单元未用
依次输入待编码的字符data及其权值weight"
data["
数据结构实验报告2
一、实验目的及要求
1）掌握栈和队列这两种特殊的线性表，熟悉它们的特性，在实际问题背景下灵活运用它们。
本实验训练的要点是“栈”和“队列”的观点;
二、实验内容
1）利用栈，实现数制转换。
2）利用栈，实现任一个表达式中的语法检查（选做）。
3）编程实现队列在两种存储结构中的基本操作（队列的初始化、判队列空、入队列、出队列）;
三、实验流程、操作步骤或核心代码、算法片段
顺序栈：
StatusInitStack（SqStack&
S）
S.base=（ElemType*）malloc（STACK_INIT_SIZE*sizeof（ElemType））;
if（!
S.base）
returnERROR;
S.top=S.base;
S.stacksize=STACK_INIT_SIZE;
returnOK;
StatusDestoryStack（SqStack&
free（S.base）;
StatusClearStack（SqStack&
StatusStackEmpty（SqStackS）
if（S.base==S.top）
intStackLength（SqStackS）
returnS.top-S.base;
StatusGetTop（SqStackS,ElemType&
e）
if（S.top-S.base>
=S.stacksize）
S.base=（ElemType*）realloc（S.base,（S.stacksize+STACKINCREMENT）*sizeof（ElemType））;
S.base）returnERROR;
S.top=S.base+S.stacksize;
S.stacksize+=STACKINCREMENT;
*S.top++=e;
StatusPush（SqStack&
S,ElemTypee）
StatusPop（SqStack&
S,ElemType&
if（S.top==S.base）
e=*--S.top;
StatusStackTraverse（SqStackS）
ElemType*p;
p=（ElemType*）malloc（sizeof（ElemType））;
p）returnERROR;
p=S.top;
while（p!
=S.base）//S.top上面一个...
p--;
printf（"
%d"
*p）;
StatusCompare（SqStack&
intflag,TURE=OK,FALSE=ERROR;
ElemTypee,x;
InitStack;
flag=OK;
请输入要进栈或出栈的元素：
）;
while（（x=getchar）!
='
#'
flag）
switch（x）
case'
（'
:
['
{'
if（Push（S,x）==OK）
括号匹配成功!
"
break;
）'
if（Pop（S,e）==ERROR||e!
）
没有满足条件"
flag=FALSE;
]'
if（Pop（S,e）==ERROR||e!
}'
if（flag&
x=='
&
StackEmpty）
链队列：
StatusInitQueue（LinkQueue&
Q）
Q.front=Q.rear=
（QueuePtr）malloc（sizeof（QNode））;
if（!
Q.front）returnERROR;
Q.front->
next=NULL;
StatusDestoryQueue（LinkQueue&
while（Q.front）
Q.rear=Q.front->
next;
free（Q.front）;
Q.front=Q.rear;
StatusQueueEmpty（LinkQueue&
if（Q.front->
next==NULL）
StatusQueueLength（LinkQueueQ）
inti=0;
QueuePtrp,q;
p=Q.front;
while（p->
next）
i++;
q=p->
p=q;
returni;
StatusGetHead（LinkQueueQ,ElemType&
QueuePtrp;
p=Q.front->
p）
e=p->
data;
returne;
StatusClearQueue（LinkQueue&
while（Q.front->
next）
Q.front=p;
next=NULL;
Q.rear->
StatusEnQueue（LinkQueue&
Q,ElemTypee）
p=（QueuePtr）malloc（sizeof（QNode））;
data=e;
next=p;
Q.rear=p;
//p->
next为空
StatusDeQueue（LinkQueue&
Q,ElemType&
if（Q.front==Q.rear）
p=Q.front->
e=p->
next=p->
if（Q.rear==p）
Q.rear=Q.front;
//只有一个元素时（不存在指向尾指针）
free（p）;
StatusQueueTraverse（LinkQueueQ）
if（QueueEmpty（Q）==OK）
这是一个空队列!
while（p）
q=p;
%d<
-"
q->
data）;
循环队列：
StatusInitQueue（SqQueue&
Q.base=（QElemType*）malloc（MAXQSIZE*sizeof（QElemType））;
Q.base）
exit（OWERFLOW）;
Q.front=Q.rear=0;
StatusEnQueue（SqQueue&
Q,QElemTypee）
if（（Q.rear+1）%MAXQSIZE==Q.front）
Q.base[Q.rear]=e;
Q.rear=（Q.rear+1）%MAXQSIZE;
StatusDeQueue（SqQueue&
Q,QElemType&
if（Q.front==Q.rear）
e=Q.base[Q.front];
Q.front=（Q.front+1）%MAXQSIZE;
intQueueLength（SqQueueQ）
return（Q.rear-Q.front+MAXQSIZE）%MAXQSIZE;
StatusDestoryQueue（SqQueue&
free（Q.base）;
StatusQueueEmpty（SqQueueQ）//判空
if（Q.front==Q.rear）
StatusQueueTraverse（SqQueueQ）
while（Q.front%MAXQSIZE!
=Q.rear）
Q.base[Q.front]）;
Q.front++;
数据结构实验报告3
《数据结构与算法》实验报告
专业班级姓名学号
实验项目
实验一二叉树的应用
实验目的
1、进一步掌握指针变量的含义及应用。
2、掌握二叉树的结构特征，以及各种存储结构的特点及使用范围。
3、掌握用指针类型描述、访问和处理二叉树的运算。
实验内容
题目1:
编写一个程序，采用一棵二叉树表示一个家谱关系。
要求程序具有如下功能：
（1）用括号表示法输出家谱二叉树，
（2）查找某人的所有儿子，
（3）查找某人的所有祖先。
算法设计分析
（一）数据结构的定义
为了能够用二叉树表示配偶、子女、兄弟三种关系，特采用以下存储关系，则能在二叉树上实现家谱的各项运算。
二叉树型存储结构定义为：
typedefstructSNODE
{charname[MAX];
//人名
structSNODE*left;
//指向配偶结点
structSNODE*right;
//指向兄弟或子女结点
}FNODE;
（二）总体设计
实验由主函数、家谱建立函数、家谱输出函数、儿子查找函数、祖先查找函数、结点定位函数、选择界面函数七个函数共同组成。
其功能描述如下：
（1）主函数：
统筹调用各个函数以实现相应功能
（2）家谱建立函数：
与用户交互建立家族成员对应关系
voidInitialFamily（FNODE*&
head）//家谱建立函数
（3）家谱输出函数：
用括号表示法输出家谱
输出形式为：
父和母（子1和子妻1（孙1），子2和子妻2（孙2））
voidPrintFamily（FNODE*head）//家谱输出函数
（4）儿子查找函数：
在家谱中查找到某人所有的子女并输出，同时也能辨别出其是否为家族成员与是否有子女
voidFindSon（FNODE*b,charp[]）//儿子查找函数
（5）祖先查找函数：
在家谱中查找到某人所有的祖先并输出，同时也能辨别出其是否为家族中成员。
intFindAncestor（FNODE*head,charson[]）//祖先查找函数
（6）结点定位函数：
在家谱中找到用户输入人名所对应的结点。
FNODE*findnode（FNODE*b,charp[]）//结点定位函数
（7）选择界面函数：
为便于编写程序，将用户选择部分独立为此函数。
voidPRINT（int&
n）
（三）各函数的详细设计：
1：
首先建立当前人的信息，将其左右结点置为空，
2：
然后让用户确定其是否有配偶，如果没有配偶，则当前程序结束，
3：
如果有则建立其配偶信息，并将配偶结点赋给当前人的左结点；
4：
再让用户确定其是否有子女，如果有则递归调用家谱建立函数建立子女结点，并将其赋给配偶结点的下一个右结点。
5：
如无，则程序结束
首先判断当前结点是否为空，如果为空则结束程序；
如果不为空，则输出当前结点信息，
然后判断其左结点（配偶结点）是否为空，如不为空则输出“和配偶信息。
再判断配偶结点的右结点是否为空，如不为空则递归调用输出其子女信息，最后输出“）”；
当配偶结点为空时，则判断其右结点（兄弟结点）是否为空
6：
如果不为空，则输出“，”，并递归调用输出兄弟信息
7程序结束
当前结点是否为空，为空则返回空；
如果和查找信息相同，则返回当前结点；
如不然，则先后递归访问其左结点，再不是则递归访问右结点
在家谱中定位到要查找的结点，如无则输出“查找不到此人”
判断其配偶结点与子女结点是否为空，为空则输出“无子女”
不为空则输出其配偶结点的所有右结点（子女结点）。
先在家谱中定位到要查找的结点，如为空输出“不存在此人”，程序结束
先将父母结点入栈，当栈为空时程序结束，
栈不为空时，判断栈顶元素是否已访问过，
访问过，再判断是否为查找结点，如是则输出栈中保存的其祖先结点，并滤过其兄弟结点不输出；
不是查找结点，则退栈一个元素
未访问过，则取当前栈顶元素，置访问标志――1，同时取其右结点
栈不为空或当前所取结点不为空时，转到2；
实验测试结果及结果分析
（一）测试结果
（二）结果分析
（略）
实验总结
升级会员 