【第1篇】數(shù)據(jù)結(jié)構(gòu)實(shí)驗(yàn)報告怎么寫900字
數(shù)據(jù)結(jié)構(gòu)實(shí)驗(yàn)報告
數(shù)據(jù)結(jié)構(gòu)實(shí)驗(yàn)報告1
一.實(shí)驗(yàn)內(nèi)容：
實(shí)現(xiàn)哈夫曼編碼的生成算法。
二.實(shí)驗(yàn)?zāi)康模?/p>
1、使學(xué)生熟練掌握哈夫曼樹的生成算法。
2、熟練掌握哈夫曼編碼的方法。
三.問題描述：
已知n個字符在原文中出現(xiàn)的頻率，求它們的哈夫曼編碼。
1、讀入n個字符，以及字符的權(quán)值，試建立一棵huffman樹。
2、根據(jù)生成的huffman樹，求每個字符的huffman編碼。并對給定的待編碼字符序列進(jìn)行編碼，并輸出。
四.問題的實(shí)現(xiàn)
(1)郝夫曼樹的存儲表示
typedef struct{
unsigned int weight;
unsigned int parent，lchild，rchild;
}htnode，*huffmantree; //動態(tài)分配數(shù)組存儲郝夫曼樹
郝夫曼編碼的存儲表示
typedef char* *huffmancode;//動態(tài)分配數(shù)組存儲郝夫曼編碼
(2)主要的實(shí)現(xiàn)思路：
a.首先定義郝夫曼樹的存儲形式，這里使用了數(shù)組
b.用select遍歷n個字符，找出權(quán)值最小的兩個
c.構(gòu)造郝夫曼樹ht，并求出n個字符的郝夫曼編碼hc
總結(jié)
1.基本上沒有什么太大的問題，在調(diào)用select這個函數(shù)時，想把權(quán)值最小的兩個結(jié)點(diǎn)的序號帶回huffmancoding，所以把那2個序號設(shè)置成了引用。
2.在編程過程中，在什么時候分配內(nèi)存，什么時候初始化花的時間比較長
3.最后基本上實(shí)現(xiàn)后，發(fā)現(xiàn)結(jié)果仍然存在問題，經(jīng)過分步調(diào)試，發(fā)現(xiàn)了特別低級的輸入錯誤。把ht[i].weight=ht[s1].weight ht[s2].weight;中的s2寫成了i
附：
//動態(tài)分配數(shù)組存儲郝夫曼樹
typedef struct{
int weight; //字符的.權(quán)值
int parent，lchild，rchild;
}htnode，*huffmantree;
//動態(tài)分配數(shù)組存儲郝夫曼編碼
typedef char* *huffmancode;
//選擇n個(這里是k=n)節(jié)點(diǎn)中權(quán)值最小的兩個結(jié)點(diǎn)
void select(huffmantree &ht，int k，int &s1，int &s2)
{ int i;
i=1;
while(i<=k && ht[i].parent！=0)i ;
//下面選出權(quán)值最小的結(jié)點(diǎn)，用s1指向其序號
s1=i;
for(i=1;i<=k;i )
{
if(ht[i].parent==0&&ht[i].weight
}
//下面選出權(quán)值次小的結(jié)點(diǎn)，用s2指向其序號
for(i=1;i<=k;i )
{
if(ht[i].parent==0&&i！=s1)break;
}
s2=i;
for(i=1;i<=k;i )
{
if(ht[i].parent==0&&i！=s1&&ht[i].weight
}
}
//構(gòu)造huffman樹，求出n個字符的編碼
void huffmancoding(huffmantree &ht，huffmancode &hc，int *w，int n)
{
int m，c，f，s1，s2，i，start;
char *cd;
if(n<=1)return;
m=2*n-1; //n個葉子n-1個結(jié)點(diǎn)
ht=(huffmantree)malloc((m 1)*sizeof(htnode)); //0號單元未用，預(yù)分配m 1個單元
huffmantree p=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); //選出當(dāng)前權(quán)值最小的
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]='';//編碼結(jié)束符
for(i=1;i<=n;i ) //逐個字符求郝夫曼編碼
{
start=n-1; //編碼結(jié)束符位置
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復(fù)制編碼到hc
}
free(cd); //釋放工作空間
}
void main
{ int n，i;
int* w; //記錄權(quán)值
char* ch; //記錄字符
huffmantree ht;
huffmancode hc;
cout<<'請輸入待編碼的字符個數(shù)n=';
cin>>n;
w=(int*)malloc((n 1)*sizeof(int)); //記錄權(quán)值，號單元未用
ch=(char*)malloc((n 1)*sizeof(char));//記錄字符，號單元未用
cout<<'依次輸入待編碼的字符data及其權(quán)值weight'<
for(i=1;i<=n;i )
{
cout<<'data['<
}
數(shù)據(jù)結(jié)構(gòu)實(shí)驗(yàn)報告2
一、實(shí)驗(yàn)?zāi)康募耙?/p>
1)掌握棧和隊(duì)列這兩種特殊的線性表，熟悉它們的特性，在實(shí)際問題背景下靈活運(yùn)用它們。
本實(shí)驗(yàn)訓(xùn)練的要點(diǎn)是“棧”和“隊(duì)列”的觀點(diǎn);
二、實(shí)驗(yàn)內(nèi)容
1) 利用棧，實(shí)現(xiàn)數(shù)制轉(zhuǎn)換。
2) 利用棧，實(shí)現(xiàn)任一個表達(dá)式中的語法檢查(選做)。
3) 編程實(shí)現(xiàn)隊(duì)列在兩種存儲結(jié)構(gòu)中的基本操作(隊(duì)列的初始化、判隊(duì)列空、入隊(duì)列、出隊(duì)列);
三、實(shí)驗(yàn)流程、操作步驟或核心代碼、算法片段
順序棧：
status initstack(sqstack &s)
{
s.base=(elemtype*)malloc(stack_init_size*sizeof(elemtype));
if(！s.base)
return error;
s.top=s.base;
s.stacksize=stack_init_size;
return ok;
}
status destorystack(sqstack &s)
{
free(s.base);
return ok;
}
status clearstack(sqstack &s)
{
s.top=s.base;
return ok;
}
status stackempty(sqstack s)
{
if(s.base==s.top)
return ok;
return error;
}
int stacklength(sqstack s)
{
return s.top-s.base;
}
status gettop(sqstack s，elemtype &e)
{
if(s.top-s.base>=s.stacksize)
{
s.base=(elemtype *)realloc(s.base，(s.stacksize stackincrement)*sizeof(elemtype));
if(！s.base) return error;
s.top=s.base s.stacksize;
s.stacksize =stackincrement;
}
*s.top =e;
return ok;
}
status push(sqstack &s，elemtype e)
{
if(s.top-s.base>=s.stacksize)
{
s.base=(elemtype *)realloc(s.base，(s.stacksize stackincrement)*sizeof(elemtype));
if(！s.base)
return error;
s.top=s.base s.stacksize;
s.stacksize =stackincrement;
}
*s.top =e;
return ok;
}
status pop(sqstack &s，elemtype &e)
{
if(s.top==s.base)
return error;
e=*--s.top;
return ok;
}
status stacktraverse(sqstack s)
{
elemtype *p;
p=(elemtype *)malloc(sizeof(elemtype));
if(！p) return error;
p=s.top;
while(p！=s.base)//s.top上面一個...
{
p--;
printf('%d '，*p);
}
return ok;
}
status compare(sqstack &s)
{
int flag，ture=ok，false=error;
elemtype e，x;
initstack(s);
flag=ok;
printf('請輸入要進(jìn)?；虺鰲５脑兀?);
while((x= getchar)！='#'&&flag)
{
switch (x)
{
case '(':
case '[':
case '{':
if(push(s，x)==ok)
printf('括號匹配成功！ ');
break;
case ')':
if(pop(s，e)==error || e！='(')
{
printf('沒有滿足條件 ');
flag=false;
}
break;
case ']':
if ( pop(s，e)==error || e！='[')
flag=false;
break;
case '}':
if ( pop(s，e)==error || e！='{')
flag=false;
break;
}
}
if (flag && x=='#' && stackempty(s))
return ok;
else
return error;
}
鏈隊(duì)列：
status initqueue(linkqueue &q)
{
q.front =q.rear=
(queueptr)malloc(sizeof(qnode));
if (！q.front) return error;
q.front->next = null;
return ok;
}
status destoryqueue(linkqueue &q)
{
while(q.front)
{
q.rear=q.front->next;
free(q.front);
q.front=q.rear;
}
return ok;
}
status queueempty(linkqueue &q)
{
if(q.front->next==null)
return ok;
return error;
}
status queuelength(linkqueue q)
{
int i=0;
queueptr p，q;
p=q.front;
while(p->next)
{
i ;
p=q.front;
q=p->next;
p=q;
}
return i;
}
status gethead(linkqueue q，elemtype &e)
{
queueptr p;
p=q.front->next;
if(！p)
return error;
e=p->data;
return e;
}
status clearqueue(linkqueue &q)
{
queueptr p;
while(q.front->next )
{
p=q.front->next;
free(q.front);
q.front=p;
}
q.front->next=null;
q.rear->next=null;
return ok;
}
status enqueue(linkqueue &q，elemtype e)
{
queueptr p;
p=(queueptr)malloc(sizeof (qnode));
if(！p)
return error;
p->data=e;
p->next=null;
q.rear->next = p;
q.rear=p; //p->next 為空
return ok;
}
status dequeue(linkqueue &q，elemtype &e)
{
queueptr p;
if (q.front == q.rear)
return error;
p = q.front->next;
e = p->data;
q.front->next = p->next;
if (q.rear == p)
q.rear = q.front; //只有一個元素時(不存在指向尾指針)
free (p);
return ok;
}
status queuetraverse(linkqueue q)
{
queueptr p，q;
if( queueempty(q)==ok)
{
printf('這是一個空隊(duì)列！ ');
return error;
}
p=q.front->next;
while(p)
{
q=p;
printf('%d<- '，q->data);
q=p->next;
p=q;
}
return ok;
}
循環(huán)隊(duì)列：
status initqueue(sqqueue &q)
{
q.base=(qelemtype*)malloc(maxqsize*sizeof(qelemtype));
if(！q.base)
exit(owerflow);
q.front=q.rear=0;
return ok;
}
status enqueue(sqqueue &q，qelemtype e)
{
if((q.rear 1)%maxqsize==q.front)
return error;
q.base[q.rear]=e;
q.rear=(q.rear 1)%maxqsize;
return ok;
}
status dequeue(sqqueue &q，qelemtype &e)
{
if(q.front==q.rear)
return error;
e=q.base[q.front];
q.front=(q.front 1)%maxqsize;
return ok;
}
int queuelength(sqqueue q)
{
return(q.rear-q.front maxqsize)%maxqsize;
}
status destoryqueue(sqqueue &q)
{
free(q.base);
return ok;
}
status queueempty(sqqueue q) //判空
{
if(q.front ==q.rear)
return ok;
return error;
}
status queuetraverse(sqqueue q)
{
if(q.front==q.rear)
printf('這是一個空隊(duì)列！');
while(q.front%maxqsize！=q.rear)
{
printf('%d<- '，q.base[q.front]);
q.front ;
}
return ok;
}
數(shù)據(jù)結(jié)構(gòu)實(shí)驗(yàn)報告3
《數(shù)據(jù)結(jié)構(gòu)與算法》實(shí)驗(yàn)報告
專業(yè) 班級 姓名 學(xué)號
實(shí)驗(yàn)項(xiàng)目
實(shí)驗(yàn)一 二叉樹的應(yīng)用
實(shí)驗(yàn)?zāi)康?/p>
1、進(jìn)一步掌握指針變量的含義及應(yīng)用。
2、掌握二叉樹的結(jié)構(gòu)特征，以及各種存儲結(jié)構(gòu)的特點(diǎn)及使用范圍。
3、掌握用指針類型描述、訪問和處理二叉樹的運(yùn)算。
實(shí)驗(yàn)內(nèi)容
題目1:編寫一個程序，采用一棵二叉樹表示一個家譜關(guān)系。要求程序具有如下功能：
（1）用括號表示法輸出家譜二叉樹，
（2）查找某人的所有兒子，
（3）查找某人的所有祖先。
算法設(shè)計(jì)分析
（一）數(shù)據(jù)結(jié)構(gòu)的定義
為了能夠用二叉樹表示配偶、子女、兄弟三種關(guān)系，特采用以下存儲關(guān)系，則能在二叉樹上實(shí)現(xiàn)家譜的各項(xiàng)運(yùn)算。
二叉樹型存儲結(jié)構(gòu)定義為：
typedef struct snode
{char name[max]; //人名
struct snode *left;//指向配偶結(jié)點(diǎn)
struct snode *right; //指向兄弟或子女結(jié)點(diǎn)
}fnode;
（二）總體設(shè)計(jì)
實(shí)驗(yàn)由主函數(shù)、家譜建立函數(shù)、家譜輸出函數(shù)、兒子查找函數(shù)、祖先查找函數(shù)、結(jié)點(diǎn)定位函數(shù)、選擇界面函數(shù)七個函數(shù)共同組成。其功能描述如下：
（1）主函數(shù)：統(tǒng)籌調(diào)用各個函數(shù)以實(shí)現(xiàn)相應(yīng)功能
void main
（2）家譜建立函數(shù)：與用戶交互建立家族成員對應(yīng)關(guān)系
void initialfamily(fnode *&head) //家譜建立函數(shù)
（3）家譜輸出函數(shù)：用括號表示法輸出家譜
輸出形式為：父和母（子1和子妻1（孫1），子2和子妻2（孫2））
void printfamily(fnode *head) //家譜輸出函數(shù)
（4）兒子查找函數(shù)：在家譜中查找到某人所有的子女并輸出，同時也能辨別出其是否為家族成員與是否有子女
void findson(fnode *b，char p[]) //兒子查找函數(shù)
（5）祖先查找函數(shù)：在家譜中查找到某人所有的祖先并輸出，同時也能辨別出其是否為家族中成員。
int findancestor(fnode *head，char son[ ]) //祖先查找函數(shù)
（6）結(jié)點(diǎn)定位函數(shù)：在家譜中找到用戶輸入人名所對應(yīng)的結(jié)點(diǎn)。
fnode *findnode(fnode *b，char p[]) //結(jié)點(diǎn)定位函數(shù)
（7）選擇界面函數(shù)：為便于編寫程序，將用戶選擇部分獨(dú)立為此函數(shù)。
void print(int &n)
（三）各函數(shù)的詳細(xì)設(shè)計(jì)：
void initialfamily(fnode *&head) //家譜建立函數(shù)
1：首先建立當(dāng)前人的信息，將其左右結(jié)點(diǎn)置為空，
2：然后讓用戶確定其是否有配偶，如果沒有配偶，則當(dāng)前程序結(jié)束，
3：如果有則建立其配偶信息，并將配偶結(jié)點(diǎn)賦給當(dāng)前人的左結(jié)點(diǎn)；
4：再讓用戶確定其是否有子女，如果有則遞歸調(diào)用家譜建立函數(shù)建立子女結(jié)點(diǎn)，并將其賦給配偶結(jié)點(diǎn)的下一個右結(jié)點(diǎn)。
5：如無，則程序結(jié)束
void printfamily(fnode *head) //家譜輸出函數(shù)
1：首先判斷當(dāng)前結(jié)點(diǎn)是否為空，如果為空則結(jié)束程序；
2：如果不為空，則輸出當(dāng)前結(jié)點(diǎn)信息，
3：然后判斷其左結(jié)點(diǎn)（配偶結(jié)點(diǎn)）是否為空，如不為空則輸出“和配偶信息。
4：再判斷配偶結(jié)點(diǎn)的右結(jié)點(diǎn)是否為空，如不為空則遞歸調(diào)用輸出其子女信息，最后輸出“）”；
5：當(dāng)配偶結(jié)點(diǎn)為空時，則判斷其右結(jié)點(diǎn)（兄弟結(jié)點(diǎn)）是否為空
6：如果不為空，則輸出“，”，并遞歸調(diào)用輸出兄弟信息
7程序結(jié)束
fnode *findnode(fnode *b，char p[]) //結(jié)點(diǎn)定位函數(shù)
1：當(dāng)前結(jié)點(diǎn)是否為空，為空則返回空；
2：如果和查找信息相同，則返回當(dāng)前結(jié)點(diǎn)；
3：如不然，則先后遞歸訪問其左結(jié)點(diǎn)，再不是則遞歸訪問右結(jié)點(diǎn)
void findson(fnode *b，char p[]) //兒子查找函數(shù)
1：在家譜中定位到要查找的結(jié)點(diǎn)，如無則輸出“查找不到此人”
2：判斷其配偶結(jié)點(diǎn)與子女結(jié)點(diǎn)是否為空，為空則輸出“無子女”
3：不為空則輸出其配偶結(jié)點(diǎn)的所有右結(jié)點(diǎn)（子女結(jié)點(diǎn)）。
int findancestor(fnode *head，char son[ ]) //祖先查找函數(shù)
1：先在家譜中定位到要查找的結(jié)點(diǎn)，如為空輸出“不存在此人”，程序結(jié)束
2：先將父母結(jié)點(diǎn)入棧，當(dāng)棧為空時程序結(jié)束，
3：棧不為空時，判斷棧頂元素是否已訪問過，
4：訪問過，再判斷是否為查找結(jié)點(diǎn)，如是則輸出棧中保存的其祖先結(jié)點(diǎn)，并濾過其兄弟結(jié)點(diǎn)不輸出；不是查找結(jié)點(diǎn)，則退棧一個元素
5：未訪問過，則取當(dāng)前棧頂元素，置訪問標(biāo)志——1，同時取其右結(jié)點(diǎn)
6：棧不為空或當(dāng)前所取結(jié)點(diǎn)不為空時，轉(zhuǎn)到2；
實(shí)驗(yàn)測試結(jié)果及結(jié)果分析
（一）測試結(jié)果
（二）結(jié)果分析
（略）
實(shí)驗(yàn)總結(jié)
（略）
數(shù)據(jù)結(jié)構(gòu)實(shí)驗(yàn)報告
精選寫報告經(jīng)驗(yàn)37人覺得有用
寫一份好的數(shù)據(jù)結(jié)構(gòu)實(shí)驗(yàn)報告并不難，但得花點(diǎn)心思。開頭部分得先把實(shí)驗(yàn)?zāi)康膶懬宄瑒e含糊其辭，不然老師看了可能覺得你沒搞明白。比如實(shí)驗(yàn)是要驗(yàn)證某個算法的時間復(fù)雜度還是空間復(fù)雜度，或者是想對比兩種算法的性能，都得交代明白。
接下來就是實(shí)驗(yàn)環(huán)境了，這部分得把軟硬件條件寫全，包括操作系統(tǒng)版本、編程語言、編譯器之類的東西。要是省略了這一步，可能會讓讀者摸不著頭腦。記得把實(shí)驗(yàn)的具體步驟也寫出來，一步一步來，這樣別人也能跟著你的思路走一遍。
數(shù)據(jù)記錄這一塊尤其重要，所有的實(shí)驗(yàn)結(jié)果都要如實(shí)記錄下來。表格、圖表什么的最好都用上，這樣直觀。不過有時候數(shù)據(jù)會有些波動，這是正常的，不用太糾結(jié)。要是發(fā)現(xiàn)數(shù)據(jù)偏差太大，就該檢查一下是不是實(shí)驗(yàn)過程中出了問題。
分析結(jié)果的時候要結(jié)合理論知識，看看實(shí)驗(yàn)結(jié)果符不符合預(yù)期。如果發(fā)現(xiàn)不符，就得好好想想原因，可能是理論有漏洞，也可能是實(shí)驗(yàn)設(shè)計(jì)有問題。這個環(huán)節(jié)寫的時候要有點(diǎn)深度，不能只是簡單地羅列數(shù)據(jù)。
最后就是結(jié)論部分了，得明確回答實(shí)驗(yàn)的目的是否達(dá)到了。有時候結(jié)論可能不是非黑即白的，這時候可以提出一些開放性的問題，引導(dǎo)讀者去思考。當(dāng)然啦，寫報告的時候難免會有一些疏漏，只要不影響整體理解就行。
【第2篇】北郵數(shù)據(jù)結(jié)構(gòu)實(shí)驗(yàn)報告線性表怎么寫1050字
北郵數(shù)據(jù)結(jié)構(gòu)實(shí)驗(yàn)報告線性表
實(shí)驗(yàn)報告;課程名稱：數(shù)據(jù)結(jié)構(gòu)班級：軟件工程實(shí)驗(yàn)成績：;1206;實(shí)驗(yàn)名稱：打印機(jī)隊(duì)列模擬學(xué)號：20124848批;程序的設(shè)計(jì);實(shí)驗(yàn)編號：實(shí)驗(yàn)一姓名：實(shí)驗(yàn)日期：2025年5月2;一、實(shí)驗(yàn)?zāi)康?對隊(duì)列的理解;對stl中的queue的使用;實(shí)驗(yàn)仿真一個網(wǎng)絡(luò)打印過程;二、實(shí)驗(yàn)內(nèi)容與實(shí)驗(yàn)步驟流程圖;這個任務(wù)隊(duì)列的測試使用stl隊(duì)列適配器;具體地說，每一行中包含的信息是
實(shí) 驗(yàn) 報 告
課程名稱：數(shù)據(jù)結(jié)構(gòu) 班級：軟件工程實(shí)驗(yàn)成績：
1206
實(shí)驗(yàn)名稱：打印機(jī)隊(duì)列模擬學(xué)號：20124848 批閱教師簽字：
程序的設(shè)計(jì)
實(shí)驗(yàn)編號：實(shí)驗(yàn)一 姓名： 實(shí)驗(yàn)日期：2025年5 月 24 日
一、實(shí)驗(yàn)?zāi)康?/p>
對隊(duì)列的理解
對stl中的queue的使用
實(shí)驗(yàn)仿真一個網(wǎng)絡(luò)打印過程
二、實(shí)驗(yàn)內(nèi)容與實(shí)驗(yàn)步驟流程圖
這個任務(wù)隊(duì)列的測試使用stl隊(duì)列適配器。程序要求完成模擬的實(shí)現(xiàn)共享打印機(jī)。這個打印機(jī)使用先進(jìn)先出隊(duì)列。仿真是通過讀取和處理事件數(shù)據(jù)文件的列表。一個有效的數(shù)據(jù)文件中的每一行包含信息打印作業(yè)和提交這份工作的時間。
具體地說，每一行中包含的信息是提交工作的時間(以秒為單位)，和在頁面的工作長及工作的計(jì)算機(jī)的名稱。在模擬的開始，每個這些事件的每一個應(yīng)該被程序所讀，存儲在繼承工作負(fù)載隊(duì)列。程序應(yīng)該通過循環(huán)遞增計(jì)數(shù)器或while-loop模擬時間的流逝。程序應(yīng)該將計(jì)數(shù)器初始化為零，然后依次增加1秒。當(dāng)模擬等于當(dāng)前時間的打印作業(yè)的提交時間在工作隊(duì)列的前面，一個打印作業(yè)完成。當(dāng)這一切發(fā)生的時候，從工作隊(duì)列取出這個事件，然后把它放在另一個隊(duì)列對象。這個隊(duì)列對象存儲已完成的打印作業(yè)。當(dāng)程序仿真其他的打印工作的時候，這些工作在隊(duì)列等待。
win8，visual c 6.0
四、實(shí)驗(yàn)過程與分析
(1)實(shí)驗(yàn)主要函數(shù)及存儲結(jié)構(gòu)
main.cpp 包括主函數(shù)和主要的功能
simulator.h 仿真類的聲明
simulator.cpp 仿真類的定義
event.h 事件類的聲明
event.cpp - 事件類的定義
job.h 作業(yè)類的聲明
job.cpp 作業(yè)類的.定義
arbitrary.run 包括任意打印作業(yè)數(shù)的數(shù)據(jù)文件
arbitrary.out 輸出 arbitrary.run
bigfirst.run 包括打印較大作業(yè)的數(shù)據(jù)文件
bigfirst.out 輸出 bigfirst.run
(2)實(shí)驗(yàn)代碼
#ifndef fifo_h //fifo.h
#define fifo_h
#include 'simulator.h'
class fifo:public simulator{
protected:
queue waiting;
priority_queue priority_waiting;
public:
fifo(int seconds_per_page);
void simulate(string file);
};
bool operator < (event evtleft，event evtright);
#endif
#include 'fifo.h' //fifo.cpp
#include
using namespace std;
fifo::fifo(int seconds_per_page):simulator(seconds_per_page){ }
void fifo::simulate(string file){
int finish_time = 0;
float agg_latency = 0;
int totaljob =0;
event evt;
if(file.find('arbitrary')！= string::npos){
string outfile ='arbitrary.out';
ofstream osf(outfile.c_str);
loadworkload(file);
osf<<'fifo simulation '<
for(int time =1;！waiting.empty||！workload.empty;time ){ while(！workload.empty && time ==
workload.front.arrival_time){
evt= workload.front;
osf<<' arriving: '<
workload.pop;
}
if(！waiting.empty && time >;= finish_time){
totaljob ;
evt = waiting.front;
agg_latency = time - evt.arrival_time;
osf<<' servicing: '<
finish_time = time evt.getjob.getnumpages * seconds_per_page;
}
}
osf<<' total job '<
osf<<' aggregate latency: '<
osf<<' mean latency : '<
return;
}
if(file.find('bigfirst') ！= string::npos){
string outfile = 'bigfirst.out';
ofstream osf(outfile.c_str);
loadworkload(file);
osf<<'fifo simulation '<
for(int time
=1;！priority_waiting.empty||！workload.empty;time ){
while(！workload.empty && time ==
workload.front.arrival_time){
evt= workload.front;
osf<<' arriving: '<
workload.pop;
}
if(！priority_waiting.empty && time >;= finish_time){
totaljob ;
evt = priority_waiting.top;
agg_latency = time - evt.arrival_time;
osf<<' servicing: '<
finish_time = time evt.getjob.getnumpages * seconds_per_page; }
}
osf<<' total job '<
osf<<' aggregate latency: '<
osf<<' mean latency : '<
return;
}
cerr<<'the program don't know what algorithm to use'<
cerr<<'you should specify the file name with arbitrary or bigfirst'<
bool operator < (event evtleft，event evtright){
return evtleft.getjob.getnumpages <
evtright.getjob.getnumpages;
}
五、實(shí)驗(yàn)結(jié)果總結(jié)
經(jīng)測試，功能較為完整。代碼流程簡圖如下：
通過這次實(shí)驗(yàn)，我了解了有關(guān)隊(duì)列方面的知識。掌握了隊(duì)列的邏輯結(jié)構(gòu)，抽象數(shù)據(jù)類型，隊(duì)列的存儲方式等。運(yùn)用先進(jìn)先出表，仿真了網(wǎng)絡(luò)打印隊(duì)列。這都使我對數(shù)據(jù)結(jié)構(gòu)的學(xué)習(xí)有了新的認(rèn)識與幫助。在實(shí)驗(yàn)過程中，我也遇到了許多困難，從開始時對隊(duì)列運(yùn)算的不熟悉，到逐漸查找資料，從而完成了實(shí)驗(yàn);六、附錄;-《數(shù)據(jù)結(jié)構(gòu)與算法分析》以及網(wǎng)上資料;
逐漸查找資料，從而完成了實(shí)驗(yàn)。在今后的學(xué)習(xí)中，我將繼續(xù)努力，加強(qiáng)對堆棧，隊(duì)列等知識的學(xué)習(xí)，以達(dá)到精益求精。
六、附錄
-《數(shù)據(jù)結(jié)構(gòu)與算法分析》以及網(wǎng)上資料
精選寫報告經(jīng)驗(yàn)92人覺得有用
做實(shí)驗(yàn)報告這件事，很多人覺得挺麻煩的，尤其是像北郵這種學(xué)校的數(shù)據(jù)結(jié)構(gòu)實(shí)驗(yàn)報告，線性表這部分更是得花點(diǎn)心思。線性表說白了就是一串有序的數(shù)據(jù)，比如數(shù)組啦、鏈表啦，這些東西你得清楚它們的原理，不然寫報告的時候就容易亂。
先說說開頭，別上來就直接抄題目，得稍微有點(diǎn)自己的理解。你可以先把實(shí)驗(yàn)的目的寫一下，比如這次實(shí)驗(yàn)主要是想讓大家熟悉線性表的基本操作，像插入、刪除什么的。不過這里有個小問題，有時候大家會把目的寫得太寬泛，像是“通過本次實(shí)驗(yàn)掌握線性表”，這樣的話老師看了可能覺得你沒用心。建議把具體的技能點(diǎn)列出來，這樣顯得更實(shí)在。
接著就是實(shí)驗(yàn)內(nèi)容了。這部分一定要詳細(xì)，不能只寫個大概。比如說你要實(shí)現(xiàn)一個鏈表的增刪改查功能，就得把每一步都描述清楚。記得帶上偽代碼或者流程圖，這樣能讓報告看起來更有技術(shù)含量。不過有時候人們會忘記標(biāo)注變量名或者函數(shù)名的具體含義，這就容易讓人看不懂。我以前看同學(xué)的報告就遇到過這種情況，比如某個變量突然冒出來，名字又起得模棱兩可，這肯定不行。
然后就是結(jié)果分析了。這一塊兒特別重要，得把你運(yùn)行程序得到的結(jié)果好好解釋一番。如果發(fā)現(xiàn)結(jié)果跟預(yù)期不符，也得說明原因，可能是算法有問題，也可能是代碼細(xì)節(jié)沒處理好。這里有個小毛病，有些同學(xué)喜歡直接復(fù)制粘貼程序輸出，但沒有深入分析，這就顯得很表面。你應(yīng)該結(jié)合理論去討論為什么會出現(xiàn)這樣的結(jié)果。
最后就是總結(jié)部分了?？偨Y(jié)不是簡單地復(fù)述前面的內(nèi)容，而是要提煉出關(guān)鍵點(diǎn)。你可以談?wù)勥@次實(shí)驗(yàn)給你帶來了什么啟發(fā)，或者你覺得哪些地方還可以改進(jìn)。當(dāng)然，有時候人們會在這部分寫得過于籠統(tǒng)，比如“收獲很大”，這樣的話顯得太敷衍。最好能具體點(diǎn)，比如“學(xué)會了如何優(yōu)化鏈表的操作效率”。
【第3篇】c數(shù)據(jù)結(jié)構(gòu)實(shí)驗(yàn)報告怎么寫4350字
c數(shù)據(jù)結(jié)構(gòu)實(shí)驗(yàn)報告
數(shù)據(jù)結(jié)構(gòu)(c語言版)實(shí)驗(yàn)報告;專業(yè)：計(jì)算機(jī)科學(xué)與技術(shù)、軟件工程;學(xué)號:____201240703061_____;班級:_________軟件二班________;姓名:________朱海霞__________;指導(dǎo)教師:___劉遵仁_____________;青島大學(xué)信息工程學(xué)院;2025年10月;實(shí)驗(yàn)1;實(shí)驗(yàn)題目：順序存儲結(jié)構(gòu)線性表的插入和刪除;實(shí)驗(yàn)?zāi)?/p>
數(shù)據(jù)結(jié)構(gòu)(c語言版) 實(shí)驗(yàn)報告
專業(yè)：計(jì)算機(jī)科學(xué)與技術(shù)、軟件工程
學(xué)號:____201240703061___________________
班級:_________軟件二班______________
姓名:________朱海霞______________
指導(dǎo)教師:___劉遵仁________________
青島大學(xué)信息工程學(xué)院
2025年10月
實(shí)驗(yàn)1
實(shí)驗(yàn)題目：順序存儲結(jié)構(gòu)線性表的插入和刪除
實(shí)驗(yàn)?zāi)康模?/p>
了解和掌握線性表的邏輯結(jié)構(gòu)和順序存儲結(jié)構(gòu)，掌握線性表的基本算法及相關(guān)的時間性能分析。
實(shí)驗(yàn)要求：
建立一個數(shù)據(jù)域定義為整數(shù)類型的線性表，在表中允許有重復(fù)的數(shù)據(jù);根據(jù)輸入的數(shù)據(jù)，先找到相應(yīng)的存儲單元，后刪除之。
實(shí)驗(yàn)主要步驟：
1、分析、理解給出的示例程序。
2、調(diào)試程序，并設(shè)計(jì)輸入一組數(shù)據(jù)(3，-5，6，8，2，-5，4，7，-9)，測試程序的如下功能：根據(jù)輸入的數(shù)據(jù)，找到相應(yīng)的存儲單元并刪除，顯示表中所有的數(shù)據(jù)。
程序代碼:
#include
#include
#define ok 1
#define error 0
#define overflow -2
#define list_init_size 100
#define listincrement 10
typedef struct{
int* elem;
int length;
int listsize;
}sqlist;
int initlist_sq(sqlist &l){
l.elem=(int*)malloc(list_init_size*sizeof(int));
if(！l.elem) return -1;
l.length=0;
l.listsize=list_init_size;
return ok;
}
int listinsert_sq(sqlist&l，int i，int e){
if(i<1||i>;l.length 1) return error;
if(l.length==l.listsize){
int *newbase;
newbase=(int*)realloc(l.elem，(l.listsize listincrement)*sizeof(int));
if(！newbase) return -1;
l.elem=newbase;
l.listsize =listincrement;
}
int *p，*q;
q=&(l.elem[i-1]);
for(p=&(l.elem[l.length-1]);p>;=q;--p)
*(p 1)=*p;
*q=e;
l.length;
return ok;
}
int listdelete_sq(sqlist &l，int i，int e){
int *p，*q;
if(i<1||i>;l.length)return error;
p=&(l.elem[i-1]);
e=*p;
q=l.elem l.length-1;
for( p;p<=q; p)
*(p-1)=*p;
--l.length;
return ok;
}
int main{
sqlist l;
initlist_sq(l);//初始化
int i，a[]={3，-5，6，8，2，-5，4，7，-9};
for(i=1;i<10;i )
listinsert_sq(l，i，a[i-1]);
for(i=0;i<9;i )
printf(' %d'，l.elem[i]);
printf(' ');//插入9個數(shù)
listinsert_sq(l，3，24);
for(i=0;i<10;i )
printf(' %d'，l.elem[i]);
printf(' ');//插入一個數(shù)
int e;
listdelete_sq(l，2， e);
for(i=0;i<9;i )
printf(' %d'，l.elem[i]);//刪除一個數(shù)
printf(' ');
return 0;
}
實(shí)驗(yàn)結(jié)果：
3，-5，6，8，2，-5，4，7，-9
3，-5，24，6，8，2，-5，4，7，-9
3，24，6，8，2，-5，4，7，-9
心得體會：
順序存儲結(jié)構(gòu)是一種隨機(jī)存取結(jié)構(gòu)，存取任何元素的時間是一個常數(shù)，速度快;結(jié)構(gòu)簡單，邏輯上相鄰的元素在物理上也相鄰;不使用指針，節(jié)省存儲空間;但是插入和刪除元素需要移動大量元素，消耗大量時間;需要一個連續(xù)的存儲空間;插入元素可能發(fā)生溢出;自由區(qū)中的存儲空間不能被其他數(shù)據(jù)共享 實(shí)驗(yàn)2
實(shí)驗(yàn)題目：單鏈表的插入和刪除
實(shí)驗(yàn)?zāi)康模?/p>
了解和掌握線性表的邏輯結(jié)構(gòu)和鏈?zhǔn)酱鎯Y(jié)構(gòu)，掌握單鏈表的基本算法及相關(guān)的時間性能分析。
實(shí)驗(yàn)要求：
建立一個數(shù)據(jù)域定義為字符類型的單鏈表，在鏈表中不允許有重復(fù)的字符;根據(jù)輸入的字符，先找到相應(yīng)的結(jié)點(diǎn)，后刪除之。
實(shí)驗(yàn)主要步驟：
3、分析、理解給出的示例程序。
4、調(diào)試程序，并設(shè)計(jì)輸入數(shù)據(jù)(如：a，c，e，f，h，j，q，m)，測試程序的如下功能：不允許重復(fù)字符的插入;根據(jù)輸入的字符，找到相應(yīng)的結(jié)點(diǎn)并刪除。
5、修改程序：
(1) 增加插入結(jié)點(diǎn)的功能。
(2) 建立鏈表的方法有“前插”、“后插”法。
程序代碼:
#include
#include
#define null 0
#define ok 1
#define error 0
typedef struct lnode{
int data;
struct lnode *next;
}lnode，*linklist;
int initlist_l(linklist &l){
l=(linklist)malloc(sizeof(lnode)); l->;next=null;
return ok;
}
int listinsert_l(linklist &l，int i，int e){ linklist p，s;
int j;
p=l;j=0;
while(p&&j
p=p->;next; j;
}
if(！p||j>;i-1)
return error;
s=(linklist)malloc(sizeof(lnode)); s->;data=e;
s->;next=p->;next;
p->;next=s;
return ok;
}
int listdelete_l(linklist&l，int i，int &e){ linklist p，q;
int j;
p=l;j=0;
while(p->;next&&j
p=p->;next; j;
}
if(！(p->;next)||j
return error;
q=p->;next;p->;next=q->;next; e=q->;data;free(q);
return ok;
}
int main{
linklist l，p;
char a[8]={'a'，'c'，'e'，'f'，'h'，'j'，'q'，'u'}; int i，j;
initlist_l(l);
for(i=1，j=0;i<=8，j<8;i ，j ) listinsert_l(l，i，a[j]);
p=l->;next;
while(p！=null){
printf('%c '，p->;data); p=p->;next;
}//插入八個字符printf(' ;實(shí)驗(yàn)結(jié)果：;acefhjqu;abcefhjqu;abefhjqu;心得體會：;單鏈表是通過掃描指針p進(jìn)行單鏈表的操作;頭指針唯;實(shí)驗(yàn)3;實(shí)驗(yàn)題目：棧操作設(shè)計(jì)和實(shí)現(xiàn);實(shí)驗(yàn)?zāi)康模?1、掌握棧的順序存儲結(jié)構(gòu)和鏈?zhǔn)酱鎯Y(jié)構(gòu)，以便在實(shí);2、掌握棧的特點(diǎn)，即后進(jìn)先出和先進(jìn)先出的原則;3、掌握棧的'基本運(yùn)算，如：入棧與出棧
}
}//插入八個字符 printf(' '); i=2; int e; listinsert_l(l，i，'b'); p=l->;next; while(p！=null){ printf('%c '，p->;data); p=p->;next; }//插入一個字符 printf(' '); i=3; listdelete_l(l，i，e); p=l->;next; while(p！=null){ printf('%c '，p->;data); p=p->;next; } printf(' '); return 0;
實(shí)驗(yàn)結(jié)果：
a c e f h j q u
a b c e f h j q u
a b e f h j q u
心得體會：
單鏈表是通過掃描指針p進(jìn)行單鏈表的操作;頭指針唯一標(biāo)識點(diǎn)鏈表的存在;插入和刪除元素快捷，方便。
實(shí)驗(yàn)3
實(shí)驗(yàn)題目：棧操作設(shè)計(jì)和實(shí)現(xiàn)
實(shí)驗(yàn)?zāi)康模?/p>
1、掌握棧的順序存儲結(jié)構(gòu)和鏈?zhǔn)酱鎯Y(jié)構(gòu)，以便在實(shí)際中靈活應(yīng)用。
2、掌握棧的特點(diǎn)，即后進(jìn)先出和先進(jìn)先出的原則。
3、掌握棧的基本運(yùn)算，如：入棧與出棧等運(yùn)算在順序存儲結(jié)構(gòu)和鏈?zhǔn)酱鎯Y(jié)構(gòu)上的實(shí)現(xiàn)。
實(shí)驗(yàn)要求：
回文判斷：對于一個從鍵盤輸入的字符串，判斷其是否為回文。回文即正反序相同。如
“abba”是回文，而“abab”不是回文。
實(shí)驗(yàn)主要步驟
(1)數(shù)據(jù)從鍵盤讀入;
(2)輸出要判斷的字符串;
(3)利用棧的基本操作對給定的字符串判斷其是否是回文，若是則輸出“yes”，否則輸出“no”。
程序代碼:
#include
#include
#define true 1
#define false 0
#define ok 1
#define error 0
#define overflow -2
#define n 100
#define stack_init_size 100
#define stackincrement 10
typedef struct{
int *base; // 在棧構(gòu)造之前和銷毀之后，base的值為null int *top; // 棧頂指針
int stacksize; // 當(dāng)前已分配的存儲空間，以元素為單位
} sqstack;
int initstack(sqstack &s)
{ // 構(gòu)造一個空棧s
if(！(s.base=(int *)malloc(stack_init_size*sizeof(int))))
exit(overflow); // 存儲分配失敗
s.top=s.base;
s.stacksize=stack_init_size;
return ok;
}
int stackempty(sqstack s)
{ // 若棧s為空棧，則返回true，否則返回false
if(s.top==s.base)
return true;
else
return false;
}
int push(sqstack &s， int e)
{ // 插入元素e為新的棧頂元素
if(s.top-s.base>;=s.stacksize) // 棧滿，追加存儲空間
{
s.base=(int *)realloc(s.base，(s.stacksize stackincrement)*sizeof(int)); if(！s.base)
exit(overflow); // 存儲分配失敗
s.top=s.base s.stacksize;
s.stacksize =stackincrement;
}
*(s.top) =e;
return ok;
}
int pop(sqstack &s，int &e)
{ // 若棧不空，則刪除s的棧頂元素，用e返回其值，并返回ok;否則返回error if(s.top==s.base)
return error;
e=*--s.top;
return ok;
}
int main{
sqstack s;
int i，e，j，k=1;
char ch[n] = {0}，*p，b[n] = {0};
if(initstack(s)) // 初始化棧成功
{
printf('請輸入表達(dá)式: ');
gets(ch);
p=ch;
while(*p) // 沒到串尾
push(s，*p );
for(i=0;i
if(！stackempty(s)) {// 棧不空
pop(s，e); // 彈出棧頂元素
b[i]=e;
}
}
for(i=0;i
if(ch[i]！=b[i])
k=0;
}
if(k==0)
printf('no！');
else
printf('輸出:')
printf('yes！');
}
return 0;
}
實(shí)驗(yàn)結(jié)果：
請輸入表達(dá)式：
abcba
輸出：yes！
心得體會：棧是僅能在表尾驚醒插入和刪除操作的線性表，具有先進(jìn)后出的性質(zhì)，這個固有性質(zhì)使棧成為程序設(shè)計(jì)中的有用工具。
實(shí)驗(yàn)4
實(shí)驗(yàn)題目：二叉樹操作設(shè)計(jì)和實(shí)現(xiàn)
實(shí)驗(yàn)?zāi)康模?/p>
掌握二叉樹的定義、性質(zhì)及存儲方式，各種遍歷算法。
實(shí)驗(yàn)要求：
采用二叉樹鏈表作為存儲結(jié)構(gòu)，完成二叉樹的建立，先序、中序和后序以及按層次遍歷的操作，求所有葉子及結(jié)點(diǎn)總數(shù)的操作。
實(shí)驗(yàn)主要步驟：
1、分析、理解程序。
2、調(diào)試程序，設(shè)計(jì)一棵二叉樹，輸入完全二叉樹的先序序列，用#代表虛結(jié)點(diǎn)(空指針)，如abd###ce##f##，建立二叉樹，求出先序、中序和后序以及按層次遍歷序列，求所有葉子及結(jié)點(diǎn)總數(shù)。
程序代碼:
實(shí)驗(yàn)結(jié)果：
心得體會：
實(shí)驗(yàn)5
實(shí)驗(yàn)題目：圖的遍歷操作
實(shí)驗(yàn)?zāi)康模?/p>
掌握有向圖和無向圖的概念;掌握鄰接矩陣和鄰接鏈表建立圖的存儲結(jié)構(gòu);掌握dfs及bfs對圖的遍歷操作;了解圖結(jié)構(gòu)在人工智能、工程等領(lǐng)域的廣泛應(yīng)用。
實(shí)驗(yàn)要求：
采用鄰接矩陣和鄰接鏈表作為圖的存儲結(jié)構(gòu)，完成有向圖和無向圖的dfs和bfs操作。
實(shí)驗(yàn)主要步驟：
設(shè)計(jì)一個有向圖和一個無向圖，任選一種存儲結(jié)構(gòu)，完成有向圖和無向圖的dfs(深度優(yōu)先遍歷)和bfs(廣度優(yōu)先遍歷)的操作。
1. 鄰接矩陣作為存儲結(jié)構(gòu)
#include'stdio.h'
#include'stdlib.h'
#define maxvertexnum 100 //定義最大頂點(diǎn)數(shù)
typedef struct{
char vexs[maxvertexnum]; //頂點(diǎn)表
int edges[maxvertexnum][maxvertexnum]; //鄰接矩陣，可看作邊表 int n，e; //圖中的頂點(diǎn)數(shù)n和邊數(shù)e
}mgraph; //用鄰接矩陣表示的圖的類型
//=========建立鄰接矩陣=======
void creatmgraph(mgraph *g)
{
int i，j，k;
char a;
printf('input vertexnum(n) and edgesnum(e): ');
scanf('%d，%d'，&g->;n，&g->;e); //輸入頂點(diǎn)數(shù)和邊數(shù)
scanf('%c'，&a);
printf('input vertex string:');
for(i=0;in;i )
{
scanf('%c'，&a);
g->;vexs[i]=a; //讀入頂點(diǎn)信息，建立頂點(diǎn)表
}
for(i=0;in;i )
for(j=0;jn;j )
g->;edges[i][j]=0; //初始化鄰接矩陣
printf('input edges，creat adjacency matrix ');
for(k=0;ke;k ) { //讀入e條邊，建立鄰接矩陣
scanf('%d%d'，&i，&j); //輸入邊(vi，vj)的頂點(diǎn)序號
g->;edges[i][j]=1;;g->;edges[j][i]=1;//若為;//=========定義標(biāo)志向量，為全局變量=;typedefenum{false，true}b;booleanvisited[maxvertex;//========dfs：深度優(yōu)先遍歷的遞歸算;voiddfsm(mgraph*g，inti);{//以vi為出發(fā)點(diǎn)
g->;edges[i][j]=1;
g->;edges[j][i]=1; //若為無向圖，矩陣為對稱矩陣;若建立有向圖，去掉該條語句 }
}
//=========定義標(biāo)志向量，為全局變量=======
typedef enum{false，true} boolean;
boolean visited[maxvertexnum];
//========dfs：深度優(yōu)先遍歷的遞歸算法======
void dfsm(mgraph *g，int i)
{ //以vi為出發(fā)點(diǎn)對鄰接矩陣表示的圖g進(jìn)行dfs搜索，鄰接矩陣是0，1矩陣
給出你的編碼
//===========bfs：廣度優(yōu)先遍歷=======
void bfs(mgraph *g，int k)
{ //以vk為源點(diǎn)對用鄰接矩陣表示的圖g進(jìn)行廣度優(yōu)先搜索
給出你的編碼
//==========主程序main =====
void main
{
int i;
mgraph *g;
g=(mgraph *)malloc(sizeof(mgraph)); //為圖g申請內(nèi)存空間
creatmgraph(g); //建立鄰接矩陣
printf('print graph dfs: ');
dfs(g); //深度優(yōu)先遍歷
printf(' ');
printf('print graph bfs: ');
bfs(g，3); //以序號為3的頂點(diǎn)開始廣度優(yōu)先遍歷
printf(' ');
}
2. 鄰接鏈表作為存儲結(jié)構(gòu)
#include'stdio.h'
#include'stdlib.h'
#define maxvertexnum 50 //定義最大頂點(diǎn)數(shù)
typedef struct node{ //邊表結(jié)點(diǎn)
int adjvex; //鄰接點(diǎn)域
struct node *next; //鏈域
}edgenode;
typedef struct vnode{ //頂點(diǎn)表結(jié)點(diǎn)
char vertex; //頂點(diǎn)域
edgenode *firstedge; //邊表頭指針
}vertexnode;
typedef vertexnode adjlist[maxvertexnum]; //adjlist是鄰接表類型 typedef struct {
adjlist adjlist; //鄰接表
int n，e; //圖中當(dāng)前頂點(diǎn)數(shù)和邊數(shù)
} algraph; //圖類型
//=========建立圖的鄰接表=======
void creatalgraph(algraph *g)
{
int i，j，k;
char a;
edgenode *s; //定義邊表結(jié)點(diǎn)
printf('input vertexnum(n) and edgesnum(e): ');
scanf('%d，%d'，&g->;n，&g->;e); //讀入頂點(diǎn)數(shù)和邊數(shù)
scanf('%c'，&a);
printf('input vertex string:');
for(i=0;in;i ) //建立邊表
{
scanf('%c'，&a);
g->;adjlist[i].vertex=a; //讀入頂點(diǎn)信息
g->;adjlist[i].firstedge=null; //邊表置為空表
}
printf('input edges，creat adjacency list ');
for(k=0;ke;k ) { //建立邊表
scanf('%d%d'，&i，&j); //讀入邊(vi，vj)的頂點(diǎn)對序號
s=(edgenode *)malloc(sizeof(edgenode)); //生成邊表結(jié)點(diǎn)
s->;adjvex=j; //鄰接點(diǎn)序號為j
s->;next=g->;adjlist[i].firstedge;
g->;adjlist[i].firstedge=s; //將新結(jié)點(diǎn)*s插入頂點(diǎn)vi的邊表頭部
s=(edgenode *)malloc(sizeof(edgenode));
s->;adjvex=i; //鄰接點(diǎn)序號為i
s->;next=g->;adjlist[j].firstedge;
g->;adjlist[j].firstedge=s; //將新結(jié)點(diǎn)*s插入頂點(diǎn)vj的邊表頭部
}
}
//=========定義標(biāo)志向量，為全局變量=======
typedef enum{false，true} boolean;
boolean visited[maxvertexnum];
//========dfs：深度優(yōu)先遍歷的遞歸算法======
void dfsm(algraph *g，int i)
{ //以vi為出發(fā)點(diǎn)對鄰接鏈表表示的圖g進(jìn)行dfs搜索
給出你的編碼
//==========bfs：廣度優(yōu)先遍歷=========
void bfs(algraph *g，int k)
{ //以vk為源點(diǎn)對用鄰接鏈表表示的圖g進(jìn)行廣度優(yōu)先搜索
給出你的編碼
//==========主函數(shù)===========
void main
{
int i;
algraph *g;
g=(algraph *)malloc(sizeof(algraph));
creatalgraph(g);
printf('print graph dfs: ');
dfs(g);
printf(' ');
printf('print graph bfs: ');
bfs(g，3);
printf(' ');
}
實(shí)驗(yàn)結(jié)果：
1. 鄰接矩陣作為存儲結(jié)構(gòu)
2. 鄰接鏈表作為存儲結(jié)構(gòu)
心得體會：
實(shí)驗(yàn)6
實(shí)驗(yàn)題目：二分查找算法的實(shí)現(xiàn)
實(shí)驗(yàn)?zāi)康模?/p>
掌握二分查找法的工作原理及應(yīng)用過程，利用其工作原理完成實(shí)驗(yàn)題目中的內(nèi)容。。
實(shí)驗(yàn)要求：
編寫程序構(gòu)造一個有序表l，從鍵盤接收一個關(guān)鍵字key，用二分查找法在l中查找key，若找到則提示查找成功并輸出key所在的位置，否則提示沒有找到信息。。
實(shí)驗(yàn)主要步驟：
1. 建立的初始查找表可以是無序的，如測試的數(shù)據(jù)為{3，7，11，15，17，21，35，42，50｝或者{11，21，7，3，15，50，42，35，17｝。
2. 給出算法的遞歸和非遞歸代碼;
3. 如何利用二分查找算法在一個有序表中插入一個元素x，并保持表的有序性？
程序代碼
實(shí)驗(yàn)結(jié)果：
心得體會：
實(shí)驗(yàn)7
實(shí)驗(yàn)題目：排序
實(shí)驗(yàn)?zāi)康模?/p>
掌握各種排序方法的基本思想、排序過程、算法實(shí)現(xiàn)，能進(jìn)行時間和空間性能的分析，根據(jù)實(shí)際問題的特點(diǎn)和要求選擇合適的排序方法。
實(shí)驗(yàn)要求：
實(shí)現(xiàn)直接排序、冒泡、直接選擇、快速、堆、歸并排序算法。比較各種算法的運(yùn)行速度。
實(shí)驗(yàn)主要步驟：
程序代碼
實(shí)驗(yàn)結(jié)果：
心得體會：
精選寫報告經(jīng)驗(yàn)176人覺得有用
做實(shí)驗(yàn)報告的時候，得把實(shí)驗(yàn)?zāi)康膶懬宄蝗焕蠋熆戳藭恢滥愕降紫氡磉_(dá)什么。數(shù)據(jù)結(jié)構(gòu)這門課，做實(shí)驗(yàn)肯定繞不開算法分析這一塊，所以這部分內(nèi)容要重點(diǎn)突出，比如用個表格列出時間復(fù)雜度什么的，這樣直觀，老師批改起來也方便。
實(shí)驗(yàn)步驟這部分，不能太簡略，也不能啰嗦得讓人看不明白。最好能像講故事一樣，一步一步地描述，但別忘了帶上自己的理解。比如說某個地方用了鏈表替代數(shù)組，就要說明為什么要這么做，是為了節(jié)省空間還是提高效率之類的。有時候可能記不太清具體細(xì)節(jié)了，這時候可以憑印象大致寫一下，只要邏輯通就行。
結(jié)果分析這塊兒比較關(guān)鍵，得把實(shí)驗(yàn)得到的數(shù)據(jù)拿出來討論下。如果發(fā)現(xiàn)跟預(yù)期不一樣，就得好好想想原因，是不是算法有問題，還是說輸入數(shù)據(jù)不對勁。記得把圖表放進(jìn)去，直觀展示效果更好。不過有時候可能會漏掉一些重要參數(shù)沒記錄下來，這種情況下就只能盡力補(bǔ)救，盡量從現(xiàn)有材料推導(dǎo)結(jié)論。
寫報告的時候，格式挺重要的，標(biāo)題字號什么的都要統(tǒng)一，不然看起來亂糟糟的。引用別人的東西一定要標(biāo)明出處，不然容易惹麻煩。有時候?qū)懼鴮懼悸吠蝗粩嗔?，這時候別急著往下湊字?jǐn)?shù)，先把前面的內(nèi)容檢查一遍，確保無誤再說。
還有就是語言表達(dá)，盡量用專業(yè)術(shù)語，但別堆砌太多，顯得晦澀難懂。偶爾蹦出幾個口語化的詞也沒關(guān)系，顯得親切自然。像什么“搞了半天終于搞明白了”這樣的話雖然不太正式，但能讓讀者感受到你的努力過程。不過要注意場合哈，別一整篇都是這樣，得把握好分寸。
最后提醒一下，打印前一定要仔細(xì)校對幾遍，尤其是數(shù)字這類容易出錯的地方。有時候忙起來就顧不上這些細(xì)節(jié)，結(jié)果提交上去才發(fā)現(xiàn)滿篇都是小錯誤，那多尷尬啊。
【第4篇】數(shù)據(jù)結(jié)構(gòu)實(shí)驗(yàn)報告總結(jié)怎么寫1500字
include# include
# include
# define max_operator_num 100 //運(yùn)算符棧數(shù)組長度
# define max_data_num 100 //運(yùn)算數(shù)棧數(shù)組長度
typedef struct opstack //定義運(yùn)算符棧
{
char opstack[max_operator_num];
int top;
}opstack， *popstack;
typedef struct datastack //定義運(yùn)算數(shù)棧
{
double stack[max_data_num];
int top;
}datastack， *pdatastack;
void initpopstack(popstack &postack) //初始化運(yùn)算符棧
{
if( ！(postack = (popstack)malloc(sizeof(opstack)))) //為運(yùn)算符棧分配空間
{
printf('分配內(nèi)存空間失??！ ');
exit(-1);
}
postack->;top = -1;
}
void initpdatastack(pdatastack &pdstack) //初始化運(yùn)算數(shù)棧
{
if( ！(pdstack = (pdatastack)malloc(sizeof(datastack)))) //為運(yùn)算數(shù)棧分配空間
{
printf('分配內(nèi)存空間失?。?');
exit(-1);
}
pdstack->;top = -1;
}
void pushopstack(popstack &postack， char ch) //運(yùn)算符進(jìn)棧
{
postack->;opstack[ (postack->;top)] = ch;
}
void popopstack(popstack &postack， char &ch) //運(yùn)算符出棧
{
ch = postack->;opstack[postack->;top];
postack->;top--;
}
void pushdatastack(pdatastack &pdstack， double d) //運(yùn)算數(shù)進(jìn)棧
{
(pdstack->;top);
pdstack->;stack[pdstack->;top] = d;
}
void popdatastack(pdatastack &pdstack， double &d) //運(yùn)算數(shù)出棧
{
d = pdstack->;stack[pdstack->;top];
pdstack->;top--;
}
void clearpopstack(popstack &postack) //清空運(yùn)算符棧
{
postack->;top = -1;
}
void clearpdatastack(pdatastack &pdstack) //清空運(yùn)算數(shù)棧
{
pdstack->;top = -1;
}
char gettoppopstack(popstack &postack) //獲取運(yùn)算符棧頂元素
{
return postack->;opstack[postack->;top];
}
double gettoppdatastack(pdatastack &pdstack) //獲取運(yùn)算數(shù)棧頂元素
{
return pdstack->;stack[pdstack->;top];
}
bool isop(char &ch) //區(qū)分 運(yùn)算符 和 運(yùn)算數(shù) 的函數(shù)，是運(yùn)算符時返回true，否則返回false
{ //判斷是否為符號
if ( (ch == ' ') || (ch == '-') || (ch == '*') || (ch == '/') || (ch == '=') || (ch == 'a') || (ch == 's') || (ch == 'a') || (ch == 's') || (ch == '(') || (ch == ')') )
return true;
else
return false;
}
char precede(char op1， char op2) //參考《數(shù)據(jù)結(jié)構(gòu)》(c語言版)第53頁 3.2.5表達(dá)式求值 表 3.1
{
char tab[9][10]; //定義字符串的二維數(shù)組來存放運(yùn)算符優(yōu)先級的關(guān)系
strcpy( tab[0]， '>;>;<<;<;' );
strcpy( tab， '>;>;<<;<;' );
strcpy( tab， '>;>;>;>;;<;' );
strcpy( tab[3]， '>;>;>;>;;<;' );
strcpy( tab[4]， '<<<<<=<
strcpy( tab[5]， '>;>;>;>;e>;>;>;>;' );
strcpy( tab[6]， '>;>;>;>;;>;>;>;' );
strcpy( tab[7]， '>;>;>;>;;>;>;>;' );
strcpy( tab[8]， '<<<<
printf(' | ***歡迎您的下次使用！謝謝！*** | '); //退出使用
printf(' |~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~| ');
}
double operate(double a， char theta， double b) //對出棧的運(yùn)算符和運(yùn)算數(shù)進(jìn)行計(jì)算
{
double s;
switch(theta)
{
case ' ':
s = a b;
break;
case '-':
s = a - b;
break;
case '*':
s = a * b;
break;
case '/':
if ( b ！= 0 ) //判斷除數(shù)是否為0，若為0，退出程序
{
s = a/b;
break;
}
else
{
printf(' #### 除數(shù)為0，非法運(yùn)算。程序終止！ #### ');
exit_e; //打印結(jié)束菜單
exit(-1);
}
case 'a':
s = fabs(b); //調(diào)用fabs函數(shù)
break;
case 's':
if( b >;= 0) //判斷被開方數(shù)是否為0，若為0，退出程序
{
s = sqrt(b); //調(diào)用sqrt函數(shù)
break;
}
else
{
printf(' #### 求負(fù)數(shù)的平方根是非法運(yùn)算。程序終止！ #### ');
exit_e; //打印結(jié)束菜單
exit(-1);
}
}
return s;
}
char changechar(char &c) //通過changechar函數(shù)來把a(bǔ)、s的小寫字母改為大寫的
{
if( c == 'a' )
c = 'a';
else if( c == 's' )
c = 's';
return c;
}
//參考《數(shù)據(jù)結(jié)構(gòu)》(c語言版)第53頁 3.2.5表達(dá)式求值算法3.4 evaluateexpression_r函數(shù)
void evaluateexpression_r //計(jì)算函數(shù)：讀入表達(dá)式，并計(jì)算結(jié)果
{
popstack postack; //聲明運(yùn)算符棧
pdatastack pdstack; //聲明運(yùn)算數(shù)棧
double result; //存運(yùn)算的結(jié)果
char x， theta， c; //c存放讀取的字符，x、theta存放運(yùn)算符棧的棧頂元素
int flag， data; //標(biāo)識符，用來讀入連續(xù)的數(shù)字
double s;
double getd; //存放gettop***的結(jié)果
double a， b， cc; //a，b存放數(shù)據(jù)棧出棧的棧頂元素， c存放運(yùn)算結(jié)果
flag = 0; //初始化標(biāo)識符，用來判斷字符串中的連續(xù)數(shù)字
data = 0; //
initpopstack(postack); //初始化運(yùn)算符棧
initpdatastack(pdstack); //初始化運(yùn)算數(shù)棧
pushopstack(postack， '='); //在運(yùn)算符棧底放入'='
printf(' &請輸入表達(dá)式以'='結(jié)束：');
c = get); //讀入字符
changechar(c); //通過調(diào)用函數(shù)來實(shí)現(xiàn)把小寫的a、s改為大寫的a、s
while( c ！= '=' || gettoppopstack(postack) ！= '=')
{
if( ！isop(c) ) //不是運(yùn)算符進(jìn)棧
{
s = c - '0'; //把字符轉(zhuǎn)化為數(shù)字
if ( flag == 1 )
{
popdatastack(pdstack， getd);
s = getd*10 s;
}
pushdatastack(pdstack， s);
flag = 1;
c = get);
changechar(c);
}
else
{
flag = 0;
switch( precede(gettoppopstack(postack)， c) ) //輸入元素和運(yùn)算符棧頂元素比較
{
case '<': //棧頂元素優(yōu)先級低
pushopstack(postack， c);
c = get);
changechar(c);
break;
case '=': //托括號并接受下一個字符
popopstack(postack， x);
c = get);
changechar(c);
break;
case '>;': //退棧并將運(yùn)算結(jié)果進(jìn)棧
popopstack(postack， theta);
popdatastack(pdstack， b);
popdatastack(pdstack， a);
cc = operate(a， theta， b);
pushdatastack(pdstack， cc);
break;
}//switch
}//else
}//while
result = gettoppdatastack(pdstack); //運(yùn)算結(jié)束時，運(yùn)算數(shù)棧的棧底元素就是計(jì)算結(jié)果
clearpopstack(postack); //清空運(yùn)算符棧
clearpdatastack(pdstack); //清空運(yùn)算數(shù)棧
printf(' ->;計(jì)算結(jié)果為：%.2f '， result); //輸出運(yùn)算結(jié)果
return ;
}
void print_user //歡迎界面
{
printf(' 歡迎使用c語言版模擬計(jì)算器 ');
printf('************************************************************************ ');
printf(' |~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~| ');
printf(' | 模擬計(jì)算器使用說明 | ');
printf(' | 作者：謝先斌 | ');
printf(' | 本程序包括對' '、'-'、'*'、'/'、''的運(yùn)算 | ');
printf(' | 本程序中abs算用a替代、sqrt運(yùn)算用s代替 | ');
printf(' | 本程序中的一切字母均不區(qū)分大小寫 | ');
printf(' 正確的表達(dá)式如：1 a(7-8) s(9*8)= ');
printf(' | 輸入'='表示表達(dá)式輸入結(jié)束！ | ');
printf(' | 歡迎使用！-->;-->; | ');
printf(' |~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~| ');
printf('************************************************************************ ');
}
int main //主函數(shù)
{
char in;
bool b; //標(biāo)識符，用來標(biāo)識是否結(jié)束程序
b = true; //初始化，不結(jié)束
print_user; //打印歡迎界面
printf(' *請確認(rèn)使用計(jì)算器y/n:');
while(1)
{
scanf('%c'， &in); //確認(rèn)是否繼續(xù)操作
get); //吃掉會車，避免干擾
switch(in)
{
case 'y':
case 'y':
{
evaluateexpression_r; //進(jìn)入計(jì)算函數(shù)：讀入表達(dá)式，并計(jì)算結(jié)果
break;
}
case 'n':
case 'n':
{
exit_e;
b = false;
break;
}
//default:
// printf(' **輸入錯誤，請重新輸入y/n:');
// break;
}
if(b==false) //如果 b==false ，退出整個程序
break;
printf(' *您確定要繼續(xù)使用計(jì)算機(jī)y/n:');
get); //用getchar吃掉回車，避免對后續(xù)輸入中in的干擾
}
return 0;
}
精選寫報告經(jīng)驗(yàn)169人覺得有用
數(shù)據(jù)結(jié)構(gòu)實(shí)驗(yàn)報告總結(jié)怎么寫
做實(shí)驗(yàn)報告總結(jié)的時候，得把整個實(shí)驗(yàn)過程好好梳理一遍。開頭部分，你可以先把實(shí)驗(yàn)的目標(biāo)說一下，就是你一開始想通過這個實(shí)驗(yàn)達(dá)到什么目的，這樣能讓看的人明白背景。接著就該回顧下具體的操作步驟了，別寫得太啰嗦，但關(guān)鍵點(diǎn)一定要提到，比如用到了哪些算法，這些算法是怎么實(shí)現(xiàn)的。
然后就要談?wù)劷Y(jié)果了，這一步很重要。結(jié)果不是單純地羅列數(shù)字或者圖表，得結(jié)合實(shí)際情況去分析。比如說你的實(shí)驗(yàn)數(shù)據(jù)和預(yù)期目標(biāo)有沒有偏差，如果有偏差的話，可能是什么原因?qū)е碌?，是算法本身的問題還是數(shù)據(jù)采集過程中出了差錯？這些問題都需要在總結(jié)里提出來。要是能提出一些改進(jìn)措施就更好了，這能體現(xiàn)你的思考深度。
不過有時候?qū)懼鴮懼赡軙l(fā)現(xiàn)自己思路有點(diǎn)亂，這種時候不妨停下來想想是不是哪里漏掉了重要信息。還有，有時候?yàn)榱斯?jié)省時間，會直接復(fù)制粘貼前面的描述，這就容易造成前后內(nèi)容重復(fù)，雖然不是大問題，但還是盡量避免吧。另外，有些地方可能會因?yàn)橼s時間而寫得比較簡略，尤其是那些不太重要的細(xì)節(jié)，但這會影響整體的嚴(yán)謹(jǐn)性，所以最好還是花點(diǎn)心思補(bǔ)充完整。
寫總結(jié)的時候，數(shù)據(jù)的準(zhǔn)確性特別關(guān)鍵。如果數(shù)據(jù)來源有問題，那后面的所有分析都會受影響。所以檢查數(shù)據(jù)的時候要仔細(xì)一點(diǎn)，確保沒有遺漏或者錯誤的地方。還有，引用別人的成果時要標(biāo)明出處，這是基本的學(xué)術(shù)道德。如果覺得自己表達(dá)得不夠清晰，可以多看看相關(guān)的文獻(xiàn)資料，從中汲取靈感。
最后，記得把總結(jié)寫得條理分明?？梢栽囍貌煌姆绞浇M織材料，找到最適合自己的表達(dá)方式。有時候換一種說法，可能會讓原本模糊的概念變得更加清楚。當(dāng)然啦，寫總結(jié)的時候也不要忘了保持耐心，畢竟好的總結(jié)不是一蹴而就的，需要反復(fù)修改和完善才能達(dá)到理想的效果。
【第5篇】數(shù)據(jù)結(jié)構(gòu)實(shí)驗(yàn)報告實(shí)驗(yàn)五怎么寫650字
數(shù)據(jù)結(jié)構(gòu)實(shí)驗(yàn)報告 實(shí)驗(yàn)五
一.實(shí)驗(yàn)內(nèi)容：
實(shí)現(xiàn)哈夫曼編碼的生成算法。
二.實(shí)驗(yàn)?zāi)康模?/p>
1、使學(xué)生熟練掌握哈夫曼樹的生成算法。
2、熟練掌握哈夫曼編碼的方法。
三.問題描述：
已知n個字符在原文中出現(xiàn)的頻率，求它們的哈夫曼編碼。
1、讀入n個字符，以及字符的.權(quán)值，試建立一棵huffman樹。
2、根據(jù)生成的huffman樹，求每個字符的huffman編碼。并對給定的待編碼字符序列進(jìn)行編碼，并輸出。
四.問題的實(shí)現(xiàn)
(1)郝夫曼樹的存儲表示
typedef struct{
unsigned int weight;
unsigned int parent，lchild，rchild;
}htnode，*huffmantree; //動態(tài)分配數(shù)組存儲郝夫曼樹
郝夫曼編碼的存儲表示
typedef char* *huffmancode;//動態(tài)分配數(shù)組存儲郝夫曼編碼
(2)主要的實(shí)現(xiàn)思路：
a.首先定義郝夫曼樹的存儲形式，這里使用了數(shù)組
b.用select遍歷n個字符，找出權(quán)值最小的兩個
c.構(gòu)造郝夫曼樹ht，并求出n個字符的郝夫曼編碼hc
總結(jié)
1.基本上沒有什么太大的問題，在調(diào)用select這個函數(shù)時，想把權(quán)值最小的兩個結(jié)點(diǎn)的序號帶回huffmancoding，所以把那2個序號設(shè)置成了引用。
2.在編程過程中，在什么時候分配內(nèi)存，什么時候初始化花的時間比較長
3.最后基本上實(shí)現(xiàn)后，發(fā)現(xiàn)結(jié)果仍然存在問題，經(jīng)過分步調(diào)試，發(fā)現(xiàn)了特別低級的輸入錯誤。把ht[i].weight=ht[s1].weight ht[s2].weight;中的s2寫成了i
附：
//動態(tài)分配數(shù)組存儲郝夫曼樹
typedef struct{
int weight; //字符的權(quán)值
int parent，lchild，rchild;
}htnode，*huffmantree;
//動態(tài)分配數(shù)組存儲郝夫曼編碼
typedef char* *huffmancode;
//選擇n個(這里是k=n)節(jié)點(diǎn)中權(quán)值最小的兩個結(jié)點(diǎn)
void select(huffmantree &ht，int k，int &s1，int &s2)
{ int i;
i=1;
while(i<=k && ht[i].parent！=0)i ;
//下面選出權(quán)值最小的結(jié)點(diǎn)，用s1指向其序號
s1=i;
for(i=1;i<=k;i )
{
if(ht[i].parent==0&&ht[i].weight
}
//下面選出權(quán)值次小的結(jié)點(diǎn)，用s2指向其序號
for(i=1;i<=k;i )
{
if(ht[i].parent==0&&i！=s1)break;
}
s2=i;
for(i=1;i<=k;i )
{
if(ht[i].parent==0&&i！=s1&&ht[i].weight
}
}
//構(gòu)造huffman樹，求出n個字符的編碼
void huffmancoding(huffmantree &ht，huffmancode &hc，int *w，int n)
{
int m，c，f，s1，s2，i，start;
char *cd;
if(n<=1)return;
m=2*n-1; //n個葉子n-1個結(jié)點(diǎn)
ht=(huffmantree)malloc((m 1)*sizeof(htnode)); //0號單元未用，預(yù)分配m 1個單元
huffmantree p=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); //選出當(dāng)前權(quán)值最小的
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]='';//編碼結(jié)束符
for(i=1;i<=n;i ) //逐個字符求郝夫曼編碼
{
start=n-1; //編碼結(jié)束符位置
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復(fù)制編碼到hc
}
free(cd); //釋放工作空間
}
void main
{ int n，i;
int* w; //記錄權(quán)值
char* ch; //記錄字符
huffmantree ht;
huffmancode hc;
cout<<'請輸入待編碼的字符個數(shù)n=';
cin>;>;n;
w=(int*)malloc((n 1)*sizeof(int)); //記錄權(quán)值，號單元未用
ch=(char*)malloc((n 1)*sizeof(char));//記錄字符，號單元未用
cout<<'依次輸入待編碼的字符data及其權(quán)值weight'<
for(i=1;i<=n;i )
{
cout<<'data['<
}
精選寫報告經(jīng)驗(yàn)159人覺得有用
數(shù)據(jù)結(jié)構(gòu)實(shí)驗(yàn)報告實(shí)驗(yàn)五怎么寫
做實(shí)驗(yàn)報告確實(shí)是個細(xì)致活兒，尤其是數(shù)據(jù)結(jié)構(gòu)這種講究邏輯的東西，寫得不好就容易顯得亂七八糟。這回我就拿實(shí)驗(yàn)五來說，大家得先把實(shí)驗(yàn)?zāi)康母闱宄?，別一上來就稀里糊涂地抄代碼。記得有一次我做實(shí)驗(yàn)的時候，就是沒弄明白實(shí)驗(yàn)?zāi)繕?biāo)，結(jié)果寫出來的報告漏洞百出，后來花了好久才改好。
寫報告的時候，第一步是把實(shí)驗(yàn)的基本情況寫清楚，比如用到了哪些算法，實(shí)驗(yàn)環(huán)境是什么樣的。這部分不用太啰嗦，但得讓人一看就知道你在做什么。比如，實(shí)驗(yàn)五可能涉及二叉樹遍歷什么的，那你就得把相關(guān)的概念和公式寫出來，不能直接跳到結(jié)果分析上。要是連基本的概念都沒交代明白，后面的內(nèi)容再漂亮也沒用。
接著就是實(shí)驗(yàn)的具體步驟了，這一步尤其重要。要是步驟寫得不清楚，別人根本不知道你是怎么得出結(jié)論的。有時候我也會犯這樣的錯，比如把一些關(guān)鍵的操作省略掉，結(jié)果后來檢查的時候才發(fā)現(xiàn)，原來那些細(xì)節(jié)才是問題的關(guān)鍵。所以，不管多簡單的過程，都得寫詳細(xì)點(diǎn)，像是代碼里的某些特殊情況處理，最好都提一下。
關(guān)于代碼部分，我覺得最好能附上截圖，這樣直觀些。不過截圖不能亂貼，得挑重點(diǎn)的地方，比如輸入輸出的部分，還有程序運(yùn)行過程中的一些異常情況。要是覺得截圖還不夠說明問題，那就補(bǔ)充文字解釋，把代碼里的邏輯講清楚。有時候我寫報告的時候，總覺得代碼解釋得不夠透徹，后來反復(fù)修改了好幾次才滿意。
數(shù)據(jù)分析這部分也很關(guān)鍵，不能只列出結(jié)果就完事了。你得把實(shí)驗(yàn)結(jié)果和預(yù)期做一個對比，看看是不是符合你的假設(shè)。要是有偏差的話，要試著找出原因，是算法的問題還是數(shù)據(jù)本身的原因。我記得以前做過一個實(shí)驗(yàn)，結(jié)果和預(yù)期差得特別遠(yuǎn)，當(dāng)時我以為是算法出了問題，后來才發(fā)現(xiàn)是數(shù)據(jù)格式不對勁，害得我白白折騰了一陣子。
最后就是結(jié)論啦，這一步可不能馬虎。結(jié)論不是簡單的重復(fù)實(shí)驗(yàn)結(jié)果，而是要結(jié)合整個實(shí)驗(yàn)過程，總結(jié)一下你學(xué)到了什么，有什么不足的地方。比如，這次實(shí)驗(yàn)讓我明白了二叉樹遍歷的重要性，也發(fā)現(xiàn)了自己在調(diào)試代碼時的一些盲點(diǎn)。當(dāng)然啦，也不能光說優(yōu)點(diǎn)，得誠實(shí)地指出存在的問題，這樣下次才能改進(jìn)。
寫實(shí)驗(yàn)報告的時候，最怕的就是格式混亂，所以一定要注意排版。要是老師要求用特定的格式，那就得嚴(yán)格按照要求來。有時候我會因?yàn)楦袷絾栴}被扣分，所以后來每次寫報告前都會先檢查一遍格式。另外，報告里引用的數(shù)據(jù)和圖表一定要標(biāo)明來源，不然很容易引起爭議。
【第6篇】北郵數(shù)據(jù)結(jié)構(gòu)實(shí)驗(yàn)報告怎么寫2150字
北郵數(shù)據(jù)結(jié)構(gòu)實(shí)驗(yàn)報告
北京郵電大學(xué)信息與通信工程學(xué)院
2009級數(shù)據(jù)結(jié)構(gòu)實(shí)驗(yàn)報告
實(shí)驗(yàn)名稱： 實(shí)驗(yàn)三哈夫曼編/解碼器的實(shí)現(xiàn)
學(xué)生姓名：陳聰捷
日 期： 2025年11月28日
1.實(shí)驗(yàn)要求
一、實(shí)驗(yàn)?zāi)康模?/p>
了解哈夫曼樹的思想和相關(guān)概念;
二、實(shí)驗(yàn)內(nèi)容：
利用二叉樹結(jié)構(gòu)實(shí)現(xiàn)哈夫曼編/解碼器
1.初始化：能夠?qū)斎氲娜我忾L度的字符串s進(jìn)行統(tǒng)計(jì)，統(tǒng)計(jì)每個字符的頻度，并建立哈夫曼樹。
2.建立編碼表：利用已經(jīng)建好的哈夫曼樹進(jìn)行編碼，并將每個字符的編碼輸出。
3.編碼：根據(jù)編碼表對輸入的字符串進(jìn)行編碼，并將編碼后的字符串輸出。
4.譯碼：利用已經(jīng)建好的哈夫曼樹對編碼后的字符串進(jìn)行譯碼，并輸出譯碼結(jié)果。
5.打?。阂灾庇^的方式打印哈夫曼樹。
6.計(jì)算輸入的字符串編碼前和編碼后的長度，并進(jìn)行分析，討論哈夫曼編碼的壓縮效果。
7.用戶界面可以設(shè)計(jì)成“菜單”方式，能進(jìn)行交互，根據(jù)輸入的字符串中每個字符出現(xiàn)的次數(shù)統(tǒng)計(jì)頻度，對沒有出現(xiàn)的字符一律不用編碼。
2. 程序分析
2.1 存儲結(jié)構(gòu)
二叉樹
template
class bitree
{
public:
bitree; //構(gòu)造函數(shù)，其前序序列由鍵盤輸入
~bitree(void); //析構(gòu)函數(shù)
binode* getroot; //獲得指向根結(jié)點(diǎn)的指針
protected:
binode *root; //指向根結(jié)點(diǎn)的頭指針
};
//聲明類bitree及定義結(jié)構(gòu)binode
data：
二叉樹是由一個根結(jié)點(diǎn)和兩棵互不相交的左右子樹構(gòu)成
哈夫曼樹類的數(shù)據(jù)域，繼承節(jié)點(diǎn)類型為int的二叉樹 class huffmantree:public bitree
data:
hcode* hcodetable;//編碼表
int tsize; //編碼表中的總字符數(shù)
二叉樹的節(jié)點(diǎn)結(jié)構(gòu)
template
struct binode //二叉樹的結(jié)點(diǎn)結(jié)構(gòu) {
t data; //記錄數(shù)據(jù)
t lchild; //左孩子
t rchild; //右孩子
t parent; //雙親
};
編碼表的節(jié)點(diǎn)結(jié)構(gòu)
struct hcode
{
char data; //編碼表中的字符
char code[100]; //該字符對應(yīng)的編碼
};
待編碼字符串由鍵盤輸入，輸入時用鏈表存儲，鏈表節(jié)點(diǎn)為 struct node
{
char character; //輸入的字符
unsigned int count;//該字符的權(quán)值
bool used; //建立樹的時候該字符是否使用過
node* next; //保存下一個節(jié)點(diǎn)的地址
};
示意圖：
2.2 關(guān)鍵算法分析
1.初始化函數(shù)(void huffmantree::init(string input))
算法偽代碼：
1.初始化鏈表的頭結(jié)點(diǎn)
2.獲得輸入字符串的第一個字符，并將其插入到鏈表尾部，n=1(n記錄的是鏈表
中字符的個數(shù))
3.從字符串第2個字符開始，逐個取出字符串中的字符
3.1 將當(dāng)前取出的字符與鏈表中已經(jīng)存在的字符逐個比較，如果當(dāng)前取出
的字符與鏈表中已經(jīng)存在的某個字符相同，則鏈表中該字符的權(quán)值加1。
3.2 如果當(dāng)前取出的字符與鏈表中已經(jīng)存在的字符都不相同，則將其加入
到鏈表尾部，同時n
4.tsize=n(tsize記錄鏈表中字符總數(shù)，即哈夫曼樹中葉子節(jié)點(diǎn)總數(shù))
5.創(chuàng)建哈夫曼樹
6.銷毀鏈表
源代碼：
void huffmantree::init(string input)
{
node *front=new node; //初始化鏈表的頭結(jié)點(diǎn)
if(！front)
throw exception('堆空間用盡');
front->;next=null;
front->;character=null;
front->;count=0;
node *pfront=front;
char ch=input[0]; //獲得第一個字符
node* new1=new node;
if(！new1)
throw exception('堆空間用盡');
new1->;character=ch; //將第一個字符插入鏈表
new1->;count=1;
new1->;next=pfront->;next;
pfront->;next=new1;
bool replace=0; //判斷在已經(jīng)寫入鏈表的字符中是否有與當(dāng)前讀出的字符相同的字符 int n=1; //統(tǒng)計(jì)鏈表中字符個數(shù)
for(int i=1;i
{
ch=input[i]; //獲得第i個字符
do
{
pfront=pfront->;next;
if((int)pfront->;character == (int)ch) //如果在鏈表中有與當(dāng)前字符相同的字符，
該字符權(quán)值加1
{
pfront->;count ;
replace=1;
break;
}
}while(pfront->;next);
if(！replace) //如果在鏈表中沒找到與當(dāng)前字符相同的字符，則將該字符作為新成 員插入鏈表
{
node* new=new node;
if(！new)
throw exception('堆空間用盡');
new->;character=ch;
new->;count=1;
new->;next=pfront->;next;
pfront->;next=new;
n ;
}
pfront=front; //重置pfront和replace變量為默認(rèn)值 replace=0;
}
tsize=n; //tsize記錄的是編碼表中字符個數(shù)
createhtree(front，n); //創(chuàng)建哈夫曼樹
pfront=front;
while(pfront) //銷毀整個鏈表
{
front=pfront;
pfront=pfront->;next;
front;
}
時間復(fù)雜度：
若輸入的字符串長度為n，則時間復(fù)雜度為o(n)
2.創(chuàng)建哈夫曼樹(void huffmantree::createcodetable(node *p))
算法偽代碼：
1. 創(chuàng)建一個長度為2*tsize-1的三叉鏈表
2. 將存儲字符及其權(quán)值的鏈表中的字符逐個寫入三叉鏈表的前tsize個結(jié)點(diǎn)
的data域，并將對應(yīng)結(jié)點(diǎn)的孩子域和雙親域賦為空
3. 從三叉鏈表的第tsize個結(jié)點(diǎn)開始，i=tsize
3.1 從存儲字符及其權(quán)值的鏈表中取出兩個權(quán)值最小的結(jié)點(diǎn)x，y，記錄其
下標(biāo)x，y。
3.2 將下標(biāo)為x和y的哈夫曼樹的結(jié)點(diǎn)的雙親設(shè)置為第i個結(jié)點(diǎn)
3.3 將下標(biāo)為x的結(jié)點(diǎn)設(shè)置為i結(jié)點(diǎn)的左孩子，將下標(biāo)為y的結(jié)點(diǎn)設(shè)置為
i結(jié)點(diǎn)的右孩子，i結(jié)點(diǎn)的權(quán)值為x結(jié)點(diǎn)的權(quán)值加上y結(jié)點(diǎn)的權(quán)值，i
結(jié)點(diǎn)的雙親設(shè)置為空
4. 根據(jù)哈夫曼樹創(chuàng)建編碼表
源代碼：
void huffmantree::createhtree(node *p，int n)
{
root= new binode[2*n-1]; //初始化哈夫曼樹
node *front=p->;next;
if(n==0)
throw exception('沒有輸入字符');
for(int i=0;i
root[i].data=front->;count;
root[i].lchild=-1;
root[i].rchild=-1;
root[i].parent=-1;
front=front->;next;
}
front=p;
int new1，new2;
for(i=n;i<2*n-1;i )
{
selectmin(new1，new2，0，i); //從0~i中選出兩個權(quán)值最小的結(jié)點(diǎn)
root[new1].parent=root[new2].parent=i; //用兩個權(quán)值最小的結(jié)點(diǎn)生成新結(jié)點(diǎn)，
新節(jié)點(diǎn)為其雙親
root[i].data=root[new1].data root[new2].data;//新結(jié)點(diǎn)的權(quán)值為其孩子的權(quán)值的和 root[i].lchild=new1;
root[i].rchild=new2;
root[i].parent=-1;
}
createcodetable(p); //創(chuàng)建編碼表
}
時間復(fù)雜度：
在選取兩個權(quán)值最小的結(jié)點(diǎn)的函數(shù)中要遍歷鏈表，時間復(fù)雜度為o(n)，故該函數(shù)
的時間復(fù)雜度為o(n^2)
3.創(chuàng)建編碼表(void huffmantree::createcodetable(node *p))
算法偽代碼：
1.初始化編碼表
2.初始化一個指針，從鏈表的頭結(jié)點(diǎn)開始，遍歷整個鏈表
2.1 將鏈表中指針當(dāng)前所指的結(jié)點(diǎn)包含的字符寫入編碼表中
2.2 得到該結(jié)點(diǎn)對應(yīng)的哈夫曼樹的葉子結(jié)點(diǎn)及其雙親
2.3 如果哈夫曼樹只有一個葉子結(jié)點(diǎn)，將其字符對應(yīng)編碼設(shè)置為0
2.4 如果不止一個葉子結(jié)點(diǎn)，從當(dāng)前葉子結(jié)點(diǎn)開始判斷
2.4.1 如果當(dāng)前葉子結(jié)點(diǎn)是其雙親的左孩子，則其對應(yīng)的編碼為0，否
則為1
2.4.2 child指針指向葉子結(jié)點(diǎn)的雙親，parent指針指向child指針的雙親，
重復(fù)2.4.1的操作
2.5 將已完成的編碼倒序
2.6 取得鏈表中的下一個字符
3.輸出編碼表
源代碼：
void huffmantree::createcodetable(node *p)
{
hcodetable=new hcode[tsize]; //初始化編碼表
node *front=p->;next;
for(int i=0;i
{
hcodetable[i].data=front->;character; //將第i個字符寫入編碼表
int child=i; //得到第i個字符對應(yīng)的葉子節(jié)點(diǎn)
int parent=root[i].parent; //得到第i個字符對應(yīng)的葉子節(jié)點(diǎn)的雙親
int k=0;
if(tsize==1) //如果文本中只有一種字符，它的.編碼為0
{
hcodetable[i].code[k]='0';
k ;
}
while(parent！=-1) //從第i個字符對應(yīng)的葉子節(jié)點(diǎn)開始，尋找它到根結(jié)點(diǎn)的路徑
{
if(child==root[parent].lchild) //如果當(dāng)前結(jié)點(diǎn)為雙親的左孩子，則編碼為0，
否則編碼為1
hcodetable[i].code[k]='0';
else
hcodetable[i].code[k]='1';
k ;
child=parent;
parent=root[child].parent;
}
hcodetable[i].code[k]='';
reverse(hcodetable[i].code); //將編碼逆置
front=front->;next; //得到下一個字符
}
cout<<'編碼表為：'<
for(i=0;i
{
cout<
parent=root[parent].lchild;
else //編碼為1則尋找右孩子
parent=root[parent].rchild;
i ;
}
if(tsize==1) //如果編碼表只有一個字符，則根結(jié)點(diǎn)即為葉子結(jié)點(diǎn) i ;
d.append(1，hcodetable[parent].data);//將葉子節(jié)點(diǎn)對應(yīng)的字符追加到解碼串中 }
cout<
}
時間復(fù)雜度：
設(shè)待解碼串長度為n，則復(fù)雜度為o(n)
8. 計(jì)算哈夫曼編碼的壓縮比(void huffmantree::calculate(string s1，string s2)) 算法偽代碼：
1. 獲得編碼前字符串的長度，即其占用的字節(jié)數(shù)
2. 獲得編碼后的字符串的長度，將其除以8然后向上取整，得到其占用的字
節(jié)數(shù)
3. 壓縮比將兩個相除
源代碼：
void huffmantree::calculate(string s1，string s2)
{
int cal1=s1.length;
int cal2=s2.length;
cal2=ceill((float)cal2/8); //將編碼串的比特?cái)?shù)轉(zhuǎn)化為字節(jié)數(shù) cout<<'編碼前的字符串長度：'<
cout<<'編碼后的字符串長度：'<
cout<<'壓縮比為：'<<((double)cal2/(double)cal1)*100<<'%'<
}
時間復(fù)雜度：
o(1)
9. 打印哈夫曼樹(void huffmantree::printtree(int treenode，int layer) ) 算法偽代碼：
1. 如果待打印結(jié)點(diǎn)為空，則返回
2. 遞歸調(diào)用函數(shù)打印當(dāng)前結(jié)點(diǎn)的右子樹
3. 根據(jù)當(dāng)前結(jié)點(diǎn)所在的層次確定其前面要輸出多少空格，先輸出空格，在打
印當(dāng)前結(jié)點(diǎn)的權(quán)值
4. 遞歸調(diào)用函數(shù)打印當(dāng)前結(jié)點(diǎn)的左子樹
源代碼：
void huffmantree::printtree(int treenode，int layer)
{
if(treenode==-1) //如果待打印結(jié)點(diǎn)為空，則返回 return;
else
{
printtree(root[treenode].rchild，layer 1); //先打印該結(jié)點(diǎn)的右子樹，layer記錄
的是該結(jié)點(diǎn)所在的層次
for(int i=0;i
空格
cout<<' ';
cout<
printtree(root[treenode].lchild，layer 1); //打印該結(jié)點(diǎn)的左子樹
}
}
時間復(fù)雜度：
中序遍歷哈夫曼樹，復(fù)雜度為o(n)
10. 菜單函數(shù)(void huffmantree::menu)
算法偽代碼：
1. 逐一讀取鍵盤緩存區(qū)中的字符，并將它們逐一追加到記錄輸入字符串的
string變量中，直到讀到回車輸入符為止
2. 刪除string變量末尾的回車輸入符
3.利用string變量創(chuàng)建哈夫曼樹，初始化編碼表。
4. 直觀打印哈夫曼樹
5. 對輸入的字符串進(jìn)行編碼
6. 對編碼后的字符串進(jìn)行解碼
7. 計(jì)算編碼前后的壓縮比并輸出
源代碼：
void huffmantree::menu
{
cout<<'請輸入你要編碼的文本，按回車鍵確定輸入'<
string input;
char letter;
do //將字符逐個讀入input變量中
{
letter=cin.get;
input.append(1，letter);
}while(letter！=' ');
input.erase(input.length-1，1); //去掉input末尾的回車符
init(input); //根據(jù)輸入的字符串創(chuàng)建哈夫曼樹及其編碼表 cout<<'直觀打印哈夫曼樹'<
printtree(2*tsize-1-1，1); //打印哈夫曼樹
cout<<' '<<' ';
string d1，d2;
cout<<'編碼后的字符串為'<
encode(input，d1); //編碼并打印編碼串
cout<<'解碼后的字符串為'<
decode(d1，d2); //解碼并打印解碼串
cout<<'ascii碼編碼與huffman編碼的比較'<
calculate(input，d1); //計(jì)算編碼前后的壓縮比
}
2.3 其他
1.由于題目要求能輸入任意長的字符串，所以本程序采用了string變量來記錄輸入
的字符串，并采用string類的類成員函數(shù)來完成各項(xiàng)任務(wù)
2.打印哈夫曼樹時采用了遞歸函數(shù)，且采用了凹凸表的形式打印哈夫曼樹。
3.為了輸入空格，輸入時采取逐個字符輸入的方式
3. 程序運(yùn)行結(jié)果
主函數(shù)流程圖：
運(yùn)行結(jié)果：
各函數(shù)運(yùn)行正常，沒有出現(xiàn)bug
4. 總結(jié)
經(jīng)過這次實(shí)驗(yàn)，我了解了哈夫曼樹的創(chuàng)建過程，了解了一種不等長編碼的方法，用設(shè)斷點(diǎn)調(diào)試的方法更加熟練，同時熟悉了stl中string類型的用法，對c 更加熟悉
精選寫報告經(jīng)驗(yàn)42人覺得有用
寫報告的時候，得先搞清楚報告的目的，比如這個北郵的數(shù)據(jù)結(jié)構(gòu)實(shí)驗(yàn)報告，肯定是用來展示你的實(shí)驗(yàn)成果的，所以開頭得說清楚你是做什么實(shí)驗(yàn)的，用什么方法做的。比如，這次實(shí)驗(yàn)主要是研究排序算法的效率問題，用了C語言編寫程序進(jìn)行測試，這樣讀者就知道你是在研究什么了。
接著就是具體的操作步驟，這部分很重要，因?yàn)閯e人要看懂你的實(shí)驗(yàn)過程。比如你可以寫，“先定義了一個數(shù)組，里面放了一組隨機(jī)數(shù)，然后用快速排序法處理這個數(shù)組，記錄下運(yùn)行時間?！边@里可能會有點(diǎn)小問題，直接寫成“然后用快速排序法處理這個數(shù)組，記錄下運(yùn)行時間”，稍微有點(diǎn)跳躍感，不過沒關(guān)系，繼續(xù)往下說就行。
結(jié)果部分就得把實(shí)驗(yàn)得到的數(shù)據(jù)列出來，最好還能畫個圖什么的，直觀一點(diǎn)。比如，“經(jīng)過多次測試，平均每次快速排序耗時0.002秒，而冒泡排序耗時0.02秒?！边@部分可以再詳細(xì)點(diǎn)，比如提到數(shù)據(jù)的具體來源，是通過幾次測試得出的平均值之類的。
最后別忘了分析一下結(jié)果，為什么會出現(xiàn)這樣的情況？可能是因?yàn)榭焖倥判蛟诖髷?shù)據(jù)量的情況下性能更好，因?yàn)樗臅r間復(fù)雜度低。不過這里有個小地方需要注意，如果直接寫“可能是因?yàn)榭焖倥判蛟诖髷?shù)據(jù)量的情況下性能更好”，感覺有點(diǎn)太籠統(tǒng)了，要是能具體說說快速排序是怎么工作的，就更清楚了。
整篇報告寫完后，檢查一下有沒有錯別字，標(biāo)點(diǎn)符號是不是都正確，尤其是那些專業(yè)術(shù)語，一定要確保用詞準(zhǔn)確。還有，記得給報告起個合適的標(biāo)題，像“基于C語言的數(shù)據(jù)結(jié)構(gòu)實(shí)驗(yàn)——排序算法性能對比分析”這樣的，既包含了主要內(nèi)容又顯得正式些。
