数据结构代码Word文件下载.docx

数据结构代码Word文件下载.docx

《数据结构代码Word文件下载.docx》由会员分享，可在线阅读，更多相关《数据结构代码Word文件下载.docx（57页珍藏版）》请在冰豆网上搜索。

=h;

i++）

if（（p=（listline*）malloc（sizeof（listline）））==NULL）

{

printf（"

exit

（1）;

}

p->

next=NULL;

r->

next=p;

输入第%d个元素:

"

i）;

scanf（"

%s"

&

p->

data）;

r=p;

voidprint（void）

temp=head->

next;

\n"

while（temp!

=NULL）

%s"

temp->

temp=temp->

voidturnlist（）

{/*倒置链表函数*/

r=head->

p=r->

r->

while（p!

temp=p->

next=r;

p=temp;

head->

voidinsert（intn,charnewdata[10]）

intj;

p=head->

j=0;

while（p&

&

j<

n）

p=p->

j++;

r=（listline*）malloc（sizeof（listline））;

strcpy（r->

data,newdata）;

next=p->

p->

voiddel_list（intn）

chare[10];

r=p->

next=r->

strcpy（e,r->

free（r）;

voidmain（void）

intselect,length,n;

charname1[10];

head=NULL;

while

（1）

menu（）;

%d"

select）;

switch（select）

case1:

\n请输入你要建立的链表的长度:

scanf（"

length）;

creater（length）;

\n以下为你链表中的所有元素:

puts（"

print（）;

\n链表已创建,返回\n"

getchar（）;

break;

case2:

if（head==NULL）

\n请先建立链表,按任意键返回\n"

getchar（）;

break;

请输入你要在第几个元素后面插入新元素:

n）;

请输入你要插入的新元素:

scanf（"

name1）;

insert（n,name1）;

\n插入成功，以下为插入后的链表:

case3:

请输入你要删除第几个元素:

del_list（n）;

\n删除成功，以下为插入后的链表:

case5:

{

printf（"

\n\n出错,返回\n"

break;

}

else

\n以下为原链表:

print（）;

\n\n以下为倒置后的链表:

turnlist（）;

\n\n倒置成功,按任意键返回\n"

getchar（）;

case6:

case7:

exit（0）;

default:

\n输入错误，请重新选择，返回\n"

//text1.cpp:

//

iostream"

usingnamespacestd;

#definestack_init_size100

#definestackincreament10

structSqstack

char*top;

char*base;

intstacksize;

};

voidinitstack（Sqstack&

S）

S.base=（char*）malloc（stack_init_size*sizeof（char））;

if（!

S.base）

puts（"

error"

S.top=S.base;

S.stacksize=stack_init_size;

voidpush（Sqstack&

S,chare）

if（S.top-S.base>

=S.stacksize）

S.base=（char*）realloc（S.base,（S.stacksize+stackincreament）*sizeof（char））;

if（!

S.top=S.base+S.stacksize;

S.stacksize+=stackincreament;

*S.top++=e;

voidpop（Sqstack&

S,char&

e）

if（S.top==S.base）

e=*--S.top;

intgettop（SqstackS,char&

e=*（S.top-1）;

return（e）;

intempty（Sqstack&

return1;

else

return0;

intmain（）

structSqstackS;

charstr[20]={0};

initstack（S）;

输入一串表达式:

gets（str）;

inti=0,flag1=0,flag2=0;

chare1,e2;

inta=-1;

while（a!

=1）

switch（str[i]）

case'

#'

:

a++;

break;

（'

push（S,'

['

{'

）'

if（gettop（S,e1）=='

）

pop（S,e2）;

else

push（S,'

flag1=1;

break;

]'

}'

default:

i++;

if（empty（S））

表达式合法"

表达式不合法"

int*top;

int*base;

S.base=（int*）malloc（stack_init_size*sizeof（int））;

S,inte）

S.base=（int*）realloc（S.base,（S.stacksize+stackincreament）*sizeof（int））;

S,int&

voidgettop（SqstackS,int&

inta,b=0;

pleaseenteranumberyouwanttochange"

a）;

enteraHexadecimalnumbersyouwant"

while（a）

push（S,a%n）;

a=a/n;

while（!

empty（S））//用while输入所有的数据

pop（S,b）;

cout<

<

b<

;

//多打一个空格，用于区分数据

typedefstructQnode

chardata;

structQnode*next;

}Qnode,*QueuePtr;

typedefstruct

QueuePtrfront;

QueuePtrrear;

}LinkQueue;

charinitQueue（LinkQueue&

Q）

Q.front=Q.rear=（QueuePtr）malloc（sizeof（Qnode））;

Q.front）

error/n"

Q.front->

charDestoryQueue（LinkQueue&

while（Q.front）

Q.rear=Q.front->

free（Q.front）;

Q.front=Q.rear;

charEnQueue（LinkQueue&

Q,chare）

p=（QueuePtr）malloc（sizeof（Qnode））;

p）

data=e;

Q.rear->

Q.rear=p

charDeQueue（LinkQueue&

Q,char&

if（Q.front==Q.rear）

p=Q.front->

e=p->

data;

if（Q.rear==p）

Q.rear=Q.front;

free（p）;

voidmian（void）

二叉树

1．对题目要有需求分析

在需求分析中，将题目中要求的功能进行叙述分析，并且设计解决此问题的数据存储结构，设计或叙述解决此问题的算法。

给出实现功能的一组或多组测试数据，程序调试后，将按照此测试数据进行测试的结果列出来。

如果程序不能正常运行，写出实现此算法中遇到的问题和改进方法；

2．对题目要有相应的源程序

源程序要按照写程序的规则来编写。

要结构清晰，重点函数的重点变量，重点功能部分要加上清晰的程序注释。

（注释量占总代码的四分之一）

程序能够运行，要有基本的容错功能。

尽量避免出现操作错误时出现死循环；

3．最后提供的主程序可以象一个应用系统一样有主窗口，通过主菜单和分级菜单调用课程设计中要求完成的各个功能模块，调用后可以返回到主菜单，继续选择其他功能进行其他功能的选择。

二叉树的建立与遍历

[问题描述]

　　建立一棵二叉树，并对其进行遍历（先序、中序、后序），打印输出遍历结果。

[基本要求]

　　从键盘接受输入，以二叉链表作为存储结构，建立二叉树，并对其进行遍历（先序、中序、后序），将遍历结果打印输出。

以下是我的数据结构实验的作业：

肯定好用，里面还包括了统计树的深度和叶子数！

记住每次做完一个遍历还要重新输入你的树哦！

string.h"

#defineNULL0

typedefstructBiTNode{

chardata;

structBiTNode*lchild,*rchild;

}BiTNode,*BiTree;

BiTreeCreate（BiTreeT）{

charch;

ch=getchar（）;

if（ch=='

）

T=NULL;

else{

if（!

（T=（BiTNode*）malloc（sizeof（BiTNode））））

printf（"

Error!

T->

data=ch;

lchild=Create（T->

lchild）;

rchild=Create（T->

rchild）;

}

returnT;

voidPreorder（BiTreeT）{

if（T）{

%c"

T->

Preorder（T->

intSumleaf（BiTreeT）{

intsum=0,m,n;

if（（!

lchild）&

（!

rchild））

sum++;

m=Sumleaf（T->

sum+=m;

n=Sumleaf（T->

sum+=n;

returnsum;

voidzhongxu（BiTreeT）{

zhongxu（T->

voidhouxu（BiTreeT）{

houxu（T->

intDepth（BiTreeT）{

intdep=0,depl,depr;

T）dep=0;

depl=Depth（T->

depr=Depth（T->

dep=1+（depl>

depr?

depl:

depr）;

returndep;

main（）{

BiTreeT;

intsum,dep;

T=Create（T）;

Preorder（T）;

zhongxu（T）;

houxu（T）;

sum=Sumleaf（T）;

sum）;

dep=Depth（T）;

\n%d"

dep）;

二叉树2

/*二叉树的建立与遍历*/

#include<

stdio.h>

stdlib.h>

typedefintEtype;

typedefstructBiTNode/*树结点结构*/

{Etypedata;

structBiTNode*lch,*rch;

}BiTNode;

/*函数原形声明*/

BiTNode*creat_bt1（）;

BiTNode*creat_bt2（）

voidinorder（BiTNode*p）;

voidnumb（BiTNode*p）;

BiTNode*t;

intn,n0,n1,n2,;

/*主函数*/

main（）

{charch;

intk;

do{printf（"

\n\n\n"

\n\n1.建立二叉树方法1"

\n\n2.建立二叉树方法2"

\n\n3.中序递归遍历二叉树"

\n\n4.计算树中结点个数"

\n\n5.结束程序运行"

\n======================================"

\n请输入您的选择（1,2,3,4,5,6）"

k）;

switch（k）

{case1:

t=creat_bt1（）;

/*调用性质5建立二叉树算法*/

case2:

t=creat_bt2（）;

/*调用递归建立二叉树算法*/

case3:

{inorder（t）;

/*调用中序遍历*/

\n\n打回车键，继续。

“）;

ch=getch（）;

}break;

case4:

{n=0;

n0=0;

n1=0;

n2