算法与数据结构实习Word格式文档下载.docx
《算法与数据结构实习Word格式文档下载.docx》由会员分享，可在线阅读，更多相关《算法与数据结构实习Word格式文档下载.docx（25页珍藏版）》请在冰点文库上搜索。
程序1：
顺序表基本操作的实现
这个程序中演示了顺序表的创建、插入、删除和查找，请修改并完成。
程序如下：
#include<
stdio.h>
stdlib.h>
/*顺序表的定义：
*/
#defineListSize100
typedefstruct
{intdata[ListSize];
/*向量data用于存放表结点*/
intlength;
/*当前的表长度*/
}SeqList;
voidmain（）
{voidCreateList（SeqList*L,intn）;
voidPrintList（SeqList*L,intn）;
intLocateList（SeqList*L,intx）;
voidInsertList（SeqList*L,intx,inti）;
voidDeleteList（SeqList*L,inti）;
SeqListL;
inti,x;
intn=10;
/*THELENGTHOFLIST*/
L.length=0;
clrscr（）;
CreateList（&
L,n）;
/*CREATTHELIST*/
PrintList（&
/*PRINTTHELIST*/
printf（"
INPUTTHERESEARCHELEMENT"
）;
scanf（"
%d"
&
x）;
i=LocateList（&
L,x）;
theresearchpositionis%d\n"
i）;
/*顺序表查找*/
inputthepositionofinsert:
\n"
i）;
inputthevalueofinsert\n"
InsertList（&
L,x,i）;
/*顺序表插入*/
/*打印顺序表*/
inputthepositionofdelete\n"
DeleteList（&
L,i）;
/*顺序表删除*/
getch（）;
/*打印顺序表*/
}
/*顺序表的建立：
voidCreateList（SeqList*L,intn）
{inti;
printf（"
pleaseinputnnumbers\n"
for（i=1;
i<
=n;
i++）
{scanf（"
L->
data[i]）;
length=n;
/*顺序表的打印：
voidPrintList（SeqList*L,intn）
thesqlistis\n"
%d"
L->
/*顺序表的查找：
intLocateList（SeqList*L,intx）
{
请完成代码
/*顺序表的插入：
voidInsertList（SeqList*L,intx,inti）
/*顺序表的删除：
voidDeleteList（SeqList*L,inti）
{
实验三单链表操作
1．掌握握单链表的基本操作：
插入、删除、查找等运算。
1．认真阅读和掌握本实验的程序。
2．上机运行本程序。
3．保存和打印出程序的运行结果，并结合程序进行分析。
4．按照你对单链表的操作需要，重新改写主程序并运行，打印出文件清单和运行结果
单链表基本操作的实现
这个程序中演示了单链表的创建、插入、删除和查找。
#include<
malloc.h>
typedefstructnode{
intdata;
structnode*next;
}NODE;
/******************************************/
NODE*Create（）{
NODE*p,*head;
intx;
head=（NODE*）malloc（sizeof（NODE））;
head->
next=NULL;
Inputdata,-1toEnd!
while（x!
=-1）{
p=（NODE*）malloc（sizeof（NODE））;
p->
data=x;
next=head->
next;
next=p;
}
return（head）;
voidOutput（NODE*head）{
NODE*p;
p=head;
BegintodumptheLinkList...\n"
while（p->
next!
=NULL）{
->
p->
next->
data）;
p=p->
\nTheLinkListended!
intListlen（NODE*head）{
inti=0;
NODE*p=head;
i++;
return（i）;
intGet（NODE*head,inti）{
voidDel（NODE*head,inti）{
voidIns（NODE*head,inti,inte）{
NODE*p=head,*q;
intj=0;
while（p->
next&
&
j<
i-1）{
main（）{
NODE*head;
inti,element;
head=Create（）;
Output（head）;
length=Listlen（head）;
thelengthofthelinkis%d\n"
length）;
inputtheorder:
element=Get（head,i）;
theelementoftheorderis%d\n"
element）;
inputthedelposition\n"
Del（head,i）;
Inputtheinsertposionandelement:
%d%d"
i,&
element）;
Ins（head,i,element）;
}_
}
实验四栈的基本操作
掌握栈的基本操作：
初始化栈、判栈为空、出栈、入栈等运算。
二、实验要求
1．认真阅读和掌握本实验的算法。
2．上机将本算法实现。
三、实验内容
利用栈的基本操作实现将任意一个十进制整数转化为R进制整数
算法为：
1、定义栈的顺序存取结构
2、分别定义栈的基本操作（初始化栈、判栈为空、出栈、入栈等）
3、定义一个函数用来实现上面问题：
十进制整数X和R作为形参
初始化栈
只要Ｘ不为０重复做下列动作
将Ｘ％Ｒ入栈
X=X/R
只要栈不为空重复做下列动作
栈顶出栈
输出栈顶元素
参考程序：
#defineMAXSIZE100
#include<
structstack{
intdata[MAXSIZE];
inttop;
};
voidinit（structstack*s）{
s->
top=-1;
intempty（structstack*s）{
if（s->
top==-1）
return1;
else
return0;
voidpush（structstack*s,inti）{
top==MAXSIZE-1）{
Stackisfull\n"
return;
intpop（structstack*s）{
if（empty（s））{
stackisempty"
return-1;
voidtrans（intnum）{
structstacks;
intk;
init（&
s）;
while（num）{
k=num%16;
push（&
s,k）;
num=num/16;
while（!
empty（&
s））{
k=pop（&
if（k<
10）
k）;
%c"
k+55）;
intnum;
Inputanum,-1toquit:
num）;
while（num!
trans（num）;
}
实验五队列的基本操作
一、实验目的
掌握队列的基本操作：
初始化队列、判队列为空、出队列、入队列等运算。
利用队列的基本操作实现杨辉三角的输出
算法如下：
voidout_number（intn）;
{init_queue（Q）;
printf
（1）;
en_queue（Q,s1+s2）;
for（I=2;
I<
I++）
{s1=0;
for（j=1;
=I-1;
j++）
{s2=out_queue（Q）;
printf（s2）;
en_queue（q,s1+s2）;
s1=s2;
en_queue（Q,1+s2）;
参考程序如下
{int*data;
intfront;
intrear;
sqqueue;
main（）
inti,j,m,s1=0,s2=1;
sqqueueq;
clrscr（）;
q.data=（int*）malloc（100*sizeof（int））;
q.rear=q.front=0;
q.data[q.rear]=s2;
q.rear++;
%40d"
s2）;
for（i=2;
=8;
for（m=1;
m<
=40-i;
m++）
'
'
=i-1;
{s2=q.data[q.front];
q.front++;
q.data[q.rear]=s1+s2;
%d\n"
1）;
q.data[q.rear]=1+s2;
实验六数组的基本操作
回顾c语言中数组的定义和基本应用
有M个学生，学习N门课程，已知所有学生的各科成绩，
编程：
分别求每个学生的平均成绩和每门课程的平均成绩
参考程序：
#defineM5
#defineN4
#include"
stdio.h"
{inti,j;
staticfloatscore[M+1][N+1]={{78,85,83,65},{88,91,89,93},{72,65,54,75},{86,88,75,60},{69,60,50,72}};
for（i=0;
M;
{for（j=0;
N;
{score[i][N]+=score[i][j];
score[M][j]+=score[i][j];
score[i][N]/=N;
for（j=0;
score[M][j]/=M;
学生编号课程1课程2课程3课程4个人平均\n"
for（i=0;
{printf（"
学生%d\t"
i+1）;
N+1;
%6.1f\t"
score[i][j]）;
8*（N+2）;
-"
\n课程平均"
score[M][j]）;
}
实验七字符串处理
1、理解字符串的基本概念，字符串的存贮
2、掌握字符串的基本操作。
定义字符串数组、实现字符串处理的基本操作
#defineMAXN100
typedefenum{fail,success}status;
typedefenum{false,true}boolean;
chars[MAXN],s1[MAXN],s2[MAXN];
voidscopy（chars1[],chars2[]）
{inti=0;
while（s2[i]!
='
\0'
）
{s1[i]=s2[i];
i++;
s1[i]='
;
intstrlen（chars[]）
{inti;
for（i=0;
s[i]!
i++）;
return（i）;
statusstrcat（chars1[],chars2[]）
{inti,j,k;
if（（i=strlen（s1））+（j=strlen（s2））>
=MAXN）
return（fail）;
for（k=0;
k<
=j;
k++）
s1[i+k]=s2[k];
return（success）;
statusstrins（chars1[],inti,chars2[]）
{intm,n,k;
if（i<
0||i>
（m=strlen（s1））||m+（n=strlen（s2））>
MAXN）
return（fail）;
return（success）;
statusstrsub（sl,i,j,s2）
charsl[],s2[];
inti,j;
{intm,k;
0||i>
=（m=strlen（sl）））
return（fail）;
if（j<
0||i+j>
m）
return（success）;
}………
voidmain（）
i=strlen（"
aassddd"
）;
scopy（s1,"
abcd"
scopy（s2,"
hijkl"
%s\n"
s1）;
strcat（s1,s2）;
strins（s1,4,s2）;
……….
实验八二叉树操作
1．进一步掌握指针变量的含义。
2．掌握二叉树的结构特征，以及各种存储结构的特点及使用范围。
3．掌握用指针类型描述、访问和处理二叉树的运算。
4．按照你二叉树的操作需要，重新改写主程序并运行，打印出文件清单和运行结果
按先序次序输入二叉树中结点的值（一个字符），`0`表示空树，生成二叉树的二叉链表存储结构，a为指向根结点的指针。
然后按中序顺序遍历二叉树。
算法思想：
先访问左子树,再访问根结点,最后访问右子树
参考程序如下：
#defineNULL0
typedefstructstu{
chardata;
structstu*left,*right;
}sn;
sn*Create（sn*a）
{charch;
scanf（"
ch）;
if（ch=='
）a=NULL;
else{a=（sn*）malloc（sizeof（sn））;
if（!
a）printf（"
yuguyuy"
a->
data=ch;
left=Create（a->
left）;
right=Create（a->
right）;
return（a）;
voidinc（sn*b）
{if（b）{inc（b->
b->
inc（b->
main（）
sn*t,*q;
q=NULL;
t=Create（q）;
inc（t）;
getch（）;
}实验数据：
abc00de0g00f000（0表示空格）
实验九图的操作
一．实验目的
1．掌握图的基本存储方法。
2．掌握有关图的操作算法并用高级语言编程实现；
3．熟练掌握图的两种搜索路径的遍历方法。
二．实验要求
1．认真阅读和掌握本实验的算法。
4．按照你对图的操作需要，重新改写主程序并运行，打印出文件清单和运行结果
三．实验内容
以邻接矩阵和邻接表的方式存储连通图。
然后分别用深度优先算法遍历邻接矩阵方式存储的图和邻接表方式存储的图。
算法如下：
深度优先遍历的递归算法
（1）深度优先遍历算法
intvisited[MaxVertexNum]；
//访问标志向量是全局量
voidDFSTraverse（ALGraph*G）
{//深度优先遍历以邻接表表示的图G，而以邻接矩阵表示G时，算法完全与此相同
inti；
G->
n;
visited[i]=FALSE；
//标志向量初始化
n；
if（!
visited[i]）//vi未访问过
DFS（G，i）；
//以v
升级会员 