C++所有的实验程序Word下载.docx

C++所有的实验程序Word下载.docx

《C++所有的实验程序Word下载.docx》由会员分享，可在线阅读，更多相关《C++所有的实验程序Word下载.docx（27页珍藏版）》请在冰豆网上搜索。

data[0];

for（i=1;

i<

=L->

last-1;

i++）{

if（min>

data[i]）

min=L->

data[i];

if（max<

max=L->

}

max=%d,min=%d\n"

max,min）;

voidmain（）{

Sequenlist*A;

A=SqLset（）;

maxmin（A）;

实验三顺序查询：

stdlib.h>

#defineMax40

intdata[Max];

}squenlist;

voidresearch（squenlist*L）

{

inti,a,chioce;

do{

0：

退出；

\n1：

继续查找；

scanf（"

chioce）;

if（chioce==1）

{

printf（"

请输入要查找的元素：

a）;

L->

last+1]=a;

for（i=0;

last+1;

if（L->

data[i]==a）

break;

}

if（i==L->

last+1）{

printf（"

无该元素，查找失败！

else{

该元素的位置是：

%d"

i）;

if（chioce!

=1&

&

chioce!

=0）

选择有误，请重新选择!

}while（chioce!

=0）;

squenlist*L;

inti,n;

if（（L=（squenlist*）malloc（sizeof（squenlist）））==NULL）{

申请失败！

exit

（1）;

长度不超过39，请选择长度n:

n）;

last=n-1;

请输入一组长度为n的递增数：

for（i=0;

n;

data[i]）;

while（i>

=1）{

if（L->

data[i-1]>

data[i]）{

输入有误，请重新输入：

i=-1;

break;

elsebreak;

}

该顺序表元素是：

last;

i++）

%d\t"

L->

research（L）;

实验四奇偶排序：

#defineMAX60

intdata[MAX+1];

intlength;

}sqelist;

voidodd（sqelist*L）{//奇排序函数；

inti,j;

length;

for（j=0;

j<

length-i-1;

j++）{

data[j]%2==1）{

data[j]>

data[j+1]）{

L->

length]=L->

data[j+1];

data[j+1]=L->

data[j];

data[j]=L->

length];

}

voideven（sqelist*L）{//偶排序函数；

data[j]%2==0）{

voidbubble（sqelist*L）{//奇偶排序调用函数；

if（L->

data[i]>

data[i+1]）{

odd（L）;

even（L）;

sqelist*input（）{//输入；

sqelist*H;

H=（sqelist*）malloc（sizeof（sqelist））;

请输入要输入元素的个数：

H->

length=n;

请输入%d个元素：

n）;

H->

returnH;

voidputout（sqelist*L）{//输出；

按奇偶排序后的顺序是：

%d"

sqelist*L;

L=input（）;

bubble（L）;

putout（L）;

实验五-在非递减有序链表中插入元素并且顺序不变

typedefstructnode{

intdata;

structnode*next;

}Linklist;

Linklist*createlist（）{//新建链表函数；

Linklist*H,*S,*R,*P;

inti,n,m;

H=（Linklist*）malloc（sizeof（Linklist））;

next=NULL;

S=H;

请输入新建非空链表的长度：

"

data=n;

//记录新链表长度；

请输入一组长度为%d的递增数：

R=（Linklist*）malloc（sizeof（Linklist））;

m）;

R->

data=m;

S->

next=R;

P=S;

S=R;

if（P->

data>

R->

data）{

输入有误，请从此处重新输入：

i--;

P->

S=P;

free（R）;

voidinsertlist（Linklist*L）{//插入元素的值；

Linklist*P,*S,*R;

intn;

请输入要插入元素的值：

P=L;

while（P!

=NULL）{

R=P;

P=P->

next;

if（P!

=NULL&

n<

=P->

S=（Linklist*）malloc（sizeof（Linklist））;

S->

next=P;

R->

next=S;

break;

if（P==NULL）{

S=（Linklist*）malloc（sizeof（Linklist））;

voidputout（Linklist*L）{//输出函数；

Linklist*P;

P=L->

该链表是：

P->

data）;

Linklist*L=NULL;

1：

新建链表；

2：

插入元素；

3：

输出链表！

\n请选择：

switch（n）{

case1:

L=createlist（）;

case2:

if（L!

=NULL）

insertlist（L）;

else

链表为空！

case3:

putout（L）;

else{

default:

break;

}while（n!

实验七（单向循环链表表示队列）

}squelink;

intstempty（squelink*L）{//判队空；

squelink*P;

if（P->

data==0）

return0;

else

return1;

squelink*setempty（squelink*L）{//置空队；

squelink*P,*R,*H;

R=L->

H=R->

n=R->

data;

P=H->

if（P==L）L=R;

free（H）;

data--;

H=P;

squelink*setinput（squelink*L）{//入队；

squelink*R,*S;

intn,i=0,l;

l=stempty（L）;

if（l==0）

R=L;

else

R=L->

请输入队元素的个数：

if（n>

data+=n;

输入入队的元素值：

while（i<

n）{

S=（squelink*）malloc（sizeof（squelink））;

S->

L=S;

i++;

squelink*setoutput（squelink*L）{//出队；

intl,i,n;

P=R->

if（l==1）{

输入不超过%d的出队元素个数：

R->

if（n==R->

data）

L=R;

出队元素是：

for（i=0;

H=P->

next=H;

free（P）;

P=H;

if（R->

data==0）break;

空队！

squelink*L;

intn,l;

L=（squelink*）malloc（sizeof（squelink））;

data=0;

next=L;

1：

置空队；

2：

判空队；

3：

入队；

4：

出队；

while（n!

队已为空！

L=setempty（L）;

l=stempty（L）;

if（l==0）

队为空！

if（l==1）

printf（"

队非空！

L=setinput（L）;

case4:

L=setoutput（L）;

选择有误！

请选择：

实验九-二叉树所有左右节点的交换

structnode*lchild,*rchild;

}Bitree;

voidouttree（Bitree*H）{//先序遍历输出；

if（H）{

H->

outtree（H->

lchild）;

rchild）;

voidturnlr（Bitree*L）{//左右节点交换；

Bitree*P;

if（L）{

P=L->

lchild;

L->

lchild=L->

rchild;

rchild=P;

turnlr（L->

voidcreatetree（Bitree*H）{//建立二叉树；

Bitree*L,*R,*P;

intm,n;

P=H;

输入此节点的值：

P->

以-1表示虚结点，请输入该节点的左右孩子是否为虚结点：

%d%d"

m,&

if（m!

=-1）{

L=（Bitree*）malloc（sizeof（Bitree））;

lchild=NULL;

rchild=NULL;

P->

lchild=L;

createtree（L）;

if（n!

R=（Bitree*）malloc（sizeof（Bitree））;

rchild=R;

createtree（R）;

voidmain（）{//主函数；

Bitree*L;

L=NULL;

0:

\n1:

建立一个二叉树；

\n2:

转换所有节点的左右子树；

\n3:

二叉树先序遍历后的结果；

请选择:

while（n）{

Bitree*H;

H=（Bitree*）malloc（sizeof（Bitree））;

H->

createtree（H）;

L=H;

if（L==NULL）

二叉树未被建立！

turnlr（L）;

outtree（L）;

实验十（二叉排序树的判断）

}Bstnode;

voidcreatetree（Bstnode*H）{//建立二叉树；

Bstnode*L,*R,*P;

L=（Bstnode*）malloc（sizeof（Bstnode））;

R=（Bstnode*）malloc（sizeof（Bstnode））;

intjudgetree（Bstnode*H）{//判断是否为二叉排序树；

Bstnode*L,*R;

intflag1=0,flag2=0,flag;

//0表示该二叉树是二叉排序树；

L=H->

R=H->

if（L）{

=H->

flag1=1;

//不是二叉排序树时将flag值改变为1；

elseflag1=judgetree（L）;

if（R）{

data<

flag2=1;

elseflag2=judgetree（R）;

flag=（flag1>

flag2）?

flag1:

flag2;

returnflag;

Bstnode*L;

intn,m;

建立二叉树；

判断二叉树是否是二叉排序树；

Bstnode*H;

H=（Bstnode*）malloc（sizeof（Bstnode））;

空二叉树！

m=judgetree（L）;

if（m==0）

该二叉树是二叉排序树！

else

该二叉树不是二叉排序树！

实验十一（带权值边的无向图邻接矩阵转化成邻接表）

#defineMax100

//定义邻接矩阵类型；

typedefstruct{

intnum;

//顶点序号；

//顶点值；

}Vertex;

intn