数据结构实验报告全集

时间：2020-07-27 11:47:41 来源：蒲公英阅读网 本文已影响人

相关热词搜索：数据结构 全集 实验

　数据结构实验报告全集

　实验一

　线性表基本操作与简单程序

　１。

　实验目得 （1）掌握使用Ｖisuaｌ Ｃ＋+ 6、0 上机调试程序得基本方法;）2( 本基得表性线握掌ﻫ操作:初始化、插入、删除、取数据元素等运算在顺序存储结构与链表存储结构上得程序设计方法。

　2． 实验要求 (１）

　认真阅读与掌握与本实验相关得教材内容。

　(2) 认真阅读与掌握本章相关内容得程序. （3）

　上机运行程序。

　(4）

　保存与打印出程序得运行结果,并结合程序进行分析. （5）

　按照您对线性表得操作需要,重新改写主程序并运行，打印出文件清单与运行结果 实验代码：

　１) ) 头文件模块

　#inc ｌ ude i ｏｓｔｒ eam 、h h 〉 // 头文件

　#inc ｌｕd d ｅ＜ mallo ｃ、h h 〉 // 库头文件- - － -- — 动态分配内存空间

　typ ｅd d ｅf f

　ｉ nt ｅ lemtype ； // 定义数据域得类型

　typede ｆ

　str ｕc c ｔ

　linknode// 定义结点类型

　{ {

　e e ｌ em ｔ ype dat ａ； // 定义数据域

　ｓ tr ｕ ct ｌ ink ｎo o ｄe e

　*next ； // 定义结点指针

　}n ｏd d ｅ type ；

　2) 创建单链表

　ｎ od ｅ ty ｐ e ＊ cr ｅ ate （）/ / ／建立单链表, , 由用户输入各结点 a data 域之值, ,

　/ / ／以 0 0 表示输入结束

　｛

　elem ｔ ype d ； // 定义数据元素 d d

　nodetype ＊ h=NU ＬL L ， *s ，＊t t ； // 定义结点指针

　i i ｎｔ

　i=1;

　cou ｔ <<" 建立一个单链表”〈 <end ｌ；

　whi ｌe e （1 1 ）

　｛

　cou ｔ

　＜＜”

　输入第”〈〈

　i < 〈" " 结点 a data 域值：”；

　c c ｉ n 〉＞

　d;

　ｉｆ（d d ＝＝０ )

　 bre ａk k ；/ / ／以 0 0 表示输入结束

　if （i i ==1)// 建立第一个结点

　｛

　h h ＝（ nodetype ＊ )m ａl l ｌ oc(sizeof( ｎ odetype)) ； // 表示指针ｈ

　h h- - >d ａ ta=d ；h h —> > ｎｅ xt ＝Ｎ UL Ｌ；ｔ =h; ／／ｈ就是头指针

　} }

　els ｅ/ / ／建立其余结点

　{ {

　ｓ =( ｎ odet ｙ pe*) ma ｌ loc(size ｏf f （ node ｔ ype ））; ;

　ｓ- - ＞ｄ ata ＝ d;s — 〉 next ＝ＮU U ＬＬ ;t — ＞ｎｅx x ｔ =s ；

　t=s ；t //t 始终指向生成得 单链表得最后一个节点

　｝

　i++ ；

　｝

　retu ｒ n h ；

　} }

　３）输出单链表中得元素

　ｖ oi ｄ

　disp （ node ｔy y ｐｅ＊h h ）／/ / 输出由ｈ指向得单链表得所有ｄａa ta 域之值

　｛

　nodetype ＊ p=h;

　ｃ ou ｔ< < 〈”输出一个单链表 :"<<en ｄｌ＜＜”

　＂；

　ｉ f(p== Ｎ ULL ）ｃo o ｕt t ＜〈”空表”；

　w w ｈ il ｅ（ p!=NU ＬL L ）

　{ {

　cou ｔ< < 〈p p- - 〉ｄａ ta< 〈 ”

　” ；p p ＝ｐ- - 〉 nex ｔ；

　} }

　c c ｏｕt t 〈＜e e ｎ dl ；

　｝

　4 4 ）计算单链表得长度

　int len(no ｄｅ ty ｐ e ＊ｈ）/ / ／返回单链表得长度

　｛

　int i ＝0 0 ；

　ｎｏd d ｅ type ＊ p=h;

　w w ｈ ile(p!=NULL)

　{ {

　p p ＝p p — 〉 nex ｔ ;i++ ；

　｝

　re ｔ urn

　i i ；

　} }

　5) 寻找第 i i 个节点

　node ｔｙｐｅ

　*find(n ｏ detype *h ， int i)// 返回第 i i 个节点得指针

　{ {

　nod ｅ ty ｐe e

　＊ p=h ；

　ｉ nt j=1 1 ；

　if(i 〉ｌ en （ h) ｜ |i<=0)

　r r ｅ tu ｒ n NUL Ｌ；/ / ／i i 上溢或下溢 c c

　els ｅ

　{ {

　while ( ｐ！＝Ｎ ULL ＆& & ｊ〈 1)// 查找第 i i 个节点，并由 p p 指向该节点

　{ {

　j++; ｐ =p- - 〉 next ；

　} }

　retu ｒｎ

　p;

　｝

　} }

　6 6 ）单链表得插入操作

　n n ｏｄe e ｔｙ pe * ｉ ns （ node ｔｙp p ｅ

　* * ｈ ,i ｎ t i ， el ｅ mtype

　x x ）／/ / 在单链表ｈe e ａd d 中第 第 i i 个节点

　／/ / （i i 〉 =0) 之后插入一个 dat ａ域为 x x 得节点

　{ {

　nodetype * ｐ，＊ s;

　ｓ =(nodet ｙ pe ＊) ) ｍ alloc(si ｚ eo ｆ（ no ｄ ety ｐe e ））； // 创建节点 s s

　s s — 〉ｄ ata ＝ｘ；ｓ－ >n ｅ xt ＝N N Ｕ LL;

　i i ｆ（ i==0)//i=0 ：s s 作为该单链表得第一个节点

　{ {

　ｓ — >nex ｔ =h ；ｈ =s;

　｝

　else

　 { { ｐ＝ fi ｎｄ（h h ，i i ）

　;// 查找第 i i 个节点，并由 p p 指向该节点

　if （p p ！

　=NUL Ｌ) )

　｛

　ｓ- - ＞ next=p — 〉 ne ｘt t ；

　p p — 〉 next=s;

　} }

　r r ｅ tu ｒ n h;

　｝

　} }

　7 7 ）单链表得删除操作

　node ｔ ype ＊ del （ nod ｅｔ yp ｅ

　*h, ｉｎｔ

　i)// 删除第 i i 个节点

　{ {

　ｎ odetype ＊ p=h, ＊s s ；

　int

　ｊ= = １; ;

　if （ｉ= = ＝1 1 ）／／删除第 1 1 个节点

　{ {

　ｈ= = ｈ — >next ； free （ p) ；

　} }

　else

　{ {

　p p ＝ fi ｎ d(h ，i i －1 1 ）

　;// 查找第ｉ－1 1 个节点, , 并由 p p 指向该节点

　if(p ！= = ＮU U ＬL L ＆ &p － >n ｅ xt ！

　=NULL)

　｛

　ｓ =p －〉 next; ／／s s 指向要删除得节点

　p p － >ne ｘ t=s － >n ｅ xt ；

　free （ s) ；

　} }

　ｅl l ｓｅ

　co ｕt t ＜ <" 输入ｉ得值不正确 ”< < ＜ endl ；

　｝

　retu ｒ n ｈ; ;

　｝

　8 8 ）释放节点空间

　void ｄｉ spose （n n ｏ det ｙ pe *h)// 释放单链表得所有节点占用得空间

　｛

　no ｄｅ typ ｅ

　＊p p ａ =h ，＊ｐ b;

　if （ｐa a ！

　=N ＵL L Ｌ) )

　{ {

　pb=p ａ — 〉ｎ ex ｔ; ;

　if(pb= ＝ NUL Ｌ）／/ / 只有一个节点得情况

　fr ｅ e( ｐ a);

　el ｓ e

　 { {

　whil ｅ

　（p p ｂ！＝N N Ｕ LL ）／／有 两个及以上节点得情况

　{ {

　f f ｒ ee （ pa ）；p p ａ =pb ； pb ＝ pb — 〉 next ；

　} }

　free （ pa);

　｝

　｝

　｝

　9 9 ）主程序模块：

　＃ｉ nc ｌ ud ｅ＂s s ｌi i ｎｋ、h h ”/ / ／包含头文件 sli ｎk k

　v v ｏ id main( ）

　｛

　no ｄe e ｔｙp p ｅ

　＊ hea ｄ； // 定义节点指针变量

　he ａd d ＝c c ｒｅａt t ｅ () ； // 创建一个单链表

　disp （ hea ｄ）; ; ／/ / 输出单链表

　c c out 〈 <" 单链表长度：”< < 〈ｌ en(h ｅａd d ）〈〈ｅｎd d ｌ；

　ins( ｈ ea ｄ, ,

　2,0 ）； // 在第二个节点之后插入以 0 0 为元素得节点

　ｄ isp （ he ａ d) ；／/ / 输出新链表

　del （h h ｅ ad ，２) ) ；/ / ／删除第二个节点

　ｄ isp(he ａd d ）； // 输出新链表

　｝

　5 5 。实验结果

　建立一个单链表：

　输入第 1 1 结点 d d ａa ta 域值：1 1

　输入第２结点 dat ａ域值：2 2

　输入第 3 3 结点ｄa ata 域值 :3

　输入第 4 4 结点 da ｔa a 域值：４

　输入第 5 5 结点ｄa a ｔａ域值 :5

　输入第 6 6 结点 d d ａt t ａ域值：６

　输入第 7 7 结点 d d ａt t ａ域值：７

　输入第 8 8 结点 d d ａa ta 域值：８

　输入第９结点 d d ａt t ａ域值: : ９

　输入第 0 10 结点 a data 域值０: :

　输出一个单链表：

　１

　２

　3 4 5 ６

　7 ８

　９

　单链表长度：9 9

　输出一个单链表：

　1 ０

　２

　3 4

　５

　６

　7 8

　9 9

　输出一个单链表：

　1 2 3 4 5 6 7 8

　实验二

　顺序栈得实现

　1、实验目得 掌握顺序栈得基本操作:初始化栈、判栈空否、入栈、出栈、取栈顶数据元素等运算以及程序实现方法。

　2、实验要求 （１）

　认真阅读与掌握与本实验相关得教材内容。

　(2) 分析问题得要求,编写与调试完成程序. (3）

　保存与打印出程序得运行结果，并分析程序得运行结果。

　3、实验内容

　是就号括方、号括圆含包中式达表术算断判个一现实作操本基得栈用利ﻫ否正确配对得程序。具体完成如下：

　（１）

　定义栈得顺序存取结构。

　（２) 分别定义顺序栈得基本操作（初始化栈、判栈空否、入栈、出栈等)。

　（3）

　定义一个函数用来判断算术表达式中包含圆括号、方括号就是否正确配对。其中,括号配对共有四种情况:左右括号配对次序不正确；右括号多于左括号;左括号多于右括号;左右括号匹配正确.

　（4）

　设计一个测试主函数进行测试。

　(5) 对程序得运行结果进行分析. 实验代码：

　＃incluｄe ＜stdio、h >＃ﻫ０0１ eziSxaM enｉfｅdﻫ

　ｔypedｅｆ sｔruｃｔ {

　 ｉnt data［ＭaｘＳize]；

　 inｔ tｏｐ; ｝SｑＳtack; voiｄ IniｔSｔack（SqStａck *st）

　//初始化栈 ｛

　 ；１—=pot>—tsﻫ｝ﻫint SｔackＥｍpｔy（SqStaｃｋ ＊sｔ) ／/判断栈为空 ｛

　 ；)1—=＝pｏｔ〉-ｔs（ nruteｒﻫ}ﻫｖｏid Pusｈ(SｑＳｔack *ｓt,int x）

　／/元素进栈

　ﻫ｛pot>-ts（ｆiﻫ＝＝MａｘＳize-1)

　 printf（＂栈上溢出!\n"）；

　 ｅｓleﻫ{

　ﻫ

　st-〉top++;

　 ;x=］pot〉－ts［ataｄ>－tｓﻫ

　｝ }ﻫvoiｄ Pｏp（SqSｔaｃk *st）

　//退栈

　ﻫ｛）1-==pot＞－ts（fiﻫ

　 ;)”n\出溢下栈＂（fｔｎｉｒpﻫ

　eｓleﻫ

　st—〉top-—； ｝ int Ｇeｔtop(SqStack ＊st）

　/／获得栈顶元素 {

　 iｆ（st—〉ｔop==—1) ｛

　ﻫ

　printｆ（"栈空＼n”）;

　 ；0 nrｕterﻫ

　}

　 eｓlｅﻫ

　retｕrn st—〉datａ［st－>ｔｏp］; } voｉd Diｓpｌay(SqＳtaｃk *st）

　//打印栈里元素 {ﻫ

　ｉｎt i；

　 prｉntf（＂栈中元素:"）；

　 for(ｉ＝ｓt-〉toｐ;i＞=０；--i）

　 d％”（ftnirpﻫ",ｓt－＞datａ[i］）；

　ﻫ；）＂n\”(ftnirｐﻫ｝测／/ )(niam ｔnｉﻫ试

　ﻫ｛ ；L kｃatSqSﻫ

　;Ｌ＆=ｔｓ＊ kcatSqSﻫ

　 ｎIﻫitStack（st）；

　；））ｔs（yｔpmEkcａtS，"n\ｄ%：空栈"(ｆｔｎｉrpﻫ

　 ）i++;０1<ｉ；１=ｉ tni（ｒofﻫ

　 ；)i，tｓ（hsuPﻫ

　 ；)ｔs（yalpｓｉＤﻫ

　printｆ（"退一次栈\ｎ")；

　 Pｏp（ｓt);

　ｐrinｔf("栈顶元素:％d\n＂，Gｅttｏp（ｓｔ)）；

　poＰﻫ（st）;

　 ；）ts(yａlｐsiDﻫ

　 ﻫ}；0 ｎruterﻫ

　实验结果: :

　 实验三

　串得基本操作与简程序 1。

　实验目得 掌握串基本操作：初始化、联接、替换、子串等运算在堆分配存储储结构上得程序设计方法。

　２． 实验要求 (１) 认真阅读与掌握与本实验相关得教材内容. (2）

　认真阅读与掌握本章相关内容得算法并设计程序序。

　（3）

　上机运行程序。

　(4) 保存与打印出程序得运行结果,并结合程序进行分析. 实验代码：

　#inc ｌ ude ＜ stdio 、 h>

　＃d d ｅ fi ｎe e

　MaxSize 50

　type ｄ ef ｓ tr ｕ ct

　{ {

　ｃh h ａ r data ［ Ma ｘ Siz ｅ］；

　// 存放字符串

　int len ｇｔh h ；

　// 字符串 长度

　｝ SqString ；

　／/ / 将一个字符串常量赋给串 s s

　ｖ oid

　StrAssign(SqStr ｉn n ｇ

　＆ s,c ｈa a ｒ

　c c ｓｔ r[])

　｛

　i i ｎt t

　i i ；

　for(i ＝０ ;cstr[i] ！= = ＇\ \ 0";i++ ）

　／/ / 这个＇\ \0 0 ＇代表字符串结束标志, , 编译系统自动加上得

　ｓ、 dat ａ [i]=cs ｔ r[i];

　s s 、 len ｇ th=i;

　｝

　// 字符串得复制

　vo ｉ d StrCopy （Ｓ qStr ｉ ng & ｓ，S S ｑ St ｒi i ｎ g t)

　{ {

　ｉｎ t i;

　ｆ or(i=0;i 〈ｔ、ｌｅ ngt ｈ；ｉ ++ ）

　s s 、ｄ at ａ [i ］ =t 、 data[i];

　ｓ、 le ｎ gt ｈ =t 、ｌ ength ；

　p p ｒ intf( ＂字符串复制成功了\ \n n ”) ) ；

　｝

　// 判断字符串就是否相等

　vo ｉｄ

　St ｒＥq q ｕａｌ (SqStrin ｇ

　s s ，Ｓ qSt ｒi i ｎ g t)

　｛

　in ｔ

　i, ｓ ame= １；

　ｉf f （s s 、ｌ ength!=t 、ｌ en ｇ th ）

　sa ｍ e=0 ；

　el ｓｅ

　{ {

　for （ i= ０；i i 〈s s 、 length;i++ ）

　if( ｓ、 da ｔ a[i ］ !=t 、ｄa a ｔa a ［ｉ］）

　｛

　sa ｍe e ＝０; ;

　ｂ reak ；

　｝

　｝

　ｉ f(same==0 ）

　p p ｒｉn n ｔ f(" 这两个字符串不相等\ \ n" ）; ;

　else

　p p ｒ int ｆ（" " 这两个字符串相等\ \n n ”) ) ；

　｝

　/ / ／字符串得长度

　ｖ oid

　Ｓ trLe ｎ gth(SqS ｔr r ｉn n ｇ

　ｓ）

　｛

　pr ｉn n ｔf f （”此字符串长度为：％d d\ \ n" ，s s 、ｌ eng ｔｈ) )； ；

　｝

　// 合并字符串

　Sq Ｓ tring Co ｎ cat （Ｓ qString

　s,Sq Ｓ tring t)

　{ {

　Ｓ qS ｔ ri ｎｇ

　s s ｔｒ；

　in ｔ

　i i ；

　ｓ tr 、ｌｅｎ gth=s 、 len ｇ th+t 、ｌ en ｇt t h;

　for( ｉ =0 ；ｉ＜s s 、 le ｎ gt ｈ； i++ ）

　str 、d d ａt t ａ［ i] ＝s s 、 data ［i i ］; ;

　for(i=0 ；ｉ〈t t 、ｌ eng ｔ h;i++)

　str 、ｄa a ｔa a ［ｓ、l l ｅ ngt ｈ＋ i] ＝ｔ、 data ［ i];

　ｒ eturn str;

　｝

　/ / ／求子字符串

　void

　SubStr （ＳｑS S ｔ ri ｎ g s ， in ｔ

　i i ，ｉn n ｔ

　j)

　｛

　SqStr ｉ ng

　ｓt t ｒ; ;

　ｉ nt

　ｋ；

　ｓ tr 、l l ｅ ngth= ０；

　i i ｆi (i 〈 =0| ｜i i〉 〉s s、 、 len ｇt t ｈ| | ｜ j<0 ｜ |i+j- - １> > ｓ、ｌe e ngth)

　pri ｎ tf(" 子字符串复制失败＼n n ＂ );

　ｆ or （ k= ｉ－ 1;k 〈 i+j- -1 1 ；k k ＋+ + ）

　st ｒ、 dat ａ［k k —i i ＋ 1]=s 、d d ａ ta[k] ；

　ｓｔr r 、ｌ ength=j;

　printf （" " 子字符串复制成功

　长度为：

　%d\ \ ｎ＂, , ｊ) ) ；

　print ｆ( ( ”下面输出此子字符串：＼n n ＂ );

　f f ｏr r （ｉ =0 ；ｉ <j ； i++)

　ｐr r ｉ ntf （ ” ％ｃ ”, ｓt t ｒ、 data[i ］) ) ；

　printf(”\ \ ｎ ” ）；

　} }

　// 插入字符串

　Ｓ qStri ｎ g Ｉ ns ｅ rStr(S ｑ Str ｉｎｇ

　s1 ， int ｉ ,SqS ｔring s ２) )

　{ {

　int

　j j ；

　Sq Ｓ tr ｉn n ｇ

　str;

　ｓ tr 、 length=0 ；

　if （i i 〈= = ０｜｜ i>s1 、 length+1)

　{ {

　pr ｉn n ｔf f （”字符串插入失败＼ n" ）; ;

　retu ｒｎ

　str ；

　} }

　for （ j= ０; ; ｊ <i- -1 1 ；ｊ ++ ）

　ｓｔr r 、ｄ ata ［ｊ］＝ s1 、ｄａ ta[j];

　for （ j=0; ｊ〈ｓ2 2 、 lengt ｈ； j++)

　s s ｔr r 、 dat ａ [i- -1 1 ＋j j ］ =s2 、d d ａ ta[j ］；

　ｆo o ｒ（ｊ =i －1 1 ；j j ＜s s １、ｌ eng ｔ h;j++ ）

　st ｒ、 da ｔａ [s2 、ｌｅ ngt ｈ +j] ＝ s1 、 data ［ j];

　ｓ tr 、 leng ｔh h ＝ｓ1 1 、 le ｎｇ th+ ｓ2 2 、l l ｅｎｇ th ；

　printf （" " 插入字符串成功

　长度为：％d d\ \n n ”，s s ｔｒ、ｌｅngth ）；

　retu ｒ n st ｒ; ;

　｝

　/ / ／删除字符串

　Sq Ｓｔ ring DeleS ｔｒ（ SqStri ｎ g s ， int ｉ，ｉ nt

　）

　ｊ）

　｛

　ｉ nt k ；

　Ｓq q Ｓt t ｒi i ｎｇ

　s s ｔr r ；

　s s ｔr r 、ｌ eng ｔh h ＝ 0;

　if （ i<=0 ｜ |i>s 、ｌ engt ｈ｜｜ i+ ｊ >s 、 le ｎｇｔ h+1)

　{ {

　ｐｒi i ｎ tf （＂字符串删除失败＼n n ”）；

　return

　str;

　｝

　f f ｏ r( ｋ= = ０；k k 〈i i- - １；k k ＋ +)

　ｓ tr 、 da ｔ a[k] ＝s s 、ｄ ata ［ｋ ];

　for （ k=i+j — １；ｋ〈ｓ、 leng ｔh h ； k++ ）

　s s ｔｒ、 data ［k k －ｊ ]=s 、 data[k ］；

　str 、 length=s 、l l ｅ ngt ｈ —j j ；

　pri ｎt t ｆ( ( ＂删除子字符串成功

　剩余长度为: : ％d d ＼ n", ｓtr 、 le ｎ gth) ；

　re ｔｕ rn str ；

　｝

　// 替换字符串

　voi ｄ

　R R ｅｐ Str(SqStr ｉｎ g s,int

　i i ,i ｎt t

　j, Ｓ qString t)

　｛

　i i ｎt t

　ｋ；

　S S ｑ String

　str ；

　s s ｔｒ、 length ＝0 0 ；

　if(i<= ０｜｜i i 〉s s 、 le ｎｇ th||i+j — 1>s 、ｌ eng ｔh h ）

　pri ｎ tf （" " 字符串替换失败了\ \n n ＂）; ;

　ｆ or(k=0;k ＜i i — 1; ｋ＋＋）

　st ｒ、 dat ａ [k ］= = ｓ、ｄａt t ａ［k k ］；

　for( ｋ =0;k<t 、l l ｅｎg g ｔh h ；ｋ＋+ + ）

　str 、ｄ at ａ［ i+k- - １］ =t 、d d ａ ta ［k k ］；

　for （ k=i ＋j j －１; ; ｋ <s 、 le ｎ gt ｈ； k++)

　str 、d d ata ［t t 、ｌ ength+k- -j j ］ =s 、ｄ ata[k ］；

　s s ｔｒ、l l ｅｎg g ｔ h= ｓ、 le ｎ gth- - j+t 、l l ｅn n ｇ th ；

　p p ｒi i ｎt t ｆ( ( ”替换字符串成功

　新字符串长度为：％d d\ \n n ”，str 、 length) ；

　｝

　// 字符串得输出

　ｖ oi ｄ

　Di ｓｐ St ｒ（ SqString

　s s ）

　｛

　int i ；

　if( ｓ、ｌｅ ng ｔ h> ０) )

　｛

　ｐｒｉ nt ｆ（＂下面输出这个字符串\ \n n ＂) ) ；

　fo ｒ（i i ＝ 0;i 〈s s 、ｌe e ｎg g ｔ h;i ＋+ + ）

　p p ｒ intf(" ％ｃ＂，ｓ、 da ｔa a ［ｉ］）; ;

　ｐ ri ｎt t ｆ( ( ＂\ \ n”) ；

　} }

　ｅｌ se

　print ｆ（＂目前空字符串

　无法输出＼ n" ）；

　} }

　void main （）

　{ {

　S S ｑS S ｔ ring s;

　char a ［] ] ＝{ { ＂ we ｎ

　x x ｉａn n

　ｌｉａ ng ＂} } ；

　// 字符串常量ａ

　Ｓt t ｒＡ ssig ｎ（s s ，ａ）；

　Ｄ ispS ｔ r(s ）；

　StrL ｅｎｇt t ｈ（ s);

　SqS ｔr r ｉ ng

　s s １ ,s2,t;

　1 //s1 就是待复制得字符串变量

　ｐr r ｉn n ｔ f(" 请输入一个字符串ｔ：\ \n n ”) ) ；

　scan ｆ (" ％s s ＂ ,t 、ｄ ata ）；

　StrAssi ｇｎ (t ，t t 、ｄa a ｔ a);

　S S ｔ rCopy(s1 ，t t ）；

　// 复制字符串

　Ｓt t ｒＬe e ｎｇｔh h （ s1) ；

　Dis ｐ Str(s １) ) ；

　p p ｒ in ｔ f("串 下面判断字符串 1 s1 串 与字符串 s s 就是否相等＼ｎ＂）；

　StrE ｑ ua ｌ（s s ， s1) ；

　printf(" 下面将字符串 s s １与字符串 s s 合并一起＼ｎ" " ）；

　Sq Ｓ trin ｇ

　str ；

　s s ｔr r ＝ Concat(s ， s1) ；

　／/ / 合并字符串

　DispStr(st ｒ）；

　StrLength （ str) ；

　Ｓu u ｂＳ tr （ st ｒ, , ２2 2 ，7 7 ）；

　/ / ／求子字符串

　s s ｔr r ＝ DeleS ｔｒ (st ｒ ,1 ５ ,4) ；

　// 删除字符串

　Ｄi i ｓp p Ｓ tr （ st ｒ）; ;

　St ｒ Length （ str) ；

　p p ｒi i ｎ tf(" 请插入一个字符串ｓ2 2\ \n n ”）; ;

　s s ｃ anf （ ” ％ｓ ",s ２、d d ａt t ａ) ) ；

　St ｒ As ｓ ig ｎ (s2, ｓ２、 dat ａ );

　ｓｔｒ＝ Ins ｅ rS ｔ r(s ｔｒ， 15 ， s2 ）

　;

　／/ / 插入字符串

　D D ｉ spS ｔ r(st ｒ）；

　Str Ｌ ength （ st ｒ）; ;

　printf( ＂顺序字符串得基本运算到此结束了\ \ ｎ”) ) ；

　｝

　实验结果：

　实验四

　编程建立二叉树, 对树进行插入删除及遍历得程序

　1、实验目得 （1）

　进一步掌握指针变量得用途与程序设计方法。

　（2）

　掌握二叉树得结构特征,以及链式存储结构得特点及程序设计方法。

　(３）

　掌握构造二叉树得基本方法。

　(４）

　掌握二叉树遍历算法得设计方法. 3． 实验要求 （1)认真阅读与掌握与本实验相关得教材内容。

　(2）掌握一个实际二叉树得创建方法. (3）掌握二叉链存储结构下二叉树操作得设计方法与遍历操作设计方法。

　4。

　实验内容 (1）定义二叉链存储结构. （2)设计二叉树得基本操作（初始化一棵带头结点得二叉树、左结点插入、右结点插入、中序遍历二叉树等)。

　（3）按照建立一棵实际二叉树得操作需要,编写建立二叉树、遍历二叉树得函数. (4）编写测试主函数并上机运行。打印出运行结果,并结合程序运行结果进行分析。

　实验代码: ＃ｉ nclu ｄ e<i ｏs s ｔ re ａm m 、h h ＞

　ｔ ypede ｆ

　s s ｔ ruc ｔ

　bi ｔ nod ｅ｛

　ｃh h ａ r ｄa a ｔａ; ;

　ｓ tr ｕｃ t bitnod ｅ

　* * ｌ chi ｌ d, ＊ rchi ｌd d ；

　}bino ｄe e ，* * ｂ itre ｅ；

　void createbit ｒ ee(bi tr ｅ e ＊Ｔ）｛

　ｃｈ ar ｃ h;

　c c ｉ n>>ch ；

　if(ch ＝ ="0 ＇）

　(*T ）＝ NULL ；

　else ｛

　＊（＝）Ｔﻩ （＊Ｔ）＝ ne ｗ

　ｂ it ｎ ode;

　（ *T)- -> > ｄａｔａ= = ｃｈ；

　crea ｔ ebitree （ &( ＊ T) — 〉l l ｃ hild) ；

　create ｂｉ tre ｅ( ( ＆（＊T T ）

　— 〉r r ｃ hil ｄ）; ;

　} }ﻩ｝

　void ｉn n ｏ rd ｅ rout （ｂ itr ｅ e T) ｛

　if （Ｔ ){

　droniﻩ inord ｅ ro ｕ t(T- -> > ｌc c ｈｉｌd d ）; ;

　ｏc cﻩﻩ ｏ ut ＜＜T T- - >data ＜ <end d ｌ; ;

　tuoredroniﻩﻩ inorderout （Ｔ- - 〉 rchi ｌd d ）；

　} }ﻩ} }

　void p ｏs s ｔ ord ｅr r （ bitree T) ｛

　if(T) ｛

　po ｓ torder(T- - >l ｃ hi ｌ d) ；

　postor ｄe e ｒ (T — ＞r r ｃ hil ｄ) ) ；

　cout<<T －〉 data 〈 <endl ；

　｝

　｝

　ｉn n ｔ

　countleaf （ bit ｒ ee

　ｂｔ ){

　i i ｆ（ !bt)

　erﻩ re ｔ urn ０；

　ｉf f （b b ｔ－ >lc ｈi i ｌｄ ==N Ｕ LL&& ｂt t- - >rchild==NUL）

　Ｌ）

　ret ｕｒn n

　1 1 ；

　r r ｅ turn ( ｃ oun ｔ lea ｆ（ｂｔ- - 〉 lc ｈi i ｌd d ）+ + ｃｏ untｌ eaf （b b ｔ- - ＞ｒc c ｈｉ ld ））; ;

　} }

　voi ｄ

　ｍ ai ｎ( ( ）{ {

　ｂ it ｒｅｅ

　ｂ t;

　creat ｅ bit ｒ ee （＆ｂt t ）；

　in ｏ rd ｅｒ out( ｂ t) ；

　cou ｔ <<" ＂< < 〈 endl ；

　postorder （ bt) ；

　countlea ｆ( ( ｂt t ）；

　｝

　 实验五 建立有序表并进行折半查找 1、 实验目得 掌握递归算法求解问题得基本思想与程序实现方法. 2.实验要求)1（

　.想思法算得验实本握掌与读阅真认ﻫ(2）编写与调试完成程序. （3)保存与打印程序得运行结果,并对运行结果进行分析。

　3、实验内容 （１) 分析掌握折半查找算法思想,在此基础上,设计出递归算法与循环结构两种实现方法得折半查找函数. （2）

　编写程序实现:在保存于数组得 100０个有序数据元素中查找数据元素ｘ就是否存在。数据元素ｘ要包含两种情况:一种就是数据元素 x 包含在数组中；另一种就是数据元素x 不包含在数组中 （3）

　数组中数据元素得有序化既可以初始赋值时实现,也可以设计一个排序函数实现。

　（４) 根据两种方法得实际运行时间，进行两种方法时间效率得分析对比。

　实验代码: ＃iｎclude＜stdｉo、h> #incluｄｅ<stｄlib、ｈ> ＃defiｎe MAX＿LENGTＨ

　100 typeｄｅf int KｅyＴype；

　ｔｙpedｅf sｔｒucｔ {

　int ｋｅy； }EleｍＴype； tｙｐｅdef struct ｛

　出空元单号 0 /／

　 ；]HTGＮＥL_XAＭ[mｅle epyTｍｅlＥﻩ

　iｎt lｅnｇｔｈ; }SSTable; int Searｃh＿Bin(SSＴabｌe SＴ,KeyType kｅy) ｛

　 int low,higｈ，miｄ;

　loｗ = 1；hｉgh = ST、leｎgtｈ；

　 ｗｈile（low ＜=ｈiｇｈ）

　｛

　 mｉd = (lｏw+ｈigh)/2；

　 )ｙeｋ、］ｄｉm[mele、TS== yek(fiﻩﻩ

　ﻩ

　 retｕｒn mｉd；

　 ｅsｌeﻩ ﻩ

　 ）yek、]dim[mｅle、TS〈yｅk(fiﻩ ﻩ

　 ;1—dim = ｈgihﻩ ﻩﻩ

　 ｅlse

　ﻩ

　 lｏw=ｍiｄ+１;

　}

　ﻩ

　retuｒｎ 0; ｝ voiｄ ｍain（) ｛

　iｎt i，ｒeｓult；

　；TS eｌｂａTSSﻩ ；ｙek epyTyeＫﻩ printf（＂plｅasｅ inｐｕt lｅngｔh:＂);

　scanｆ(＂%d",＆ST、ｌeｎgtｈ）；

　）＋+ｉ;hｔgｎeｌ、TS=＜ｉ；1=i（ｒｏfﻩ {ﻩ

　;）"：mｅｌe、TＳ ｔｕｐｎi eｓaｅlp"（fｔniｒpﻩ

　scanf（"％d＂，＆ST、elｅｍ［i]）;

　｝

　ｐrｉntf("pｌｅase iｎput keywｏrd:"）;

　 scａｎf("%ｄ"，&kｅy);

　result=Search_Ｂｉｎ（SＴ，key);

　)０＝＝ｔlｕsｅr(ｆiﻩ

　pｒiｎｔf（”Ｄoｎ"t ｆｉnｄ\n"）;

　esleﻩ

　ｐrｉntf(”Fiｎd the kｅｙ，thｅ positiｏn iｓ ％d＼n＂，resｕlｔ)； } 实验结果:

　实验六 建立一组记录并进行插入排序 1、 实验目得 （1）

　掌握插入排序算法得思想. （2）

　掌握顺序队列下插入排序算法得程序设计方法。

　2、 实验要求 ）1(

　。想思得法算序排入插中材教握掌与读阅真认ﻫ（3) 编写基于顺序队列得插入排序排序算法并上机实现。

　３、 实验内容 （1) 编写基于顺序队列得插入排序函数。

　（2) 设计一个测试主函数，实现对基于顺序队列结构得插入排序算法得测试. （３）

　分析程序得运行结果。

　实验代码: ＃include〈sｔｄiｏ、h> #ｉncluｄe〈sｔdliｂ、ｈ> ＃definｅ MAＸSIZE １0０ typｅdef struｃt

　｛

　iｎt kｅｙ; }sｏrｔkeｙ； typedef stｒuct ｛

　ｓortkｅy elem[ＭAＸＳIZE];

　ｉｎt lengｔh； ｝sortelｅｍ; vｏiｄ InsｅrtSort（sorteleｍ *ｐ) ｛

　ｉnt ｉ，j;

　ｆｏｒ(i=2；ｉ<=ｐ-〉length；i＋＋)

　｛

　iｆ（ｐ-＞eleｍ［i]、ｋｅｙ＜ｐ－＞elem［i-1］、key）／＊小于时，需将 eｌeｍ［i］插入有序表＊/

　｛

　p—>eleｍ[0]、key=ｐ—>ｅlem［i］、ｋｅy； /＊为统一算法设置监测＊/

　for（j=ｉ—1；p－>eｌeｍ[0］、key〈p－>elem［j］、ｋeｙ；j—－）

　 p->ｅleｍ[ｊ+1］、key=p—〉eｌｅｍ[j］、ｋeｙ;/＊记录后移＊/

　 p-〉eｌｅm[j+1]、kｅy＝p－>eｌｅm[0］、ｋeｙ； /*插入到正确位置＊／

　}

　} } void main（) {

　sｏrteｌem ＊ｐ; int i; int b[6]={45,23,54,6，4，46}; p＝（sorteｌem *)mａllｏｃ（sｉｚeof(sorteleｍ)）; ｐ—〉lenｇth=０； foｒ(i=1；ｉ＜7；i++）

　｛

　p—>elｅm［i]、key=b[i—1］；

　ｐ->length+＋; } InｓeｒｔSorｔ（ｐ）; for(i=1;i＜７；i++) ｛

　prinｔｆ（”%d

　"，p—>elem［i］、ｋey）； ｝ sｙstem（"pause"）； } 实验结果:

　 实验七

　建立一组记录并进行快速排序 1、 实验目得 （１）

　掌握快速排序算法得思想. （2) 掌握顺序队列下快速排序算法得程序设计方法。

　2、 实验要求 ）1(

　。想思得法算序排速快中材教握掌与读阅真认ﻫ（3）

　编写基于顺序队列得快速排序排序算法并上机实现。

　3、 实验内容 （1) 编写基于顺序队列得快速排序函数。

　（2) 设计一个测试主函数，实现对基于顺序队列结构得快速排序算法得测试. (3）

　分析程序得运行结果。

　实验代码: ＃includｅ〈iostｒeam、h〉 ｖｏｉd quick_sｏrt(int a［],int loｗ， ｉnｔ higｈ）

　｛

　ｉnt i,j,pivｏt；

　if （low < ｈiｇh）

　｛

　piｖot ＝ a［low］；

　ｉ = lｏw;

　ｊ = ｈiｇh；

　whiｌe (i < j）

　｛

　//从顶端开始比较值，如果小于标准值，停止

　ｗhiｌe （i < j ＆＆ a[ｊ］ ＞= pｉｖot)

　｛

　j－-;

　｝

　/／将比 pivot 小得元素移到低端，下标加加

　if (ｉ ＜ j)

　a[ｉ＋+] = a[j];

　//从底端开始比较值，如果大于标准值，停止

　while （i < j &＆ a[i］ <＝ pivot）

　｛

　ｉ+＋;

　｝

　／/将比 pivot 大得元素移到顶端,下标减减

　 if (i 〈 j)

　a［ｊ--] = ａ[i]；

　｝

　/／pivot 移动到最终位置

　a［ｉ] ＝ ｐivｏｔ；

　/／对左区间进行递归排序

　quick_ｓort(a， loｗ， ｉ—１）；

　／/对右区间进行递归排序

　qｕick_sｏrt（a， i＋1， hｉgｈ)；

　}

　}

　voｉｄ print＿array（int a[］， int ｎ）

　｛

　ｆoｒ（inｔ i = 0; ｉ 〈 ｎ； i++）

　｛

　cｏut <〈 a[i] 〈< ",";

　}

　｝

　inｔ ｍaiｎ（)

　｛

　int ｄaｔa［9］ = {54，3８，96,２3,１5，72,６0，4５,８3｝；

　ｑｕick_ｓort（dａta, 0， ８）；

　ｐｒint_arrａy(data，9）；

　reｔｕrｎ 0；

　}

　 实验结果：