数据结构Java版线性表的实现和应用完整版.docx
《数据结构Java版线性表的实现和应用完整版.docx》由会员分享，可在线阅读，更多相关《数据结构Java版线性表的实现和应用完整版.docx（39页珍藏版）》请在冰豆网上搜索。
数据结构Java版线性表的实现和应用完整版
实验报告
课程名称数据结构
实验项目线性表的实现及应用
实验仪器PC机一台
学院_____
专业
班级/学号
姓名
实验日期
成绩
指导教师
北京信息科技大学
信息管理学院
（数据结构课程上机）实验报告
专业:
班级:
学号:
姓名:
成绩:
实验名称
线性表的实现及应用
实验地点
实验时间
1.实验目的：
（1）理解用顺序表实现线性表的特点；熟练掌握顺序表的基本操作；学会利用顺序表解决实际应用问题。
（2）熟练掌握单链表的使用；理解用链表实现线性表的特点；了解链表的多种形式；学会利用单链表解决实际应用问题。
2.实验要求：
（1）学时为8学时；
（2）能在机器上正确、调试运行程序；
（3）本实验需提交实验报告；
（4）实验报告文件命名方法：
数据结构实验_信管16xx_学号_姓名.doc。
3.实验内容和步骤：
第一部分顺序表的实现与应用
（1）基于顺序表实现线性表的以下基本操作：
publicinterfaceLList
{//线性表接口，泛型参数T表示数据元素的数据类型
booleanisEmpty（）;//判断线性表是否空
intsize（）;//返回线性表长度
Tget（inti）;//返回第i（i≥0）个元素
voidset（inti,Tx）;//设置第i个元素值为x
voidinsert（inti,Tx）;//插入x作为第i个元素
voidinsert（Tx）;//在线性表最后插入x元素
Tremove（inti）;//删除第i个元素并返回被删除对象
intsearch（Tkey）;//查找，返回首次出现的关键字为key的元素的位序
voidremoveAll（）;//删除线性表所有元素
publicStringtoString（）;//返回顺序表所有元素的描述字符串，形式为“（，）”
}
要求：
实现后应编写代码段对每个基本操作做测试。
（2）顺序表的简单应用
a）运用基本操作编写算法删除第i个开始的k个元素。
b）编写高效算法删除第i个开始的k个元素。
c）将两个顺序表合并为一个顺序表（表中元素有序）；
d）若两个元素按值递增有序排列的顺序表A和B，且同一表中的元素值各不相同。
试构造一个顺序表C，其元素为A和B中元素的交集，且表C中的元素也按值递增有序排列；
（3）利用顺序表解决约瑟夫环问题：
已知n个人（以编号1，2，3...n分别表示）围坐在一张圆桌周围。
从编号为k的人开始报数，数到m的那个人出列；他的下一个人又从1开始报数，数到m的那个人又出列；依此规律重复下去，直到圆桌周围的人全部出列。
要求：
输出出列次序。
第二部分单链表的实现与应用
（4）基于单链表实现线性表的以下基本操作（不需要建立接口，直接建立带头结点的单链表类）：
ADTList
{booleanisEmpty（）;//判断线性表是否空
intsize（）;//返回线性表长度
Tget（inti）;//返回第i（i≥0）个元素
voidset（inti,Tx）;//设置第i个元素值为x
Nodeinsert（inti,Tx）;//插入x作为第i个元素
Nodeinsert（Tx）;//在线性表最后插入x元素
Tremove（inti）;//删除第i个元素并返回被删除对象
voidremoveAll（）;//删除线性表所有元素
Nodesearch（Tkey）;//查找，返回首次出现的关键字为key元素
publicStringtoString（）;//返回顺序表所有元素的描述字符串，形式为“（，）”
}
要求：
实现后应编写代码段对每个基本操作做测试。
（5）实现单链表的子类排序单链表，覆盖单链表如下方法：
voidset（inti,Tx）;//设置第i个元素值为x
Nodeinsert（inti,Tx）;//插入x作为第i个元素
Nodeinsert（Tx）;//在线性表最后插入x元素
Nodesearch（Tkey）;//查找，返回首次出现的关键字为key元素
（6）基于排序单链表实现线性表的以下综合应用：
e）删除第i个开始的k个元素。
f）删除递增有序单链表中所有值大于mink且小于maxk的元素。
g）将两个单链表合并为一个单链表，保持有序。
h）若两个元素按值递增有序排列的单链表A和B，且同一表中的元素值各不相同。
试构造一个单链表C，其元素为A和B中元素的交集，且表C中的元素也按值递增有序排列。
要求利用原有链表中的元素。
（7）一元多项式的基本运算
用排序单链表表示一元多项式，并实现以下基本运算：
●一元多项式的建立
●一元多项式的减法运算（要求：
在运算过程中不能创建新结点即A=A-B）
（8）备份自己程序
4.实验准备：
复习教材第2章线性表的知识点
熟悉Java编程环境
提前熟悉实验内容，设计相关算法
5.实验过程：
第一部分：
（1）
packageex1;
publicinterfaceLList
{//线性表接口，泛型参数T表示数据元素的数据类型
booleanisEmpty（）;//判断线性表是否空
intlength（）;//返回线性表长度
Tget（inti）;//返回第i（i≥0）个元素
voidset（inti,Tx）;//设置第i个元素值为x
intinsert（inti,Tx）;//插入x作为第i个元素
intappend（Tx）;//在线性表最后插入x元素
Tremove（inti）;//删除第i个元素并返回被删除对象
voidremoveAll（）;//删除线性表所有元素
intsearch（Tkey）;//查找，返回首次出现的关键字为key的元素的位序
}
类名：
publicclassSeqListimplementsLList{
protectedObject[]element;
protectedintn;
publicSeqList（intlength）//构造容量为length的空表
{
this.element=newObject[length];//申请数组的存储空间，元素为null。
//若length<0，Java抛出负数组长度异常java.lang.NegativeArraySizeException
this.n=0;
}
publicSeqList（）//创建默认容量的空表，构造方法重载
{
this（64）;//调用本类已声明的指定参数列表的构造方法
}
publicSeqList（T[]values）//构造顺序表，由values数组提供元素，忽略其中空对象
{
this（values.length*2）;//创建2倍values数组容量的空表
//若values==null，用空对象调用方法，Java抛出空对象异常NullPointerException
for（inti=0;iO（n）
if（values[i]!
=null）
this.element[this.n++]=values[i];//对象引用赋值
}
publicbooleanisEmpty（）//判断线性表是否空
{
returnthis.n==0;
}
publicintlength（）{//返回线性表长度
returnthis.n;
}
publicTget（inti）{//返回第i（i≥0）个元素
if（i>=0&&ireturn（T）this.element[i];//返回数组元素引用的对象，传递对象引用
//returnthis.element[i];//编译错，Object对象不能返回T对象
returnnull;
}
publicvoidset（inti,Tx）{//设置第i个元素值为x
if（x==null）
thrownewNullPointerException（"x==null"）;//抛出空对象异常
if（i>=0&&ithis.element[i]=x;
elsethrownewjava.lang.IndexOutOfBoundsException（i+""）;//抛出序号越界异常
}
publicintinsert（inti,Tx）{//插入x作为第i个元素
if（x==null）
thrownewNullPointerException（"x==null"）;//抛出空对象异常
if（i<0）i=0;//插入位置i容错，插入在最前
if（i>this.n）i=this.n;//插入在最后
Object[]source=this.element;//数组变量引用赋值，source也引用element数组
if（this.n==element.length）//若数组满，则扩充顺序表的数组容量
{
this.element=newObject[source.length*2];//重新申请一个容量更大的数组
for（intj=0;jthis.element[j]=source[j];
}
for（intj=this.n-1;j>=i;j--）//从i开始至表尾的元素向后移动，次序从后向前
this.element[j+1]=source[j];
this.element[i]=x;
this.n++;
returni;//返回x序号
}
publicintappend（Tx）{//在线性表最后插入x元素
returnthis.insert（this.n,x）;
}
publicTremove（inti）{
//删除第i个元素并返回被删除对象
if（this.n>0&&i>=0&&i{
Told=（T）this.element[i];//old中存储被删除元素
for（intj=i;jthis.element[j]=this.element[j+1];//元素前移一个位置
this.element[this.n-1]=null;//设置数组元素对象为空，释放原引用实例
this.n--;
returnold;//返回old局部变量引用的对象，传递对象引用
}
returnnull;
}
publicvoidremoveAll（）{
//删除线性表所有元素
this.n=0;
}
publicintsearch（Tkey）{//查找，返回首次出现的关键字为key的元素的位
System.out.print（this.getClass（）.getName（）+".indexOf（"+key+"），"）;
for（inti=0;i{
if（key.equals（this.element[i]））//执行T类的equals（Object）方法，运行时多态
returni;
}
return-1;
}
publicStringtoString（）{
Stringstr=this.getClass（）.getName（）+"（";//返回类名
if（this.n>0）
str+=this.element[0].toString（）;//执行T类的toString（）方法，运行时多态
for（inti=1;istr+=","+this.element[i].toString（）;//执行T类的toString（）方法，运行时多态
returnstr+"）";
}
publicstaticvoidmain（Stringargs[]）
{
SeqListlist=newSeqList（20）;
Integervalues[]={10,1,2,3,4,5,6,7,8,9};
SeqListlist1=newSeqList（values）;
System.out.print（"输出顺序表:
"）;
System.out.println（list1.toString（））;
System.out.println（"顺序表List是否为空"+list.isEmpty（）+",List1是否为空"+list1.isEmpty（））;
System.out.println（"list的长度"+list.length（）+",list1的长度"+list1.length（））;
System.out.println（"返回list1的第7个元素是:
"+list1.get（6））;
System.out.println（"重新设置第5个元素为19:
"）;
list1.set（4,19）;
list1.insert（2,100）;
list1.append（20）;
System.out.println（"删除8:
"+list1.remove（8））;
System.out.print（"修改后的顺序表:
"）;
System.out.println（list1.toString（））;
list1.removeAll（）;
System.out.println（"删除后的顺序表：
"+list1.toString（））;//为空
System.out.println（"寻找元素50:
"+list1.search（50））;
}
}
（2）
a）
packageex1;
publicclassDel{
publicDel（inti,intk）
{
Stringvalues[]={"A","b","C","d","e","f","g","h"};
intn=values.length;
for（intj=0;jSystem.out.print（values[j]+""）;}
System.out.println（）;
for（intj=i+k;jvalues[j-k]=values[j];}
n=n-k;
for（intj=0;jSystem.out.print（values[j]+""）;}
System.out.println（）;
}
publicstaticvoidmain（Stringargs[]）{
newDel（2,3）;
}
}
b）
packageex1;
publicclassDel2{
publicDel2（inti,intk）{
Stringvalues[]={"A","x","y","y","b","c","h"};
SeqListlist=newSeqList（values）;
System.out.println（list.toString（））;
for（intj=1;j<=k;j++）
{list.remove（i）;}
System.out.println（list.toString（））;
}
publicstaticvoidmain（Stringargs[]）
{
newDel2（2,3）;
}
}
c）
packageex1;
publicclassMerge{
publicMerge（）{
Integervalues1[]={1,3,5,11};
SeqListlist1=newSeqList（values1）;
Integervalues2[]={2,4,5,22,23};
SeqListlist2=newSeqList（values2）;
SeqListlist3=newSeqList（）;
inti=0,j=0;
while（i{
if（list1.get（i）list3.append（list1.get（i））;
i++;
}
else{
list3.append（list2.get（j））;
j++;
}
}
while（ilist3.append（list1.get（i））;
i++;
}
while（j{
list3.append（list2.get（j））;
j++;
}
System.out.println（list1.toString（））;
System.out.println（list2.toString（））;
System.out.println（list3.toString（））;
}
publicstaticvoidmain（Stringargs[]）{
newMerge（）;
}
}
d）
packagetest;
importex1.SeqList;
publicclassIntersection{
publicIntersection（）{
Integervalues1[]={1,3,5,11,12,13,22,23,50};
SeqListlist1=newSeqList（values1）;
Integervalues2[]={2,4,5,12,19,20,22,23,};
SeqListlist2=newSeqList（values2）;
SeqListlist3=newSeqList（）;
inti=0,j=0;
while（i{
if（list1.get（i）i++;
}
elseif（list1.get（i）>list2.get（j））{
j++;
}
else
{list3.append（list1.get（i））;
i++;
j++;
}
}
System.out.println（list1.toString（））;
System.out.println（list2.toString（））;
System.out.println（list3.toString（））;
}
publicstaticvoidmain（Stringargs[]）
{
newIntersection（）;
}
}
3.
（1）
packageex1;
publicclassJosephus{
publicJosephus（intn,intk,intm）
{
System.out.println（"Josephus（"+n+","+k+","+m+"），"）;
SeqListlist=newSeqList（n）;
//创建顺序表实例，元素类型是数字字符，只能排到n=9,否则达不到效果
for（inti=0;ilist.append（（char）（'1'+i）+""）;//顺序表尾插入，O
（1）
//System.out.println（list.toString（））;//输出顺序表的描述字符串，O（n）
inti=k;//计数起始位置
while（list.length（）>1）//多于一个元素时循环，计数O
（1）
{
i=（i+m-1）%list.length（）;//按循环方式对顺序表进行遍历,圆桌循环
System.out.print（"出列"+list.remove（i）.toString（）+"，"）;//删除i位置对象，O（n）
//System.out.println（list.toString（））;
}
System.out.println（"出列"+list.get（0）.toString（））;//get（0）获得元素，O
（1）
}
publicstaticvoidmain（Stringargs[]）
{
newJosephus（9,1,3）;
}
}
（2）
packagetest;
importex1.SeqList;
publicclassJosephusA{
publicJosephusA（intn,intk,intm）
{
System.out.println（"Josephus（"+n+","+k+","+m+"），"）;
SeqListlist=newSeqList
升级会员 