数据结构实验报告.docx

数据结构实验报告.docx

《数据结构实验报告.docx》由会员分享，可在线阅读，更多相关《数据结构实验报告.docx（14页珍藏版）》请在冰豆网上搜索。

数据结构实验报告

数据结构实验报告

　　想必学计算机专业的同学都知道数据构造是一门比拟重要的课程，则，下面是我给大家收拾收集的数据构造试验报告，供大家阅读参考。

数据构造试验报告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[

　　}