北京科技大学数据结构试验报告附录含代码.docx
《北京科技大学数据结构试验报告附录含代码.docx》由会员分享，可在线阅读，更多相关《北京科技大学数据结构试验报告附录含代码.docx（21页珍藏版）》请在冰豆网上搜索。
北京科技大学数据结构试验报告附录含代码
一、
1）功能描述
输入数据（设为整型）建立单链表，并求相邻两节点data值之和为最大的第一节点。
2）详细设计
遵循链表建立的基本思想，建立一个新的链表，H为表头，r为新节点，p为表尾节点指针，没存入一个新的数据则申请一个新的节点，知道没有数据输入，利用循环和打擂台法，比较和的大小，并输出。
3）测试分析
程序调试完成后，选取两组数据进行测试，都得出了正确结果（数据以0为结束符，若有相同和，则取第一组）
结果截图
4）心得体会
通过做第一题，学习到链表的建立以及链表里指针的使用，并且复习了比较法里面的打擂台法。
二、
1）功能描述
实现算术表达式求值程序（栈的运用），输入中缀表达式，可将其转换成后缀表达式
2）详细设计
本题目的程序是根据课本上的程序改进之后得出的，课本上有完整的程序，但是有bug，按照课本上的程序，结果会出现“烫烫烫烫烫”，原因是对于优先级的比较没有处理好，因此加了两行代码，将优先级的比较处理好，即现在的程序。
3）测试分析
程序调试完成后，选取题目所给的式子进行测试，得出了正确后缀表达式结果
结果截图
4）心得体会
通过做第二题，对于课本上的知识表示得出“实践出真知”的真理，即使书上的东西也不一定就是正确的，尤其是代码，最好是个人自己真正实践一下。
三、
1）功能描述
实现链式队列运算程序（队列的运用）
2）详细设计
本题目是队列相关应用，队列和栈是相反的，队列是先进的先出，因此输入12345，先出的是1，本着队列的这一特性，根据课本所学的队列的算法，设计了如下程序。
3）测试分析
程序调试完成后，选取12345进行测试，后缀加0，则一个字符出队，只输入0，则继续出队，输入@，则打印剩余全部元素。
结果截图
4）心得体会
通过做第三题，对于队列的特点有了更加深刻的认识，尤其区分队列与栈的不同点，需要特别注意。
四、
1）功能描述
①构造关于F的Huffman树；
②求出并打印D总各字符的Huffman编码。
2）详细设计
本题目是Huffman树的应用以及Huffman编码的应用，参照课本上关于Huffman树的建立以及Huffman编码的应用的实现，将所给数据依权值最小原则建立Huffman树，并实现Huffman编码。
3）测试分析
程序调试完成后，给出数据abcdefgh，相应频率为12345678，运行代码得出结果如图。
同时选取另一组数据测试也得出了正确结论
结果截图
4）心得体会
通过做第四题，对于Huffman树有了更加深刻的体会，同时练习也使得对课本知识进行实践，有助于更好的理解Huffman树的算法。
五、
1）功能描述
设英文句子：
“everyoneroundyoucanhearyouwhenyouspeak.”
（1）依次读入句中各单词，构造一棵二叉排序树；
（2）按LDR遍历此二叉排序树。
LDR：
caneveryonehearroundspeakwhenyou（有序）
2）详细设计
本题目是有关二叉树的建立和中序遍历的，二叉树作为数据存储一个很重要的结构，它的建立也是很重要的。
本题目代码设计上采用课本上的对于二叉树建立的方法，将所给单词以二叉树形式建立并存储，然后中序遍历的到字典顺序。
3）测试分析
程序调试完成后，给出单词串everyoneroundyoucanhearyouwhenyouspeak，运行代码得出中序遍历结果如图。
结果截图
4）心得体会
通过做第五题，练习运用二叉树模型解决了一些实际问题如现实中字典的编排问题，在熟悉算法的基础上，同时得出结论，好的算法可以应用与实际生活生产，使之更为便捷。
附录程序代码
实验一：
#include"stdio.h"
#include"malloc.h"
typedefstructnode
{
intdata;
structnode*next;
}list,*List;
ListCreatlist（）//建立链表函数
{
ListH,p,r;//H为表头，r为新节点，p为表尾节点指针
H=（List）malloc（sizeof（list））;//建立头节点
r=H;
p=（List）malloc（sizeof（list））;//申请新节点
while（scanf（"%d",p）&&p->data!
=0）//输入数据，直到为零（结束标志）
{
r->next=p;//新节点链入表尾
r=p;
p=（List）malloc（sizeof（list））;
}
r->next=NULL;//将尾节点的指针域置空
returnH;//返回已创建的头节点
}
ListAdjmax（ListH）//比较相邻两数之和
{//返回相邻两数之和最大的第一个数指针
Listp,r,q;
intsum=0;
p=H->next;
if（H->next==NULL）//判断是否为空
{
printf（"EmptyList!
"）;
q=（List）malloc（sizeof（list））;
q->data=0;
}
while（p!
=NULL）//比较相邻两数之和
{
r=p->next;
if（p&&r）
if（r->data+p->data>sum）
{
q=p;
sum=r->data+p->data;}//不断赋给sum新的最大值
else;
p=p->next;
}
returnq;
}
intmain（）
{
charch;
printf（"///请输入整形数据，以空格隔开，0结束。
///\n"）;
printf（"Ready?
\nY/N（enter'y'or'Y'tocontinue）\n"）;
while（scanf（"%c",&ch）&&（ch=='Y'||ch=='y'））
{
ListH,pmax;
H=Creatlist（）;
pmax=Adjmax（H）;
printf（"相邻两数之和最大的第一个数为：
%d\nContinue?
Y/N",pmax->data）;
free（H）;
scanf（"%c",&ch）;
}
return0;
}
实验二：
#include
#include
#include
typedefstructnode//栈节点类型
{
chardata;//存储一个栈元素
structnode*next;//后继指针
}snode,*slink;
intEmptystack（slinkS）//检测栈空
{
if（S==NULL）return
（1）;
elsereturn（0）;
}
charPop（slink*top）//出栈
{
chare;
slinkp;
if（Emptystack（*top））return（-1）;//栈空返回
else
{
e=（*top）->data;//取栈顶元素
p=*top;*top=（*top）->next;//重置栈顶指针
free（p）;return（e）;
}
}
voidPush（slink*top,chare）//进栈
{
slinkp;
p=（slink）malloc（sizeof（snode））;//生成进栈p节点
p->data=e;//存入元素e
p->next=*top;//p节点作为新的栈顶链入
*top=p;
}
voidClearstack（slink*top）//置空栈
{
slinkp;
while（*top!
=NULL）
{
p=（*top）->next;
Pop（top）;//依次弹出节点直到栈空
*top=p;
}
*top=NULL;
}
charGetstop（slinkS）//取栈顶
{
if（S!
=NULL）return（S->data）;
return（0）;
}
//符号优先级比较
intPrecede（charx,chary）//比较x是否"大于"y
{
switch（x）
{
case'（':
x=0;break;
case'+':
case'-':
x=1;break;
case'*':
case'/':
x=2;break;
default:
x=-1;
}
switch（y）
{
case'+':
case'-':
y=1;break;
case'*':
case'/':
y=2;break;
case'（':
y=3;break;
default:
y=100;
}
if（x>=y）return
（1）;
elsereturn（0）;
}
//中后序转换
voidmid_post（charpost[],charmid[]）//中缀表达式mid到后缀表达式post的转换的算法
{
inti=0,j=0;
charx;
slinkS=NULL;//置空栈
Push（&S,'#'）;//结束符入栈
do
{
x=mid[i++];//扫描当前表达式分量x
switch（x）
{case'#':
{while（!
Emptystack（S））
post[j++]=Pop（&S）;
}break;
case'）':
{while（Getstop（S）!
='（'）
post[j++]=Pop（&S）;//反复出栈直至遇到'（'
Pop（&S）;//退掉'（'
}break;
case'+':
case'-':
case'*':
case'/':
case'（':
{while（Precede（Getstop（S）,x））//栈顶运算符（Q1）与x比较
post[j++]=Pop（&S）;//Q1>=x时，输出栈顶符并退栈
Push（&S,x）;//Q1}break;
default:
post[j++]=x;//操作数直接输出
}
}while（x!
='#'）;
post[j]='\0';
}
//后缀表达式求值
intpostcount（charpost[]）//后缀表达式post求值的算法
{
inti=0;
charx;
floatz,a,b;
slinkS=NULL;//置栈空
while（post[i]!
='#'）
{x=post[i];//扫描每一个字符送x
switch（x）
{case'+':
b=Pop（&S）;a=Pop（&S）;z=a+b;Push（&S,z）;break;
case'-':
b=Pop（&S）;a=Pop（&S）;z=a-b;Push（&S,z）;break;
case'*':
b=Pop（&S）;a=Pop（&S）;z=a*b;Push（&S,z）;break;
case'/':
b=Pop（&S）;a=Pop（&S）;z=a/b;Push（&S,z）;break;//执行相应运算结果进栈
default:
x=post[i]-'0';Push（&S,x）;//操作数直接进栈
}
i++;
}
if（!
Emptystack（S））return（Getstop（S））;//返回结果
}
voidmain（）
{
charpost[255],mid[255]="";
printf（"请输入要处理的中缀表达式：
\n"）;
scanf（"%s",mid）;
printf（"相应的后缀表达式为：
\n"）;
mid_post（post,mid）;
printf（"%s\n",post）;
printf（"表达式的值为：
%d\n",postcount（post））;
getch（）;
}
实验三：
#include"stdio.h"
#include"malloc.h"
#definemax1000
typedefstructnode
{
charch[max];
intfront,rear;
}squeue,*sq;
voidClearqueue（sqQ）
{
Q->front=Q->rear;
}
intEmptyqueue（sqQ）
{
if（Q->rear==Q->front）
return1;
else
return0;
}
voidEnqueue（sqQ,charch）
{
if（Q->rear>=max）
{
printf（"FULLQUEUE!
"）;
}
else
{
Q->ch[Q->rear]=ch;
Q->rear++;
}}
voidDequeue（sqQ）
{
if（Emptyqueue（Q））
{
printf（"EmptyQUEUE!
\n"）;
}
else
{
printf（"出队：
%c\n",Q->ch[Q->front]）;
Q->front++;
}
}
voidPrintqueue（sqQ）
{
if（Emptyqueue（Q））
;
else
{
printf（"队列中全部元素：
\n"）;
while（Q->front!
=Q->rear-1）
{
printf（"%c",Q->ch[Q->front]）;
Q->front++;
}
printf（"\n"）;
}
}
intmain（）
{
sqQueue;
charf;
printf（"*******************************************\n"）;
printf（"请输入字符X\nX≠'@'并且X≠'@'字符入队；\n"）;
printf（"X='0',字符出队；\n"）;
printf（"X='@',打印队列中各元素。
\n"）;
printf（"*******************************************\n"）;
Queue=（sq）malloc（sizeof（squeue））;
Queue->front=Queue->rear=0;
while（scanf（"%c",&f）&&f!
='@'）
{
if（f!
='0'）
Enqueue（Queue,f）;
else
Dequeue（Queue）;
}
if（f=='@'）
Printqueue（Queue）;
else;
return0;}
实验四：
#include"stdio.h"
#include"malloc.h"
#defineN8
#defineMAX100
#defineM2*N-1
typedefstruct
{
charletter;
intw;
intparent,lchild,rchild;
}Huffm;
typedefstruct
{
charbits[N+1];
intstart;
charch;
}ctype;
voidinputHT（HuffmHT[M+1]）
{
inti;
for（i=1;i<=M;i++）
{
HT[i].w=0;
HT[i].parent=0;
HT[i].lchild=0;
HT[i].rchild=0;
}
printf（"请输入电文字符集：
"）;
for（i=1;i<=N;i++）
{
scanf（"%c",&HT[i].letter）;
}
printf（"请输入字符出现的频率：
"）;
for（i=1;i<=N;i++）
{
scanf（"%d",&HT[i].w）;
}
}
voidCreatHT（HuffmHT[M+1]）
{
inti,j,min1,min2;
inttag1,tag2;//权值最小两个点标号；
for（i=N+1;i<=M;i++）
{
tag1=tag2=0;
min1=min2=MAX;
for（j=1;j<=i-1;j++）
{
if（HT[j].parent==0）
if（HT[j].w{min2=min1;
min1=HT[j].w;
tag2=tag1;
tag1=j;
}
else
if（HT[j].w{
min2=HT[j].w;
tag2=j;
}
}
HT[tag1].parent=HT[tag2].parent=i;
HT[i].lchild=tag1;
HT[i].rchild=tag2;
HT[i].w=HT[tag1].w+HT[tag2].w;
}
}
voidHuffmcode（HuffmHT[M+1]）//Huffm编码函数
{
inti,j,p,tag;
ctypemcode,code[N+1];
for（i=1;i<=N;i++）
{
code[i].ch=HT[i].letter;
}
for（i=1;i<=N;i++）
{
mcode.ch=code[i].ch;
mcode.start=N+1;
tag=i;
p=HT[i].parent;
for（j=0;j<=N;j++）
mcode.bits[j]='';
while（p!
=0）
{
mcode.start--;
if（HT[p].lchild==tag）
mcode.bits[mcode.start]='0';
else
mcode.bits[mcode.start]='1';
tag=p;p=HT[p].parent;
}
code[i]=mcode;
}
for（i=1;i<=N;i++）
{
printf（"'%c'的Huffm编码为：
",code[i].ch）;
for（j=0;j<=N;j++）
printf（"%c",code[i].bits[j]）;
printf（"\n"）;
}
}
intmain（）
{
charch;
printf（"******************************************************\n"）;
printf（"电文字符集含8个字符，连续输入，不同频率之间以空格隔开\n"）;
printf（"******************************************************\n"）;
ch='y';
while（ch=='y'）
{
HuffmHT[M+1];
inputHT（HT）;
CreatHT（HT）;
Huffmcode（HT）;
printf（"Continue?
Y/N"）;
fflush（stdin）;
scanf（"%c",&ch）;
fflush（stdin）;
}
}
实验五：
#include"stdio.h"
#include"malloc.h"
#include"string.h"
typedefstructbsnode
{
charword[20];
structbsnode*lchild,*rchild;
}BStree,*BST;
BSTBSTinsert（BSTT,BSTs）
{
BSTf,p;
if（T==NULL）
returns;
p=T;f=NULL;
while（p）
{
f=p;
if（strcmp（s->word,p->word）==0）
{
free（s）;
returnT;
}
if（strcmp（s->word,p->word）<0）
p=p->lchild;
else
p=p->rchild;
}
if（strcmp（s->word,f->word）<0）
f->lchild=s;
else
f->rchild=s;
returnT;}
BSTCreatBst（）
{
BSTT,s;
charkeyword[20];
T=NULL;
gets（keyword）;
while（keyword[0]!
='0'）
{
s=（BST）malloc（sizeof（BStree））;
strcpy（s->word,keyword）;
s->lchild=s->rchild=NULL;
T=BSTinsert（T,s）;
gets（keyword）;
}
returnT;}
voidInorder（BSTT）
{
if（T）
{
Inorder（T->lchild）;
printf（"%s",T->word）;
Inorder（T->rchild）;
}
}
intmain（）
{charch;
BSTT;
printf（"************************************************************\n"）;
printf（"请输入英文句子，每输入一个单词以回车结束，句子结束以'0'结束。
\n"）;
printf（"************************************************************\n"）;
ch='y';
while（ch=='Y'||ch=='y'）
{
T=CreatBst（）;
printf（"按LDR遍历此二叉排序树（字典顺序）:
\n"）;
Inorder（T）;
free（T）;
printf（"\nCo
升级会员 