数据结构实验报告.docx
《数据结构实验报告.docx》由会员分享,可在线阅读,更多相关《数据结构实验报告.docx(14页珍藏版)》请在冰豆网上搜索。
![数据结构实验报告.docx](https://file1.bdocx.com/fileroot1/2023-1/27/9374cdb7-ec1a-47d0-80ff-03aa68f50666/9374cdb7-ec1a-47d0-80ff-03aa68f506661.gif)
数据结构实验报告
数据结构实验报告
想必学计算机专业的同学都知道数据构造是一门比拟重要的课程,则,下面是我给大家收拾收集的数据构造试验报告,供大家阅读参考。
数据构造试验报告1
一、试验目的及要求
1)控制栈和队列这两种特别的线性表,熟识它们的特性,在实际问题背景下灵便运用它们。
本试验训练的要点是"栈'和"队列'的观点;
二、试验内容
1)利用栈,实现数制转换。
2)利用栈,实现任一个叙述式中的语法检查(选做)。
3)编程实现队列在两种存储构造中的根本操作(队列的初始化、判队列空、入队列、出队列);
三、试验流程、操作步骤或核心代码、算法片段
顺序栈:
StatusInitStack(SqStackS)
{
S.base=(ElemType*)malloc(STACK_INIT_SIZE*sizeof(ElemType));
if(!
S.base)
returnERROR;
S.top=S.base;
S.stacksize=STACK_INIT_SIZE;
returnOK;
}
StatusDestoryStack(SqStackS)
{
free(S.base);
returnOK;
}
StatusClearStack(SqStackS)
{
S.top=S.base;
returnOK;
}
StatusStackEmpty(SqStackS)
{
if(S.base==S.top)
returnOK;
returnERROR;
}
intStackLength(SqStackS)
{
returnS.top-S.base;
}
StatusGetTop(SqStackS,ElemTypee)
{
if(S.top-S.base=S.stacksize)
{
S.base=(ElemType*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(ElemType));
if(!
S.base)returnERROR;
S.top=S.base+S.stacksize;
S.stacksize+=STACKINCREMENT;
}
*S.top++=e;
returnOK;
}
StatusPush(SqStackS,ElemTypee)
{
if(S.top-S.base=S.stacksize)
{
S.base=(ElemType*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(ElemType));
if(!
S.base)
returnERROR;
S.top=S.base+S.stacksize;
S.stacksize+=STACKINCREMENT;
}
*S.top++=e;
returnOK;
}
StatusPop(SqStackS,ElemTypee)
{
if(S.top==S.base)
returnERROR;
e=*--S.top;
returnOK;
}
StatusStackTraverse(SqStackS)
{
ElemType*p;
p=(ElemType*)malloc(sizeof(ElemType));
if(!
p)returnERROR;
p=S.top;
while(p!
=S.base)//S.top上面一个...
{
p--;
printf(%d,*p);
}
returnOK;
}
StatusCompare(SqStackS)
{
intflag,TURE=OK,FALSE=ERROR;
ElemTypee,x;
InitStack(S);
flag=OK;
printf(请输入要进栈或出栈的元素:
);
while((x=getchar)!
=#flag)
{
switch(x)
{
case(:
case[:
case{:
if(Push(S,x)==OK)
printf(括号匹配胜利!
\n\n);
break;
case):
if(Pop(S,e)==ERROR||e!
=()
{
printf(没有满足条件\n);
flag=FALSE;
}
break;
case]:
if(Pop(S,e)==ERROR||e!
=[)
flag=FALSE;
break;
case}:
if(Pop(S,e)==ERROR||e!
={)
flag=FALSE;
break;
}
}
if(flagx==#StackEmpty(S))
returnOK;
else
returnERROR;
}
链队列:
StatusInitQueue(LinkQueueQ)
{
Q.front=Q.rear=
(QueuePtr)malloc(sizeof(QNode));
if(!
Q.front)returnERROR;
Q.front-next=NULL;
returnOK;
}
StatusDestoryQueue(LinkQueueQ)
{
while(Q.front)
{
Q.rear=Q.front-next;
free(Q.front);
Q.front=Q.rear;
}
returnOK;
}
StatusQueueEmpty(LinkQueueQ)
{
if(Q.front-next==NULL)
returnOK;
returnERROR;
}
StatusQueueLength(LinkQueueQ)
{
inti=0;
QueuePtrp,q;
p=Q.front;
while(p-next)
{
i++;
p=Q.front;
q=p-next;
p=q;
}
returni;
}
StatusGetHead(LinkQueueQ,ElemTypee)
{
QueuePtrp;
p=Q.front-next;
if(!
p)
returnERROR;
e=p-data;
returne;
}
StatusClearQueue(LinkQueueQ)
{
QueuePtrp;
while(Q.front-next)
{
p=Q.front-next;
free(Q.front);
Q.front=p;
}
Q.front-next=NULL;
Q.rear-next=NULL;
returnOK;
}
StatusEnQueue(LinkQueueQ,ElemTypee)
{
QueuePtrp;
p=(QueuePtr)malloc(sizeof(QNode));
if(!
p)
returnERROR;
p-data=e;
p-next=NULL;
Q.rear-next=p;
Q.rear=p;//p-next为空
returnOK;
}
StatusDeQueue(LinkQueueQ,ElemTypee)
{
QueuePtrp;
if(Q.front==Q.rear)
returnERROR;
p=Q.front-next;
e=p-data;
Q.front-next=p-next;
if(Q.rear==p)
Q.rear=Q.front;//惟独一个元素时(不存在指向尾指针)
free(p);
returnOK;
}
StatusQueueTraverse(LinkQueueQ)
{
QueuePtrp,q;
if(QueueEmpty(Q)==OK)
{
printf(这是一个空队列!
\n);
returnERROR;
}
p=Q.front-next;
while(p)
{
q=p;
printf(%d-\n,q-data);
q=p-next;
p=q;
}
returnOK;
}
循环队列:
StatusInitQueue(SueueQ)
{
Q.base=(QElemType*)malloc(MAXQSIZE*sizeof(QElemType));
if(!
Q.base)
exit(OWERFLOW);
Q.front=Q.rear=0;
returnOK;
}
StatusEnQueue(SueueQ,QElemTypee)
{
if((Q.rear+1)%MAXQSIZE==Q.front)
returnERROR;
Q.base[Q.rear]=e;
Q.rear=(Q.rear+1)%MAXQSIZE;
returnOK;
}
StatusDeQueue(SueueQ,QElemTypee)
{
if(Q.front==Q.rear)
returnERROR;
e=Q.base[Q.front];
Q.front=(Q.front+1)%MAXQSIZE;
returnOK;
}
intQueueLength(SueueQ)
{
return(Q.rear-Q.front+MAXQSIZE)%MAXQSIZE;
}
StatusDestoryQueue(SueueQ)
{
free(Q.base);
returnOK;
}
StatusQueueEmpty(SueueQ)//判空
{
if(Q.front==Q.rear)
returnOK;
returnERROR;
}
StatusQueueTraverse(SueueQ)
{
if(Q.front==Q.rear)
printf(这是一个空队列!
);
while(Q.front%MAXQSIZE!
=Q.rear)
{
printf(%d-,Q.base[Q.front]);
Q.front++;
}
returnOK;
}
数据构造试验报告2
一.试验内容:
实现哈夫曼编码的生成算法。
二.试验目的:
1、使学生娴熟控制哈夫曼树的生成算法。
2、娴熟控制哈夫曼编码的办法。
三.问题描述:
已知n个字符在原文中浮现的频率,求它们的哈夫曼编码。
1、读入n个字符,以及字符的权值,试建设一棵Huffman树。
2、按照生成的Huffman树,求每个字符的Huffman编码。
并对给定的待编码字符序列进行编码,并输出。
四.问题的实现
(1)郝夫曼树的存储表示
typedefstruct{
unsignedintweight;
unsignedintparent,lchild,rchild;
}HTNode,*HuffmanTree;//动态分配数组存储郝夫曼树
郝夫曼编码的存储表示
typedefchar**HuffmanCode;//动态分配数组存储郝夫曼编码
(2)主要的实现思路:
a.首先定义郝夫曼树的存储形式,这里使用了数组
b.用select遍历n个字符,找出权值最小的两个
c.结构郝夫曼树HT,并求出n个字符的郝夫曼编码HC
总结
1.根本上没有什么太大的问题,在调用select这个函数时,想把权值最小的两个结点的序号带回HuffmanCoding,所以把那2个序号设置成了引用。
2.在编程过程中,在什么时候分配内存,什么时候初始化花的时间比拟长
3.最后根本上实现后,发觉结果仍然存在问题,经过分步调试,发觉了特殊低级的输入错误。
把HT[i].weight=HT[s1].weight+HT[s2].weight;中的s2写成了i
附:
//动态分配数组存储郝夫曼树
typedefstruct{
intweight;//字符的权值
intparent,lchild,rchild;
}HTNode,*HuffmanTree;
//动态分配数组存储郝夫曼编码
typedefchar**HuffmanCode;
//挑选n个(这里是k=n)节点中权值最小的两个结点
voidSelect(HuffmanTreeHT,intk,ints1,ints2)
{inti;
i=1;
while(i=kHT[i].parent!
=0)i++;
//下面选出权值最小的结点,用s1指向其序号
s1=i;
for(i=1;i=k;i++)
{
if(HT[i].parent==0HT[i].weight
}
//下面选出权值次小的结点,用s2指向其序号
for(i=1;i=k;i++)
{
if(HT[i].parent==0i!
=s1)break;
}
s2=i;
for(i=1;i=k;i++)
{
if(HT[i].parent==0i!
=s1HT[i].weight
}
}
//结构Huffman树,求出n个字符的编码
voidHuffmanCoding(HuffmanTreeHT,HuffmanCodeHC,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的号单元也没有值,所以从号单元开场
for(i=1;i=n;i++,p++,w++)
{
p-weight=*w;
p-parent=p-rchild=p-lchild=0;
}
for(;i=m;++i,++p)
{
p-weight=p-parent=p-rchild=p-lchild=0;
}
for(i=n+1;i=m;i++)
{
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]=\0;//编码完结符
for(i=1;i=n;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=;
cinn;
w=(int*)malloc((n+1)*sizeof(int));//记录权值,号单元未用
ch=(char*)malloc((n+1)*sizeof(char));//记录字符,号单元未用
cout依次输入待编码的字符data及其权值weight
for(i=1;i=n;i++)
{
coutdata[
}