数据结构实验报告.docx
《数据结构实验报告.docx》由会员分享，可在线阅读，更多相关《数据结构实验报告.docx（30页珍藏版）》请在冰豆网上搜索。
数据结构实验报告
目录
实验一线性表的基本操作
1．实验目的……………………………………………………2
2．实验环境……………………………………………………2
3．实验内容，主要代码，调试与运行……………………2
4．总结……………………………………………………14实验二栈的基本操作
1．实验目的……………………………………………………15
2．实验环境……………………………………………………15
3．实验内容，主要代码，调试与运行……………………15
4．总结……………………………………………………18实验三赫夫曼树
1．实验目的……………………………………………………18
2．实验环境……………………………………………………18
3．实验内容，主要代码，调试与运行……………………19
4．总结……………………………………………………32
实验一线性表的基本操作
一、实验目的
１、熟悉ｃ或vc++语言上机环境。
２、会定义线性表的顺序存储结构和链式存储结构。
３、熟悉顺序表和链表的一些基本操作和应用。
４、加深对线性表的理解，逐步培养解决实际问题的编程能力。
二、实验环境
运行ｃ或vc++的微机。
三、实验内容
1.已知线性表la的数据元素（n个，n为偶数），现要求将la拆开成两个新的线性表lb，lc。
要求lb中的数据元素为la中的奇数位序的数据元素（a1,a3,…,an-1），lc中的数据元素为la中的偶数位序的数据元素（a2,a4,…,an）。
实验代码如下：
#include<stdio.h>
#include<malloc.h>
#definemax100//定义线性表的最大长度typedefstruct
{
charelem;charlist[max];//线性表intlength;//length指示当前线性表的长度}sqlist;
voidinitial（sqlist&）;//初始化线性表
voidinsert（sqlist&,int,char）;//在线性表中插入元素voidinitlist（sqlist&）;
voidprint（sqlist）;//显示线性表中所有元素voidmain（）
{sqlistla,lb,lc;//la,lb,lc是线性表
initial（la）;
initlist（lb）;
initlist（lc）;
inti;
for（i=0;i<la.length;i++）
{if（i%2==0）insert（lb,i/2,la.list[i]）;//奇数位插入lb
elseinsert（lc,i/2,la.list[i]）;}//偶数位插入lc
printf（\n您输入的线性表元素为:
\n\n）;
print（la）;
printf（线性表的奇数位次的元素为:
\n\n）;
print（lb）;
printf（线性表的偶数位次的元素为:
\n\n）;
print（lc）;
}
voidinitial（sqlist&v）
{
inti,a;
printf（请输入一个偶数作为线性表的长度:
\n\n）;
scanf（%d,&a）;
while（a%2!
=0）
{printf（您输入的数是奇数，请重新输入一个偶数:
\n\n）;
scanf（%d,&a）;}
v.length=a;
printf（\n请输入线性表元素:
\n\n）;
for（i=0;i<v.length;i++）
scanf（%c,&v.list[i]）;//对la进行赋值
}
voidinitlist（sqlist&v）//构造一个空的线性表
{
v.elem=（char）malloc（max*sizeof（char））;
v.length=0;
}
voidinsert（sqlist&v,intj,charc）
{
v.list[j]=c;//插入c
v.length++;
}
voidprint（sqlistv）
{
inti;
for（i=0;i<v.length;i++）
{printf（%c,v.list[i]）;}//输出线性表元素
printf（\n\n）;
调试通过后运行结果如下：
2.已知线性表la的数据元素（n个），现要求将la的数据元素复制到另一个线性表lb中。
实验代码如下：
#include<stdio.h>
#include<malloc.h>
#definemax100//定义线性表的最大长度
typedefstruct
{
charelem;charlist[max];//线性表intlength;//length指示当前线性表的长度}sqlist;
voidinitial（sqlist&）;//初始化线性表
voidinitlist（sqlist&）;
voidprintf（sqlist）;//显示线性表中所有元素
voidmain（）
{
initial（la）;initlist（lb）;inti;for（i=0;i<la.length;i++）//复制{
lb.list[i]=la.list[i];
lb.length++;
}
printf（lb）;
}
voidinitial（sqlist&v）//{
inti;
printf（请输入一个线性表的长度（最大为100）:
\n）;
scanf（%d,&v.length）;
printf（请输入线性表元素:
\n）;
for（i=0;i<v.length;i++）
scanf（%c,&v.list[i]）;
}
voidinitlist（sqlist&v）//{
v.elem=（char）malloc（max*sizeof（char））;
v.length=0;
}
voidprintf（sqlistv）
{
inti;
printf（\n复制得到的线性表为:
\n）;
for（i=0;i<v.length;i++）
printf（%c,v.list[i]）;
printf（\n）;
}
调试通过后运行结果如下：
构造线性表构造空线性表
3.设有一个线性表采用顺序存储结构，表中的数据元素值为正整数（n个）。
设在o（n）时间内，将线性表分成两为两部分，其中左半部分每个元素都小于原表的第一个元素，而右半部分则相反。
实验代码如下：
#include<stdio.h>
#include<malloc.h>
#definemax100//定义线性表的最大长度typedefstruct
{
intelem;intlist[max];//线性表intlength;//length指示当前线性表的长度}sqlist;
voidinitial（sqlist&）;//初始化线性表
voidinsert（sqlist&,int,int）;
voidinitlist（sqlist&）;
voidprint（sqlist）;//显示线性表中所有元素voidmain（）
{
sqlistla,lb,lc;
initial（la）;initlist（lb）;initlist（lc）;inti=1,j=0,k=0,x=la.list[0];for（;i<la.length;i++）if（la.list[i]<x）{insert（lb,j,la.list[i]）;j++;}else{insert（lc,k,la.list[i]）;k++;}printf（\n将输入的线性表以首元素为中心分成两部分:
\n）;
print（lb）;
printf（%d\n\n,x）;
print（lc）;
}
voidinitial（sqlist&v）
{
inti;
printf（请输入线性表长度:
\n）;
scanf（%d,&v.length）;
printf（\n请输入线性表元素:
\n）;
for（i=0;i<v.length;i++）
scanf（%d,&v.list[i]）;
}
voidinitlist（sqlist&v）//
{
v.elem=（int）malloc（max*sizeof（int））;
v.length=0;
}
voidinsert（sqlist&v,intj,intc）
{
v.list[j]=c;//
v.length++;
}
voidprint（sqlistv）
{
inti;
for（i=0;i<v.length;i++）
{printf（%d,v.list[i]）;}//
printf（\n\n）;
}
调试通过后运行结果如下：
构造一个空的线性表插入输出线性表元素
4.设线性表la＝（a1,a2,…,am），lb＝（b1,b2,…,bn）。
试编写一个算法，将la、lb合并为线性表lc，使
?
?
a1,b1,...,am,bm,bm?
1,...,bn?
当m?
n时lc＝?
?
?
a1,b1,...,an,bn,an?
1,...,am?
当m?
n时
要求la、lb和lc均以单链表为存储结构，且lc表利用la和lb中结点空间，这里m和n的值没有保存在头结点中，并分析算法时间复杂度。
实验代码如下：
#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
typedefstructnode{
}s;charx;structnode*next;
s*s_create（s*head）{
charch;
s*h,*p,*q;
h=（s*）malloc（sizeof（s））;
h->x=;
p=h;
fflush（stdin）;//这一句必须加，不然第二次使用该函数时，ch读到的值是回车scanf（%c,&ch）;
while（ch!
=0）{
q=（s*）malloc（sizeof（s））;
q->x=ch;
p->next=q;
p=q;
scanf（%c,&ch）;
}
p->next=null;
returnh;
}
voids_union（s*head1,s*head2）{
//s*p=head1->next,*q=head2->next,*r=head1;
//实现两个链表交叉合并为head1
s*h1,*h2;
s*upre;
h1=head1;
h2=head2;
upre=h1;
//puts（合并）;
//一比一比例交叉合并
if（null==h1）{
upre=h2;
printf（表1为空）;
}
else
if（null==h2）{
upre=h1;
printf（表2为空）;
}else
while（null!
=（h1->next）&&null!
=（h2->next））{
//插入h1节点，并在插入后把upre移到h2节点h1=h1->next;//h1下移一个节点
upre->next=h2;//插入h1节点，并转而对h2进行操作upre=h2;
//插入h2节点，并在插入后把upre移到h1节点h2=h2->next;
upre->next=h1;
upre=h1;
}
//末尾补齐，在上面的情况，最终upre=h1
if（null==（h1->next））{
upre->next=h2;
}
else{
h1=h1->next;
upre->next=h2;
h2->next=h1;
}
while（p!
=null&&q!
=null）{
r->next=p->next;
r=p;
p=p->next;
r->next=q->next;
r=q;
q=q->next;
}
if（p）{
r->next=p;
}
else{
r->next=q;
}
*/
}
voidprintf_s（s*head）{
s*p=head->next;
while（null!
=p）{
printf（%c,p->x）;
p=p->next;
}
}
intmain（）{
}return0;s*head1,*head2;//intlength1=0,length2=0;head1=（s*）malloc（sizeof（s））;//为head1申请空间head2=（s*）malloc（sizeof（s））;printf（\n输入线性表一（遇0结束）:
\n）;head1=s_create（head1）;printf（\n线性表一:
\n）;printf_s（head1）;printf（\n输入线性表二（遇0结束）:
\n）;head2=s_create（head2）;printf（\n线性表二:
\n）;printf_s（head2）;printf（\n合并后的线性表为:
\n）;s_union（head1,head2）;printf_s（head1）;printf（\n）;
调试通过后运行结果如下：
5.约瑟夫问题：
设编号为1，2，…，n的n（n>0）个人按顺时针方向围坐一圈，每人持有一正整数密码。
开始时任选一个正整数作为报数上限值m，从第一个人开始顺时针方向自1起顺序报数，报到m时停止报数，报m的人出列，将他的密码作为新的m值，从他在顺时针方向上的下一个人起重新从1报数。
如此下去，直到所有人全部出列为止。
令n最大值取30。
要求设计一个程序模拟此过程，求出出列编号序列（采用循环单链表结构）。
实验代码如下：
#include<stdio.h>
#include<malloc.h>
typedefstructnode
{
intnum,code;structnode*next;
}linklist;
voidmain（）
{
for（i=1;i<n;i++）//依次出列{s=（linklist*）malloc（sizeof（linklist））;//分配地址scanf（%d,&s->code）;s->num=i+1;intm=0,n=0,i=0,j=0;linklist*head,*s,*r,*p;//声明printf（\n请输入一个正整数作为第一个报数上限值m:
\n）;scanf（%d,&m）;printf（\n请输入一个正整数作为人数n（n最大30）:
\n）;scanf（%d,&n）;printf（\n请输入%d个正整数作为每个人的密码:
\n,n）;head=（linklist*）malloc（sizeof（linklist））;//分配地址scanf（%d,&head->code）;head->num=1;r=head;
}s->next=null;r->next=s;r=r->next;r=head;s->next=head;printf（\n输出出列序号:
\n）;//输出一次出列的序号for（j=n;j>0;j--）
{
if（m==1）
{
printf（%d,r->num）;
p->next=r->next;
r=r->next;
m=r->code;
printf（\n）;
}
else
{
for（i=1;i<m-1;i++）
{r=r->next;}
p=r;
s=r->next;
printf（%d,s->num）;
r->next=s->next;
r=s->next;
m=s->code;
printf（\n）;
free（s）;//
}
}
printf（\n）;
}
调试通过后运行结果如下：
释放s
四、总结
通过上面五个实验对线性表和链表的使用有了初步的了解。
通过程序实现了线性表的拆分，合并，复制，和单链表循环。
要注意的是线性表在使用之前都要先初始化，不用的空间最后要释放掉。
实验中还涉及到了时间复杂度的计算，提高时间复杂度可以缩短程序运行的时间。
实验二栈的基本操作
一、实验目的
１、定义栈的结点类型。
２、掌握栈插入和删除元素在操作上的特点。
３、熟悉栈的基本操作。
４、加深对栈的理解，逐步培养解决实际问题的编程能力。
二、实验环境
运行ｃ或vc++的微机。
三、实验内容
1、试编写算法，在顺序存储结构下实现堆栈的下列运算：
（1）initstk（s）。
初始化操作，建立一个空栈s；实验代码如下：
stayusinitstack（sqstack&s）个空栈
{
s.base=（selemtype*）malloc（stackinitsize*sizeof（selemtype））;
if（!
s.base）exit（overflow）;分配失败
s.top=s.base;
s.stacksize=stackinitsize;
returnok;
}//initstack
//构造一//存储
（2）emptystk（s）。
判定栈是否为空；
实验代码如下：
statusstackempty（sqstacks）
{
if（s.top==s.base）returntrue;
elsereturnfalse;
}//stackempty
（3）pushstk（s）。
如果栈s不满，在栈顶插入x；
实验代码如下：
statuspush（sqstack&s,selemtype）//插入元素e为新的栈顶元素
{
if（s.top-s.base>=s.stacksize）//栈满,追加存储空间
{
s.base=（selemtype*）realloc（s.base,（s.stacksize+stackincrement）*sizeof（selemtype））;
if（!
s.base）exit（overflow）;//存储分配失败
s.top=s.base+s.stacksize;
s.stacksize+=stackincrement;
}
*s.top++=e;
returnok;
}//push
（4）popstk（s）。
如果栈s不空，删除栈顶元素，并返回该元素的值；实验代码如下：
statuspop（sqstack&s,selemtype&e）//若栈不空,则删除s的栈顶元素,用e返回其值,并返回ok;否则返回error）
{
if（s.top==s.base）
returnerror;
e=*--s.top;
returnok;
}//pop
（5）getstk（s）。
如果栈s不空，返回栈顶元素。
实验代码如下：
statusgettop（sqstacks,selemtype&e）//若栈不空,则用e返回s的栈顶元素,并返回ok;否则返回error
{
if（s.top==s.base）
returnerror;
e=*（s.top-1）;
returnok;
}//gettop
２、试编写算法，实现数制转换：
对于输入的任意一个非负十进制
整数，打印输出与其等值的八进制数。
实验代码如下：
voidconversion（）
{//对于输入的任意一个非负十进制整数，打印、出与其等值的八进制数
initstack（s）;//构造空栈
scanf（%d,n）;while（n）
{
push（s,n%8）;
n=n/8;
}
while（!
stackempty（s））
{
pop（s,e）;
printf（%d,e）;
}
}//conversion
五、总结
本实验复习了课本上栈这一章的基本算法和内容。
栈的操作除了初始化，判断是否为空，插入，删除，返回值之外，还有清空栈，删除栈等等。
操作时要注意入栈和出栈的顺序。
实验三赫夫曼树
一、实验目的
１、熟悉二叉树的结点类型和二叉树的基本操作。
２、掌握建立赫夫曼树的操作。
3、加深对二叉树的理解，逐步培养解决实际问题的编程能力。
二、实验环境
运行ｃ或vc++的微机。
三、实验内容
完成huffman编码的译码过程。
即输入一个码串，请翻译成相应的字符串。
要求有编码过程和解码过程。
（1）构造哈夫曼树；
（2）求哈夫曼编码。
实验代码如下：
include<iostream.h>
#include<iomanip.h>
#include<string.h>
#include<malloc.h>
#include<stdio.h>
//typedefinttelemtype;
constintuint_max=1000;
typedefstruct
{
intweight;
intparent,lchild,rchild;
}htnode,*huffmantree;
typedefchar**huffmancode;
//-----------全局变量-----------------------
huffmantree
升级会员 