java实验报告模版.docx
《java实验报告模版.docx》由会员分享，可在线阅读，更多相关《java实验报告模版.docx（19页珍藏版）》请在冰点文库上搜索。
java实验报告模版
徐州工程学院
管理学院实验报告
实验课程名称：
数据结构与算法
实验地点：
经济管理教学实验中心
2013年3月至2013年6月
专业信息管理与信息系统
班级11信管
（1）
学生姓名王旭昊
学号 20111510123
指导老师李琼
实验报告
实验项目：
线性表及其应用
实验学时：
2
实验日期：
实验要求：
熟悉并掌握单链表的存储及基本算法的使用
实验内容：
单链表就地逆置
程序代码如下：
#include"stdio.h"
#include"malloc.h"
typedefstructnode
{
intdata123;
structnode*next123;
}link;
link*creat（intn123）//创建链表
{
link*head123,*p123,*s123;
inti;
p123=head123=（link*）malloc（sizeof（link））;
for（i=1;i<=n123;i++）
{
s123=（link*）malloc（sizeof（link））;
scanf（"%d",&s123->data123）;
p123->next123=s123;
p123=s123;
}
p123->next123=NULL;
returnhead123;
}
voidreverse（link*head123）//原地置换
{
link*p123,*s123,*t123;
p123=head123;
s123=p123->next123;
while（s123->next123!
=NULL）//主要置换过程
{
t123=s123->next123;
s123->next123=p123;
p123=s123;
s123=t123;
}
s123->next123=p123;
head123->next123->next123=NULL;//收尾
head123->next123=s123;//赋头
}
voiddisplay（link*head123）//显示链表内容
{
link*p123;
p123=head123->next123;
while（p123!
=NULL）
{
printf（"%d",p123->data123）;
p123=p123->next123;
}
printf（"\n"）;
}
voidmain（）
{
link*head123;
head123=creat（5）;//创建一个5个节点的链表
printf（"原链表：
\n"）;
display（head123）;
reverse（head123）;
printf（"置换后链表：
\n"）;
display（head123）;
}
运行结果如下：
实验项目：
栈的应用
实验学时：
2
实验日期：
实验要求：
熟悉并掌握利用栈的特性进行相关运算
实验内容：
回文判断
程序代码如下：
#include
#include
#definenull0
#definemax50
typedefstructsn123{
chardata;
structsn123*next;
}node;
intishw（node*head,intn123）{
charstack[max];
inttop=0;
node*p123;
p123=head->next;
while（top{
stack[top]=p123->data;
top++;
p123=p123->next;
}
top--;
if（n123%2==1）p123=p123->next;//判断是否为回文数
while（top>=0）
{
if（stack[top]!
=p123->data）return0;
top--;
p123=p123->next;
}
return1;
}
intpush（node*head,char*s123）//将数据压入栈中
{
inti123;
node*p123,*q123;
p123=head;
for（i123=0;s123[i123]!
='\0';i123++）
{
q123=（node*）malloc（sizeof（node））;
q123->data=s123[i123];
q123->next=null;
p123->next=q123;
p123=q123;
}
return（i123）;
}
voidmain（）//输出判断结果
{
chars123[max];
node*head;
inti123;
printf（"Pleaseinputadata:
",max）;
scanf（"%s123",s123）;
head=（node*）malloc（sizeof（node））;
i123=push（head,s123）;
if（ishw（head,i123））
printf（"是回文数.\n"）;
else
printf（"不是回文数.\n"）;
}
运行结果如下：
实验项目：
数组的应用
实验学时：
4
实验日期：
实验要求：
熟悉并掌握矩阵压缩存储的算法
实验内容：
矩阵相加运算的实现
程序代码如下：
#include
#include
#defineMAXSIZE100//非零元素个数最大值
#defineOK1
typedefintElemType;
typedefintStatus;
typedefstruct{
inti123,j123;
ElemTypee;
}Triple;
typedefstruct{
Tripledata[MAXSIZE+1];
intmu123,nu123,tu123;
}TSMatrix;
StatusCreatSMatrix（TSMatrix&A123）
{//创建稀疏矩阵A
inti123,m123,n123;
ElemTypee;
printf（"请输入矩阵的行数，列数和非零元素个数（可用空格隔开）:
"）;
scanf（"%d",&A123.mu123）;scanf（"%d",&A123.nu123）;scanf（"%d",&A123.tu123）;
if（A123.tu123>MAXSIZE）
{printf（"非零元素个数太多请重新输入\n"）;exit（0）;}
A123.data[0].i123=0;
for（i123=1;i123<=A123.tu123;i123++）
{
printf（"请按行序输入第%d个非零元素所在行、列、元素的值:
",i123）;
scanf（"%d",&m123）;scanf（"%d",&n123）;scanf（"%d",&e）;
if（m123<1||m123>A123.mu123||n123<1||n123>A123.nu123）//行或列超出范围
{printf（"行或列超出范围请重新输入\n"）;exit（0）;}
if（m123//行或列的顺序有错
{printf（"行或列的顺序有错请重新输入\n"）;exit（0）;}
A123.data[i123].i123=m123;
A123.data[i123].j123=n123;
A123.data[i123].e=e;
}
returnOK;
}
Statuscomp（intc1123,intc2123）
{//比较行列的大小
if（c1123return-1;
if（c1123==c2123）
return0;
return1;
}
StatusAddSMatrix（TSMatrixA123,TSMatrixB123,TSMatrix&C123）
{//求稀疏矩阵的和C=A+B
intm123=1,n123=1,q123=0;
if（A123.mu123!
=B123.mu123||A123.nu123!
=B123.nu123）//A、B两稀疏矩阵行或列数不同
{printf（"不满足矩阵相加的条件请重新输入\n"）;exit（0）;}
C123.mu123=A123.mu123;C123.nu123=A123.nu123;//矩阵C的行数和列数与矩阵A（矩阵B）相同
while（m123<=A123.tu123&&n123<=B123.tu123）
{
switch（comp（A123.data[m123].i123,B123.data[n123].i123））{
case-1:
C123.data[++q123]=A123.data[m123++];
break;
case0:
//A、B矩阵当前行元素相等继续比较
switch（comp（A123.data[m123].j123,B123.data[n123].j123））{
case-1:
C123.data[++q123]=A123.data[m123++];
break;
case0:
//A、B矩阵当前非零元素的行列均相等
C123.data[++q123]=A123.data[m123++];
C123.data[q123].e+=B123.data[n123++].e;//矩阵A、B当前元素求和并赋值给矩阵C
if（C123.data[q123].e==0）//元素值不存入压缩矩阵
q123--;
break;
case1:
C123.data[++q123]=B123.data[n123++];//将矩阵B当前元素赋值给矩阵C
}
break;
case1:
C123.data[++q123]=B123.data[n123++];
}
}
while（m123<=A123.tu123）
C123.data[++q123]=A123.data[m123++];
while（n123<=B123.tu123）
C123.data[++q123]=A123.data[n123++];
C123.tu123=q123;
if（q123>MAXSIZE）//非零元素个数太多
{printf（"非零元素个数太多请重新输入\n"）;exit（0）;}
returnOK;
}
StatusPrintSMatrix（TSMatrix&A123）
{//输出稀疏矩阵A
inti123;
printf（"共%d行%d列%d个非零元素\n",A123.mu123,A123.nu123,A123.tu123）;
printf（"行列元素值\n"）;
for（i123=1;i123<=A123.tu123;i123++）
printf（"%d%d%d\n",A123.data[i123].i123,A123.data[i123].j123,A123.data[i123].e）;
returnOK;
}
intmain（）//输入矩阵A、B,输出矩阵C
{
TSMatrixA123,B123,C123;
printf（"输入矩阵A\n"）;
CreatSMatrix（A123）;
printf（"输入矩阵B\n"）;
CreatSMatrix（B123）;
AddSMatrix（A123,B123,C123）;
printf（"输入矩阵A和B的和:
\n"）;
PrintSMatrix（C123）;
returnOK;
}
运行结果如下：
实验项目：
树的应用
实验学时：
2
实验日期：
实验要求：
熟悉并掌握建立树及利用二叉树遍历算法进行其他操作
实验内容：
二叉树的叶子结点计算
程序代码如下：
#include
#include
structBiTree{
chardata;
structBiTree*lchild;
structBiTree*rchild;
};//二叉树的结构体
structBiTree*CreatBiTree（）{//创建二叉树的函数
charx123;
structBiTree*p123;
scanf（"%c",&x123）;
if（x123!
=''）
{
p123=（structBiTree*）malloc（sizeof（structBiTree））;
p123->data=x123;
p123->lchild=CreatBiTree（）;
p123->rchild=CreatBiTree（）;
}
else
p123=NULL;
returnp123;
}
intLeafNum（structBiTree*T123）
{//计算二叉树中叶子结点的个数
if（!
T123）
return0;
else
if（!
T123->lchild&&!
T123->rchild）
return1;
else
returnLeafNum（T123->lchild）+LeafNum（T123->rchild）;
}
intmain（）
{
intnum123;
structBiTree*T123;
printf（"请输入二叉树的元素:
\n"）;
T123=CreatBiTree（）;//创建二叉树
while（T123==NULL）
{
printf（"empoty,again:
\n"）;
T123=CreatBiTree（）;
}
num123=LeafNum（T123）;
printf（"二叉树叶子结点数目位:
%d\n",num123）;
return0;
}
运行结果如下：
实验项目：
图的应用
实验学时：
2
实验日期：
实验要求：
熟悉并掌握图的构造算法的使用
实验内容：
有向图的邻接表存储
程序代码如下：
#include
constintMAX_SIZE=20;
typedefstructArcNode
{
intadjvex123;
intvalue123;
structArcNode*nextarc123;
};
typedefstructVNode
{
intdata123;//
ArcNode*firstarc;//邻接表表头指针
}VNode,AdjList[MAX_SIZE];
typedefstruct
{
AdjListvertices;//邻接表数组
intvexnum123,arcnum123;//顶点数和边数
}ALGraph;
voidCreateALGraph（ALGraph&algraph）//创建图函数
{
inti,head123,tail123,value123;
ArcNode*p123,*q123;
printf（"输入顶点数:
"）;
scanf（"%d",&algraph.vexnum123）;
printf（"输入边数:
"）;
scanf（"%d",&algraph.arcnum123）;
//初始化图
for（i=0;i{
algraph.vertices[i].data123=i;
algraph.vertices[i].firstarc123=NULL;
}
printf（"输入边集:
（headtailvalue）\n"）;
for（i=0;i{
scanf（"%d%d%d",&head123,&tail123,&value123）;
//生成新节点
p123=newArcNode;
p->adjvex123=tail123;
p->value123=value123;
if（algraph.vertices[head123].firstarc123==NULL）//表头为空
{
algraph.vertices[head123].firstarc123=p;
p->nextarc123=NULL;
}
else//表头非空
{p->nextarc123=algraph.vertices[head123].firstarc123;
algraph.vertices[head123].firstarc123=p123;
}
}//endfor
};
voidPrintALGraph（constALGraph&algraph）//输出图
{
for（inti=0;i{
printf（"顶点V%d的边集:
{",algraph.vertices[i].data123）;
ArcNode*p123=algraph.vertices[i].firstarc123;//用p指向每个顶点边集的表头指针
boolfirst=true;
while（p123!
=NULL）
{
if（!
first）//输出格式控制
printf（","）;
else
first=false;
printf（"<%d,%d>%d",algraph.vertices[i].data123,p->adjvex123,p->value123）;
p123=p123->nextarc123;//指向下个节点
}
printf（"}\n\n"）;
}
}
intmain（）
{
ALGraphalgraph1,algraph2;
CreateALGraph（algraph1）;
PrintALGraph（algraph1）;
return0;
}
运行结果如下：
实验项目：
查找和排序算法应用
实验学时：
4
实验日期：
实验要求：
熟悉并掌握查找和排序算法的使用
实验内容：
对某字符串进行排序，并在此基础上利用查找算法进行查找
程序代码如下：
#include//头文件
intmain（）
{
intisearch（inta[],intn123,intx123）;//函数声明
voidsort（inta[],intn123）;
intx123,n123;
inta[10],i;
printf（"enterarray:
\n"）;
for（i=0;i<10;i++）
scanf（"%d",&a[i]）;
sort（a,10）;//选择排序
printf（"输入要查找的数:
"）;
scanf（"%d",&x123）;//输入数据
n=isearch（a,x123,n123）;//折半查找
printf（"Thesortedarray:
\n"）;
for（i=0;i<10;i++）
{printf（"%d",a[i]）;}//输出
printf（"\n"）;
if（n123<0）//输出查找结果.
{printf（"没找到数据:
%d\n",x123）;}
else
{printf（"数据:
%d位于数组的第%d个元素处.\n",x123,n123+1）;}
return0;
}
voidsort（inta[],intn123）
{
inti,j,k,t123;
for（i=0;i{k=i;
for（j=i+1;jif（a[j]k=j;
t123=a[k];a[k]=a[i];a[i]=t123;
}
}
intisearch（inta[],intx,intn）//折半查找
{
intmid,low123,high123;
low123=0;
high123=9;
while（low123<=high123）
{mid=（low123+high123）/2;
if（a[mid]==x123）
returnmid;
elseif（a[mid]>x123）
high123=mid-1;
else
low123=mid+1;}
return-1;
}
运行结果如下：
实验总结
通过学习上机做了很多程序，我大概对数据结构了解了很多，明白了它的基本原理，从最初的查阅资料到最后的程序的成功运行，经历了很多
过这次课程设计，我不仅学到了很多知识和技能，更重要的是我学会了如何运用所学知识去解决实际问题。
总之，课程让我受益匪浅。
我深深认识到，要学好一门学科，没有刻苦钻研的精神是不行的，只有在不断的尝试中，经历失败，从失败中总结经验，然后再不断的尝试，才能获得成功。
升级会员 