北京科技大学数据结构试验报告附录含代码.docx

北京科技大学数据结构试验报告附录含代码.docx

《北京科技大学数据结构试验报告附录含代码.docx》由会员分享，可在线阅读，更多相关《北京科技大学数据结构试验报告附录含代码.docx（22页珍藏版）》请在冰豆网上搜索。

北京科技大学数据结构试验报告附录含代码

一、

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〈stdio.h>

#include

＃include

h>

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（”\nContinu