C++所有的实验程序.docx
《C++所有的实验程序.docx》由会员分享，可在线阅读，更多相关《C++所有的实验程序.docx（27页珍藏版）》请在冰豆网上搜索。
C++所有的实验程序
实验二：
#include
#include
#definemaxlen50
typedefstruct{
intdata[maxlen];
intlast;
}Sequenlist;
Sequenlist*SqLset（）{
Sequenlist*L;
inti;
L=（Sequenlist*）malloc（sizeof（Sequenlist））;
L->last=-1;
printf（"请输入不超过50的表长：
\n"）;
scanf（"%d",&i）;
if（i>0）{
printf（"输入数据：
\n"）;
for（L->last=0;L->lastlast++）
scanf（"%d",&L->data[L->last]）;
}
returnL;
}
voidmaxmin（Sequenlist*L）{
intmin,max,i;
if（L->last>=0）{
max=min=L->data[0];
for（i=1;i<=L->last-1;i++）{
if（min>L->data[i]）
min=L->data[i];
if（maxdata[i]）
max=L->data[i];
}
printf（"max=%d,min=%d\n",max,min）;
}
}
voidmain（）{
Sequenlist*A;
A=SqLset（）;
maxmin（A）;
}
实验三顺序查询：
#include
#include
#defineMax40
typedefstruct{
intdata[Max];
intlast;
}squenlist;
voidresearch（squenlist*L）
{
inti,a,chioce;
do{
printf（"0：
退出；\n1：
继续查找；\n"）;
scanf（"%d",&chioce）;
if（chioce==1）
{
printf（"请输入要查找的元素：
\n"）;
scanf（"%d",&a）;
L->data[L->last+1]=a;
for（i=0;i<=L->last+1;i++）{
if（L->data[i]==a）
break;
}
if（i==L->last+1）{
printf（"无该元素，查找失败！
\n"）;
}
else{
printf（"该元素的位置是：
%d",i）;
}
printf（"\n"）;
}
if（chioce!
=1&&chioce!
=0）
printf（"选择有误，请重新选择!
\n"）;
}while（chioce!
=0）;
}
voidmain（）{
squenlist*L;
inti,n;
if（（L=（squenlist*）malloc（sizeof（squenlist）））==NULL）{
printf（"申请失败！
\n"）;
exit
（1）;
}
printf（"长度不超过39，请选择长度n:
\n"）;
scanf（"%d",&n）;
L->last=n-1;
printf（"请输入一组长度为n的递增数：
\n"）;
for（i=0;iscanf（"%d",&L->data[i]）;
while（i>=1）{
if（L->data[i-1]>L->data[i]）{
printf（"输入有误，请重新输入：
\n"）;
i=-1;
break;
}
elsebreak;
}
}
printf（"该顺序表元素是：
\n"）;
for（i=0;i<=L->last;i++）
printf（"%d\t",L->data[i]）;
printf（"\n"）;
research（L）;
}
实验四奇偶排序：
#include
#include
#defineMAX60
typedefstruct{
intdata[MAX+1];
intlength;
}sqelist;
voidodd（sqelist*L）{//奇排序函数；
inti,j;
for（i=0;ilength;i++）
for（j=0;jlength-i-1;j++）{
if（L->data[j]%2==1）{
if（L->data[j]>L->data[j+1]）{
L->data[L->length]=L->data[j+1];
L->data[j+1]=L->data[j];
L->data[j]=L->data[L->length];
}
}
}
}
voideven（sqelist*L）{//偶排序函数；
inti,j;
for（i=0;ilength;i++）
for（j=0;jlength-i-1;j++）{
if（L->data[j]%2==0）{
if（L->data[j]>L->data[j+1]）{
L->data[L->length]=L->data[j+1];
L->data[j+1]=L->data[j];
L->data[j]=L->data[L->length];
}
}
}
}
voidbubble（sqelist*L）{//奇偶排序调用函数；
inti;
for（i=0;ilength;i++）
if（L->data[i]>L->data[i+1]）{
odd（L）;
even（L）;
}
}
sqelist*input（）{//输入；
inti,n;
sqelist*H;
H=（sqelist*）malloc（sizeof（sqelist））;
printf（"请输入要输入元素的个数：
\n"）;
scanf（"%d",&n）;
H->length=n;
printf（"请输入%d个元素：
\n",n）;
for（i=0;iscanf（"%d",&H->data[i]）;
returnH;
}
voidputout（sqelist*L）{//输出；
inti;
printf（"按奇偶排序后的顺序是：
\n"）;
for（i=0;ilength;i++）
printf（"%d",L->data[i]）;
printf（"\n"）;
}
voidmain（）{
sqelist*L;
L=input（）;
bubble（L）;
putout（L）;
}
实验五-在非递减有序链表中插入元素并且顺序不变
#include
#include
typedefstructnode{
intdata;
structnode*next;
}Linklist;
Linklist*createlist（）{//新建链表函数；
Linklist*H,*S,*R,*P;
inti,n,m;
H=（Linklist*）malloc（sizeof（Linklist））;
H->next=NULL;
S=H;
printf（"请输入新建非空链表的长度：
"）;
scanf（"%d",&n）;
H->data=n;//记录新链表长度；
printf（"请输入一组长度为%d的递增数：
\n",n）;
for（i=0;iR=（Linklist*）malloc（sizeof（Linklist））;
scanf（"%d",&m）;
R->data=m;
R->next=NULL;
S->next=R;
P=S;
S=R;
while（i>=1）{
if（P->data>R->data）{
printf（"输入有误，请从此处重新输入：
\n"）;
i--;
P->next=NULL;
S=P;
free（R）;
break;
}
elsebreak;
}
}
returnH;
}
voidinsertlist（Linklist*L）{//插入元素的值；
Linklist*P,*S,*R;
intn;
printf（"请输入要插入元素的值：
"）;
scanf（"%d",&n）;
P=L;
while（P!
=NULL）{
R=P;
P=P->next;
if（P!
=NULL&&n<=P->data）{
S=（Linklist*）malloc（sizeof（Linklist））;
S->data=n;
S->next=P;
R->next=S;
break;
}
}
if（P==NULL）{
S=（Linklist*）malloc（sizeof（Linklist））;
S->data=n;
S->next=NULL;
R->next=S;
}
}
voidputout（Linklist*L）{//输出函数；
Linklist*P;
P=L->next;
printf（"该链表是：
\n"）;
while（P!
=NULL）{
printf（"%d",P->data）;
P=P->next;
}
printf（"\n"）;
}
voidmain（）{
Linklist*L=NULL;
intn;
do{
printf（"0：
退出；1：
新建链表；2：
插入元素；3：
输出链表！
\n请选择：
"）;
scanf（"%d",&n）;
switch（n）{
case1:
L=createlist（）;
printf（"\n"）;
break;
case2:
if（L!
=NULL）
insertlist（L）;
else
printf（"链表为空！
"）;
printf（"\n"）;
break;
case3:
if（L!
=NULL）{
putout（L）;
printf（"\n"）;
}
else{
printf（"链表为空！
"）;
printf（"\n"）;
}
break;
default:
break;
}
}while（n!
=0）;
printf（"\n"）;
}
实验七（单向循环链表表示队列）
#include
#include
typedefstructnode{
intdata;
structnode*next;
}squelink;
intstempty（squelink*L）{//判队空；
squelink*P;
P=L->next;
if（P->data==0）
return0;
else
return1;
}
squelink*setempty（squelink*L）{//置空队；
squelink*P,*R,*H;
inti,n;
R=L->next;
H=R->next;
n=R->data;
for（i=0;iP=H->next;
if（P==L）L=R;
R->next=P;
free（H）;
R->data--;
H=P;
}
returnL;
}
squelink*setinput（squelink*L）{//入队；
squelink*R,*S;
intn,i=0,l;
l=stempty（L）;
if（l==0）
R=L;
else
R=L->next;
printf（"请输入队元素的个数：
"）;
scanf（"%d",&n）;
if（n>0）{
R->data+=n;
printf（"输入入队的元素值：
\n"）;
while（iS=（squelink*）malloc（sizeof（squelink））;
scanf（"%d",&S->data）;
S->next=R;
L->next=S;
L=S;
i++;
}
}
returnL;
}
squelink*setoutput（squelink*L）{//出队；
squelink*P,*R,*H;
intl,i,n;
R=L->next;
P=R->next;
l=stempty（L）;
if（l==1）{
printf（"输入不超过%d的出队元素个数：
",R->data）;
scanf（"%d",&n）;
if（n==R->data）
L=R;
printf（"\n"）;
printf（"出队元素是：
"）;
for（i=0;iH=P->next;
printf（"%d",P->data）;
R->next=H;
free（P）;
P=H;
R->data--;
if（R->data==0）break;
}
}
else
printf（"空队！
"）;
returnL;
}
voidmain（）{
squelink*L;
intn,l;
L=（squelink*）malloc（sizeof（squelink））;
L->data=0;
L->next=L;
printf（"0：
退出；1：
置空队；2：
判空队；3：
入队；4：
出队；\n请选择：
"）;
scanf（"%d",&n）;
while（n!
=0）{
switch（n）{
case1:
if（L->data==0）
printf（"队已为空！
"）;
else
L=setempty（L）;
printf（"\n"）;
break;
case2:
l=stempty（L）;
if（l==0）
printf（"队为空！
\n"）;
else
if（l==1）
printf（"队非空！
\n"）;
break;
case3:
L=setinput（L）;
printf（"\n"）;
break;
case4:
L=setoutput（L）;
printf（"\n"）;
break;
default:
printf（"选择有误！
\n"）;
break;
}
printf（"请选择：
"）;
scanf（"%d",&n）;
}
}
实验九-二叉树所有左右节点的交换
#include
#include
typedefstructnode{
intdata;
structnode*lchild,*rchild;
}Bitree;
voidouttree（Bitree*H）{//先序遍历输出；
if（H）{
printf（"%d",H->data）;
outtree（H->lchild）;
outtree（H->rchild）;
}
}
voidturnlr（Bitree*L）{//左右节点交换；
Bitree*P;
if（L）{
P=L->lchild;
L->lchild=L->rchild;
L->rchild=P;
turnlr（L->rchild）;
turnlr（L->lchild）;
}
}
voidcreatetree（Bitree*H）{//建立二叉树；
Bitree*L,*R,*P;
intm,n;
P=H;
printf（"输入此节点的值：
"）;
scanf（"%d",&P->data）;
printf（"以-1表示虚结点，请输入该节点的左右孩子是否为虚结点：
\n"）;
scanf（"%d%d",&m,&n）;
if（m!
=-1）{
L=（Bitree*）malloc（sizeof（Bitree））;
L->lchild=NULL;
L->rchild=NULL;
P->lchild=L;
createtree（L）;
}
if（n!
=-1）{
R=（Bitree*）malloc（sizeof（Bitree））;
R->lchild=NULL;
R->rchild=NULL;
P->rchild=R;
createtree（R）;
}
}
voidmain（）{//主函数；
Bitree*L;
intn;
L=NULL;
printf（"0:
退出；\n1:
建立一个二叉树；\n2:
转换所有节点的左右子树；\n3:
二叉树先序遍历后的结果；\n"）;
printf（"请选择:
"）;
scanf（"%d",&n）;
while（n）{
switch（n）{
case1:
Bitree*H;
H=（Bitree*）malloc（sizeof（Bitree））;
H->lchild=NULL;
H->rchild=NULL;
createtree（H）;
L=H;
break;
case2:
if（L==NULL）
printf（"二叉树未被建立！
\n"）;
else
turnlr（L）;
break;
case3:
if（L==NULL）
printf（"二叉树未被建立！
\n"）;
else{
outtree（L）;
printf（"\n"）;
}
break;
}
printf（"请选择：
"）;
scanf（"%d",&n）;
}
}
实验十（二叉排序树的判断）
#include
#include
typedefstructnode{
intdata;
structnode*lchild,*rchild;
}Bstnode;
voidcreatetree（Bstnode*H）{//建立二叉树；
Bstnode*L,*R,*P;
intm,n;
P=H;
printf（"输入此节点的值：
"）;
scanf（"%d",&P->data）;
printf（"以-1表示虚结点，请输入该节点的左右孩子是否为虚结点：
\n"）;
scanf（"%d%d",&m,&n）;
if（m!
=-1）{
L=（Bstnode*）malloc（sizeof（Bstnode））;
L->lchild=NULL;
L->rchild=NULL;
P->lchild=L;
createtree（L）;
}
if（n!
=-1）{
R=（Bstnode*）malloc（sizeof（Bstnode））;
R->lchild=NULL;
R->rchild=NULL;
P->rchild=R;
createtree（R）;
}
}
intjudgetree（Bstnode*H）{//判断是否为二叉排序树；
Bstnode*L,*R;
intflag1=0,flag2=0,flag;//0表示该二叉树是二叉排序树；
if（H）{
L=H->lchild;
R=H->rchild;
if（L）{
if（L->data>=H->data）
flag1=1;//不是二叉排序树时将flag值改变为1；
elseflag1=judgetree（L）;
}
if（R）{
if（R->data<=H->data）
flag2=1;//不是二叉排序树时将flag值改变为1；
elseflag2=judgetree（R）;
}
}
flag=（flag1>flag2）?
flag1:
flag2;
returnflag;
}
voidmain（）{
Bstnode*L;
intn,m;
L=NULL;
printf（"0:
退出；1：
建立二叉树；2：
判断二叉树是否是二叉排序树；\n"）;
scanf（"%d",&n）;
while（n）{
switch（n）{
case1:
Bstnode*H;
H=（Bstnode*）malloc（sizeof（Bstnode））;
H->lchild=NULL;
H->rchild=NULL;
createtree（H）;
L=H;
break;
case2:
if（L==NULL）
printf（"空二叉树！
\n"）;
else{
m=judgetree（L）;
if（m==0）
printf（"该二叉树是二叉排序树！
\n"）;
else
printf（"该二叉树不是二叉排序树！
\n"）;
}
break;
}
scanf（"%d",&n）;
}
}
实验十一（带权值边的无向图邻接矩阵转化成邻接表）
#include
#include
#defineMax100
//定义邻接矩阵类型；
typedefstruct{
intnum;//顶点序号；
intdata;//顶点值；
}Vertex;
typedefstruct{
intn
升级会员 