推荐双向循环链表的创建及相关操作的实现课程设计说明书精品.docx
《推荐双向循环链表的创建及相关操作的实现课程设计说明书精品.docx》由会员分享，可在线阅读，更多相关《推荐双向循环链表的创建及相关操作的实现课程设计说明书精品.docx（30页珍藏版）》请在冰豆网上搜索。
推荐双向循环链表的创建及相关操作的实现课程设计说明书精品
山东建筑大学计算机科学与技术学院
课程设计说明书
题目：
双向链表的创建和操作的实现
树的创建及相关操作的实现
课程：
数据结构与算法
院（部）：
计算机学院
专业：
网络工程
班级：
网络101
学生姓名：
王天未
学号：
20XX111200
指导教师：
伊静
完成日期：
20XX-7-6
山东建筑大学计算机科学与技术学院
课程设计任务书1
设计题目
双向循环链表的创建及相关操作的实现
已知技术参数和设计要求
1、建立一个空表
2、插入第i个结点。
3、删除第i个结点。
4、插入第1个结点。
5、插入最后一个结点。
6、逆置
设计内容与步骤
1、设计存储结构
2、设计算法
3、编写程序，进行调试
4、总结并进行演示、讲解
设计工作计划与进度安排
做双向链表创建方法
做双向链表各种操作方法
设计考核要求
1、考勤20%
2、课程设计说明书50%
3、成果展示30%
指导教师（签字）：
教研室主任（签字）
山东建筑大学计算机科学与技术学院
课程设计任务书2
设计题目
树的创建及相关操作的实现
已知技术参数和设计要求
1、利用先序遍历和层次遍历的结果建立二叉树
2、实现二叉树的层次遍历
3、统计二叉树叶子结点的个数（递归）。
4、将二叉树左右子树相互交换（递归）
设计内容与步骤
1.建立结点类
2.构造BinaryTree（）
3.建立线序遍历树
4.建立层次遍历树
5.实现树的层次遍历
6.统计叶子结点个数
7.交换左右子树
8.输出树的方法
设计工作计划与进度安排
6月13日，实验课下完成先序遍历建树，16月14日课程设计时间完成层次遍历建树
6月16日课下完成层次遍历和叶子节点个数统计
6月18日课程设计时间完成二叉树左右子树相互交换
6月19日完成测试函数及纠错
设计考核要求
1、考勤20%
2、课程设计说明书50%
3、成果展示30%
指导教师（签字）：
教研室主任（签字）
双向循环链表的创建及相关操作的实现
一、问题描述
1、每个节点的next域构成了一个循环单链表
2、每个节点的prev域构成了另一个循环单链表
二、数据结构
针对所处理的树：
1、画出双向循环链表的存储结构
2、使用所选用语言的功能，描述该存储结构的实现
privatestaticclassNode{
AnyTypedata;
Nodeprev;
Nodenext;
}
三、逻辑设计
1、总体思路
对于双向循环链表，建立一个空表，然后实现双向循环链表的插入，删除操作。
为了便于逆置的操作，选择建立一个带头节点的双向循环链表，插入第一个节点和插入最后一个节点，只需要在0号位置和size（）位置插入节点就行。
2、模块划分（以图示的方法给出各个函数的调用关系）
3、函数或类的具体定义和功能
classNode//节点类定义
publicclassDlList//循环链表主类
publicbooleanadd（intidex,AnyTypex）//链表插入操作
publicAnyTyperemove（intidex）//链表删除操作
privatevoidinverse（）//链表逆置
四、编码
importjava.util.Scanner;
classNode{
publicAnyTypedata;
publicNodeprev;
publicNodenext;
publicNode（）{
data=null;
prev=null;
next=null;
}
publicNode（AnyTyped）{
data=d;
prev=null;
next=null;
}
publicNode（AnyTyped,Nodep,Noden）{
data=d;
prev=p;
next=n;
}
}//节点类
publicclassDlList{
privateNodeheadNode=newNode（）;//头标记或头节点
privateinttheSize;//长度
publicDlList（）{
headNode.next=headNode;
headNode.prev=headNode;
theSize=0;
}//创建一个空表
publicintsize（）{
returntheSize;
}//设定表的长度
publicbooleanadd（AnyTypex）{
add（theSize,x）;
returntrue;
}//链表输入操作
publicbooleanadd（intidex,AnyTypex）{
booleanflag;
if（idex<0||idex>theSize）{//判断插入的位置是否大于0
System.out.println（"您输入的要插入元素的位置不正确!
"）;
flag=false;
}else{
flag=true;
}
if（flag）{
Nodep;
p=getNode（idex）;
addBefore（p,x）;
}//插入操作
returnflag;
}
privatevoidaddBefore（Nodep,AnyTypex）{
NodenewNode=newNode（x,p.prev,p）;
newNode.prev.next=newNode;
p.prev=newNode;
theSize++;
}//插入方法
publicAnyTyperemove（intidex）{
returnremove（getNode（idex））;
}
privateAnyTyperemove（Nodep）{
p.prev.next=p.next;
p.next.prev=p.prev;
theSize--;
returnp.data;
}//删除操作
privatevoidinverse（）{
Nodep,q,l;
p=headNode.next;
q=p.next;
while（p!
=headNode）{
l=q.next;//空置的中转结点赋值
q.next=p;//将p、q链表的前后域置换。
q由p的后域变成前域
p.prev=q;
p=q;//置换后，将各个结点置换输出。
q=l;
}
q.next=p;
p.prev=q;//当p为头结点时，直接将前后域置换。
}//逆置
privateNodegetNode（intidex）{
Nodep;
if（idex<0||idex>size（））
thrownewIndexOutOfBoundsException（"getNodeidex:
"+idex+";size:
"+size（））;
if（idex{
p=headNode;
for（inti=0;i<=idex;i++）
p=p.next;
}
else{
p=headNode;
for（inti=size（）;i>idex;i--）{
p=p.prev;
}
}
returnp;
}//查找结点位置
publicvoidprint（）{
for（inti=0;iSystem.out.print（getNode（i）.data+""）;
System.out.println（）;
}//结果输出
publicvoidchoose（）{
System.out.println（"1.插入第i个节点"）;
System.out.println（"2.删除第i个节点"）;
System.out.println（"3.插入第一个节点"）;
System.out.println（"4.插入最后一个节点"）;
System.out.println（"5.逆置"）;
}//选择操作项
publicstaticvoidmain（String[]args）{
DlListdl=newDlList（）;
Scannersc=newScanner（System.in）;
intxuanze;
System.out.println（"请输入链表的元素的个数（大于0个）：
"）;
intn=sc.nextInt（）;
System.out.println（"请输入链表的"+n+"个元素：
"）;
for（inti=1;i<=n;i++）{
intl=sc.nextInt（）;
dl.add（l）;//链表元素输入
}
System.out.println（"您输入的链表为：
"）;
dl.print（）;//调用print方法，提示操作。
System.out.println（"请选择操作项：
"）;
dl.choose（）;//调用choose，选择操作。
while（true）{
xuanze=sc.nextInt（）;
switch（xuanze）{
case1:
System.out.println（"请输入要插入的位置下标和数据：
"）;
intidex=sc.nextInt（）;
intdata=sc.nextInt（）;
dl.add（idex,data）;
dl.print（）;
break;
case2:
System.out.println（"请输入要删除节点的下标：
"）;
intidex1=sc.nextInt（）;
dl.remove（idex1）;
dl.print（）;
break;
case3:
System.out.println（"请输入插入第一个节点的元素：
"）;
intdata1=sc.nextInt（）;
dl.add（0,data1）;
dl.print（）;
break;
case4:
System.out.println（"请输入插入最后位置的元素：
"）;
intdata2=sc.nextInt（）;
dl.add（dl.size（）,data2）;
dl.print（）;
break;
case5:
dl.inverse（）;
dl.print（）;
break;
default:
System.out.println（"你的输入有误，请重新输入！
"）;
break;
}
}
}
}
5、测试数据
1、对每个函数的测试数据
链表中的元素插入为1、2、3、4、5
插入第二个结点的元素为6
删除第二个节点的位置的元素6
插入第一个节点的元素为7
插入最后一个节点的元素为6
逆置链表
2、对程序整体的测试数据
输入元素为1、2、3、4、5的双向循环链表
六、测试情况
请输入链表的元素的个数（大于0个）：
5
请输入链表的5个元素：
1
2
3
4
5
您输入的链表为：
12345
请选择操作项：
1.插入第i个节点
2.删除第i个节点
3.插入第一个节点
4.插入最后一个节点
5.逆置
1
请输入要插入的位置下标和数据：
2
6
126345
请输入链表的元素的个数（大于0个）：
5
请输入链表的5个元素：
1
2
3
4
5
您输入的链表为：
12345
请选择操作项：
1.插入第i个节点
2.删除第i个节点
3.插入第一个节点
4.插入最后一个节点
5.逆置
2
请输入要删除的位置下标和数据：
2
6
12345
请输入链表的元素的个数（大于0个）：
5
请输入链表的5个元素：
1
2
3
4
5
您输入的链表为：
12345
请选择操作项：
1.插入第i个节点
2.删除第i个节点
3.插入第一个节点
4.插入最后一个节点
5.逆置
3
请输入插入第一个节点的元素：
7
712345
请输入链表的元素的个数（大于0个）：
5
请输入链表的5个元素：
1
2
3
4
5
您输入的链表为：
12345
请选择操作项：
1.插入第i个节点
2.删除第i个节点
3.插入第一个节点
4.插入最后一个节点
5.逆置
4
请输入插入最后位置的元素：
6
123456
请输入链表的元素的个数（大于0个）：
5
请输入链表的5个元素：
1
2
3
4
5
您输入的链表为：
12345
请选择操作项：
1.插入第i个节点
2.删除第i个节点
3.插入第一个节点
4.插入最后一个节点
5.逆置
5
54321
树的创建及相关操作的实现
一、问题描述
1.先遍序遍历建树
2、遍历方法举例：
先序遍历：
ABDCEF
层次遍历：
ABCDEF
二、数据结构
针对所处理的树：
1、画出存储结构
2、使用所选用语言的功能，实现上述的该存储结构
publicstaticclassBTNode{
privateAnyTypedata;
privateBTNodeparent;
privateBTNodeleftNode;
privateBTNoderightNode;
}
三、逻辑设计
1、总体思路
首先建立节点类，然后构造BinaryTree（），再构造先序遍历建树方法，层次遍历建树方法，层次遍历树的方法，统计叶子结点个数方法，交换子树方法，再调试。
2、模块划分（以图示的方法给出各个函数的调用关系）
3、函数或类的具体定义和功能
BiTNode（）//节点类定义
publicBiTNodecreatTree（AnyType[]a）//先序建树方法定义
privatevoidcreatPathBinaryTree（AnyType[]a）//层次遍历建树定义
publicvoidpathOrder（）//层次遍历方法定义
publicintcountLeafNode（）//统计叶子节点个数方法定义
四、编码
1.结点类定义
packagekcsj;
publicclassBiTNodeimplementsparable>{
AnyTypedata;
BiTNodeleft,right;
intweight;
BiTNode（）{
data=null;
left=right=null;
}
BiTNode（AnyTypethedata）{
data=thedata;
left=right=null;
}
BiTNode（AnyTypethedata,BiTNodelt,BiTNodert）{
data=thedata;
left=lt;
right=rt;
}
publicBiTNodegetLeft（）{
returnleft;
}
publicBiTNodegetRight（）{
returnright;
}
publicObjectgetData（）{
returndata;
}
publicdoublegetWight（）{
returnweight;
}
@Override
publicintpareTo（BiTNodeo）{
if（o.getWight（）>this.getWight（））
return1;
if（o.getWight（）return-1;
return0;
}
}
2.BinaryTree（）构造
packagekcsj;
importjava.util.LinkedList;
importjava.util.Queue;
publicclassBinaryTreesuperAnyType>>{
AnyType[]pre,in;
BiTNoderootNode=newBiTNode（）;
intcount=0;
publicBinaryTree（）{
rootNode=null;
}
publicBinaryTree（AnyTyperootNodeItem）{
rootNode.data=rootNodeItem;
rootNode.left=rootNode.right=null;
}
publicBinaryTree（BiTNodet）{
rootNode=t;
}
//1.先序遍历建树
publicBiTNodecreatTree（AnyType[]a）{
returnrootNode=creatBinaryTree（a）;
}
privateBiTNodecreatBinaryTree（AnyType[]a）{
BiTNodep=null;
if（countAnyTypedata=a[count];
count++;
if（data!
=null）{
p=newBiTNode（（AnyType）data）;
p.left=creatTree（a）;
p.right=creatTree（a）;
}
}
returnp;
}
//1.层次遍历排序建树
publicvoidcreatPathTree（AnyType[]a）{
if（a!
=null）{
creatPathBinaryTree（a）;
}
}
privatevoidcreatPathBinaryTree（AnyType[]a）{
Queue>q=newLinkedList>（）;
BiTNodenode=newBiTNode（a[0]）;
rootNode=node;
q.offer（node）;
inti=1;
while（iif（a[i]!
=null）{
node=newBiTNode（a[i]）;
q.element（）.left=node;
q.offer（q.element（）.left）;
}
if（iif（a[++i]!
=null）{
node=newBiTNode（a[i]）;
q.element（）.right=node;
q.offer（q.element（）.right）;
}
}
q.poll（）;
i++;
}
}
//2.实现二叉树的层次遍历
publicvoidpathOrder（）{
if（rootNode!
=null）
pathOrder（rootNode）;
}
publicvoidpathOrder（BiTNodet）{
Queue>q=newLinkedList>（）;
q.offer（t）;
while（!
q.isEmpty（））{
if（q.element（）.left!
=null）
q.offer（q.element（）.left）;
if（q.element（）.right!
=null）
q.offer（q.element（）.right）;
System.out.print（q.poll（）.data+""）;
}
}
//先序遍历
publicvoidpreOrder（）{
if（rootNode!
=
升级会员 