数据结构与算法实验源代码Word文档格式.docx
《数据结构与算法实验源代码Word文档格式.docx》由会员分享，可在线阅读，更多相关《数据结构与算法实验源代码Word文档格式.docx（38页珍藏版）》请在冰豆网上搜索。
j<
=L->
last+1;
j++）
L->
data[j]=L->
data[j+1];
last--;
return1;
voidSqLdel（Sequenlist*L）{//寻找顺序表中多余的元素并删除
inti,j;
if（L->
last<
0）{
printf（"
\n顺序表为空\n"
else{
for（i=0;
last;
for（j=i+1;
if（L->
data[j]==L->
data[i]）{
SqLdelete（L,j）;
//调用函数删除下标为j的结点
}
}
voidSqLsc（Sequenlist*L）{//输出顺序表中的数据
inti;
0）
顺序表中的元素：
printf（"
%d"
L->
\n"
intmain（void）{
L=SqLsetnull（）;
intchoice;
1,输入数据2，删除重复多余的数据3,输出数据0，退出\n"
do{
请输入选择：
choice）;
switch（choice）{
case1:
SqLset（L）;
break;
case2:
SqLdel（L）;
case3:
SqLsc（L）;
default:
请输入正确的选择!
case0:
}while（choice!
=0）;
return0;
实验三
#defineSIZE15
intdata[SIZE];
}RecordList;
RecordList*shuru（）{//向顺序表中输入数据
ints,i=0;
RecordList*L;
L=（RecordList*）malloc（sizeof（RecordList））;
请输入要输入到顺序表中数据的数量：
s）;
if（s>
15）{
超过最大的数据长度"
请输入要输入的数据：
s;
i++）
scanf（"
成功输入%d个数据\n\n"
i）;
last=i-1;
voidpaixu（RecordList*L）{//冒泡排序法对顺序表中的数据进行排序
intx,change=1,i,j;
for（i=0;
last&
&
change!
=0;
change=0;
for（j=0;
last-i;
j++）{
if（L->
data[j]>
data[j+1]）{
x=L->
L->
data[j+1]=L->
data[j];
data[j]=x;
change=1;
}
intBinSrch（RecordList*L,intk）{//二分查找
intlow=0,i=-1,high,mid;
high=L->
while（low<
=high）{
mid=（low+high）/2;
if（k==L->
data[mid]）{
i=mid;
elseif（k<
data[mid]）
high=mid-1;
else
low=mid+1;
returni;
intmain（void）
{
RecordList*L=NULL;
inti,choice,data1;
1,输入数据2，二分法查找0,退出\n"
L=shuru（）;
//输入数据
paixu（L）;
//数据排序
if（L==NULL||L->
last==-1）{//查找前检验表中是否有数据
printf（"
\n顺序表为空\n\n"
break;
else{
请输入要查找的数据：
scanf（"
data1）;
i=BinSrch（L,data1）;
数据%d的序号（下标）是%d\n\n"
data1,i）;
\n请输入正确的选择\n\n"
实验四
intx,change1=1,change2=1,i,j;
change1!
=0||change2!
change1=0;
change2=0;
if（i%2==0）{
for（j=1;
j=j+2）{
x=L->
L->
change1=1;
else{
for（j=0;
change2=1;
voidshuchu（RecordList*L）{
1,输入数据2，冒泡排序3,输出0,退出\n"
排序成功\n\n"
shuchu（L）;
实验五
typedefstructnode{
intdata;
structnode*next;
}LinkList;
LinkList*CreatList（）{
LinkList*head,*r,*s;
//建立带头结点的链表，head为链表的头结点
head=（LinkList*）malloc（sizeof（LinkList））;
head->
next=NULL;
r=head;
请输入要输入的数据的个数:
请输入要输入的数据:
s=（LinkList*）malloc（sizeof（LinkList））;
s->
data）;
s->
r->
next=s;
r=s;
//r指向链表的尾节点
returnhead;
voidAdd（LinkList*head,intx）{
LinkList*s,*r,*t;
t=（LinkList*）malloc（sizeof（LinkList））;
s=head->
next;
for（;
s!
=NULL&
x>
=s->
data;
s=s->
next）{//要寻找要插入节点的位置
r=r->
t->
data=x;
if（s==NULL）{//插入在链表的表尾
next=t;
t->
else{//插入在链表的中间
next=r->
voidOut（LinkList*head）{//输出表中的数据
LinkList*L;
L=head->
表中的数据:
L;
L=L->
next）{
LinkList*head;
intx;
head=CreatList（）;
Out（head）;
请输入要插入的数据:
x）;
Add（head,x）;
实验七
typedefstructnode{
LinkList*rear;
}LinkQueue;
LinkQueue*SetQueue（）{//建立空的队列
LinkQueue*Q;
Q=（LinkQueue*）malloc（sizeof（LinkQueue））;
head=（LinkList*）malloc（sizeof（LinkQueue））;
data=-1;
next=head;
Q->
rear=head;
returnQ;
intQueueEmpty（LinkQueue*Q）{//检验对列是否为空
LinkList*p;
p=Q->
rear;
if（p->
data==-1）{
return1;
else
return0;
LinkQueue*Add（LinkQueue*Q,intx）{//数据入队
p=（LinkList*）malloc（sizeof（LinkList））;
p->
next=Q->
rear->
next=p;
rear=p;
voidOut（LinkQueue*Q）{//数据出队
LinkList*p1,*p2;
p1=Q->
p2=Q->
p2=p2->
p1=p2->
if（p1->
队列为空"
return;
出队的数据是%d\n"
p1->
p2->
next=p1->
LinkQueue*SetNull（LinkQueue*Q）{//队列置空
rear=Q->
LinkQueue*Q=NULL;
intchoice,x,i;
1，建立空队列2，数据入队3，数据出队4，置队空5，检验队空0,退出\n"
\n请输入选择:
Q=SetQueue（）;
已建立空队列\n"
请输入要入队的数据:
Q=Add（Q,x）;
Out（Q）;
case4:
Q=SetNull（Q）;
队列已置空"
case5:
i=QueueEmpty（Q）;
if（i==1）
队列为空\n"
else
队列未空\n"
实验八
#defineSIZE100
voidzhuanzhi（intsa[],intn）{//转置函数
intm,t;
3*n-2;
if（i%3!
=0）{
m=i+1;
t=sa[i];
sa[i]=sa[m];
//交换对称的两个数据
sa[m]=t;
i++;
//跳过矩阵的下三角数据
}//矩阵对角线上的数据不进行操作
voidJPrintf（intsa[],intn）{//输出函数
inti,j;
for（i=1;
=n;
j++）{
if（i==j-1||i==j||i==j+1）{//i==j-1对角线下方的元素i==j对角线上的元素i==j+1对角线上方的元素
printf（"
%d"
sa[2*i+j-3]）;
//非零元素在数据中的下标为2*i+j-3
else
0"
intn,sa[SIZE];
请输入三对角矩阵的阶数:
请依次输入三对角矩阵中的非零数据:
i++）{//三对角矩阵共有3*n-2g个非零元素
sa[i]）;
JPrintf（sa,n）;
zhuanzhi（sa,n）;
转置后的矩阵：
实验九
#definemaxsize10
chardata;
structnode*lchild,*rchild;
}Bitree;
Bitree*Q[maxsize];
//使用队列临时记录节点地址
Bitree*Creatree（）{//建立一个二叉树
charch;
intfront,rear;
Bitree*T,*s;
T=NULL;
front=1;
rear=0;
请输入一个二叉树（以#号结束）:
ch=getchar（）;
while（ch!
='
#'
）{//以输入“#”结束输入
s=NULL;
if（ch!
@'
）{//输入“@”表示虚节点
s=（Bitree*）malloc（sizeof（Bitree））;
//如果不是虚节点就建立新节点
s->
data=ch;
lchild=s->
rchild=NULL;
rear++;
Q[rear]=s;
if（rear==1）//输入的第一个节点为根节点
T=s;
if（s!
Q[front]!
=NULL）
if（rear%2==0）//若rear为偶数则该节点为父节点的左孩子，否则为右孩子
Q[front]->
lchild=s;
rchild=s;
if（rear%2==1）
front++;
ch=getchar（）;
returnT;
voidvisite（Bitree*T,int*m）{
if（T->
lchild==NULL&
T->
rchild==NULL）{//没有左孩子也没有右孩子就是叶子节点
（*m）++;
voidPreorder（Bitree*T,int*m）{//使用递归遍历二叉树
if（T）{
visite（T,m）;
//访问根节点
Preorder（T->
lchild,m）;
rchild,m）;
int*m,n=0;
m=&
//使用一个指针用于记录叶子节点的个数
Bitree*T;
T=Creatree（）;
Preorder（T,m）;
该二叉树的叶子节点数：
%d\n"
n）;
实验十
升级会员 