山东建筑大学计算机学院数据结构课程设计说明书.docx
《山东建筑大学计算机学院数据结构课程设计说明书.docx》由会员分享，可在线阅读，更多相关《山东建筑大学计算机学院数据结构课程设计说明书.docx（28页珍藏版）》请在冰豆网上搜索。
山东建筑大学计算机学院数据结构课程设计说明书
山东建筑大学计算机科学与技术学院
课程设计说明书
题目：
双向链表的创建和操作的实现
树的创建和相关操作的实现
院（部）：
计算机学院
专业：
网络工程
班级：
学生姓名：
学号：
指导教师：
伊静
完成日期：
2012-6-20
目录
课程设计任务书1I
课程设计任务书2II
双向循环链表的创建及相关操作的实现3
一、问题描述4
二、数据结构5
三、逻辑设计6
四、编码10
五、测试数据15
六、测试情况17
树的创建及相关操作的实现18
一、问题描述19
二、数据结构20
三、逻辑设计21
四、编码23
五、测试数据25
六、测试情况30
结论31
参考文献32
课程设计指导教师评语33
山东建筑大学计算机科学与技术学院
课程设计任务书1
设计题目
双向循环链表的创建及相关操作的实现
已知技术参数和设计要求
创建一个空表，对自己创建的表完成以下操作和要求：
1．建立一个有两个空节点的空表。
2．插入任意指定的位置一个元素。
3．删除指定位置的元素。
4．在第一个位置插入一个元素。
5．在最后一个位置插入一个元素。
设计内容与步骤
1、设计存储结构
2、设计算法
3、编写程序，进行调试
4、总结并进行演示、讲解
设计工作计划与进度安排
6月12—6月15做双向链表
设计考核要求
1、考勤20%
2、课程设计说明书50%
3、成果展示30%
指导教师（签字）：
教研室主任（签字）
山东建筑大学计算机科学与技术学院
课程设计任务书1
设计题目
树的创建及相关操作的实现
已知技术参数和设计要求
利用不同的存储方式和数据结构创建一个空树，对自己创建的树完成以下操作和要求：
1.用先序遍历结果创建二叉树。
2.实现二叉树的层次遍历
3.统计二叉树叶子节点的个数（递归）
4.将二叉树左右子树相互交换（递归）
5.利用先序和层次遍历的结果建立二叉树
设计内容与步骤
5、设计存储结构
6、设计算法
7、编写程序，进行调试
8、总结并进行演示、讲解
设计工作计划与进度安排
6月15—6月20做树
设计考核要求
4、考勤20%
5、课程设计说明书50%
6、成果展示30%
指导教师（签字）：
教研室主任（签字）
双向循环链表的创建及相关操作的实现
一、问题描述
二、数据结构
//Node类的定义
publicclassNode{
Nodeprev;
Nodenext;
AnyTypedata;
//构造方法，创建空节点
publicNode（）{
//TODOAuto-generatedconstructorstub
prev=next=null;
data=null;
}
//创建只含有数据的节点
publicNode（AnyTypedata）{
this.data=data;
prev=next=null;
}
}
三、逻辑设计
1、总体思路
先找出有用的数据存储结构-->编写相关方法-->完成对数据的操作
2、模块划分（以图示的方法给出各个函数的调用关系）
3、函数或类的具体定义和功能
Shuang（）构造方法
Delete（intidx）删除
add（AnyTypex）任意位置增加元素
nizhi（）链表的逆置
四、编码
//Node类的定义
publicclassNode{
Nodeprev;
Nodenext;
AnyTypedata;
//构造方法，创建空节点
publicNode（）{
//TODOAuto-generatedconstructorstub
prev=next=null;
data=null;
}
//创建只含有数据的节点
publicNode（AnyTypedata）{
this.data=data;
prev=next=null;
}
}
importjava.io.BufferedReader;
importjava.io.IOException;
importjava.io.InputStreamReader;
publicclassShuang{
staticintlength;
NodeheadNode,endNode;
Nodep;
//创建空表的构造方法
publicShuang（）{
//TODOAuto-generatedconstructorstub
headNode=newNode（）;
endNode=newNode（）;
headNode.next=endNode;
endNode.next=headNode;
endNode.prev=headNode;
headNode.prev=endNode;
p=null;
length=0;
}
//根据数组创建表的构造方法
publicShuang（AnyType[]data_array）{
//TODOAuto-generatedconstructorstub
headNode=newNode（）;
endNode=newNode（）;
headNode.next=endNode;
endNode.next=headNode;
endNode.prev=headNode;
headNode.prev=endNode;
p=null;
length=0;
//通过将数组里的数据添加到空表中实现
for（inti=0;ithis.add（data_array[i]）;
}
}
//插入方法的实现
publicNodeadd（AnyTypedata）{
//System.out.print（""+add（data,this.length）.data）;
returnadd（data,this.length）;
}
publicNodeadd（Objectdata,intindex）{
p=this.headNode;
NodenewNode=newNode（data）;
if（index<0||index>this.length）{
System.out.println（"index越界！
"）;
returnnull;
}elseif（index==0）{
newNode.next=headNode;
headNode.prev=newNode;
headNode=newNode;
headNode.prev=endNode;
endNode.next=headNode;
length++;
}else{
for（inti=0;inewNode.next=p.next;
newNode.prev=p;
p.next.prev=newNode;
p.next=newNode;
length++;
}
returnnewNode;
}
//删除方法的实现
publicNodedelete（）{
returndelete（length-1）;
}
publicNodedelete（intindex）{
p=headNode;
if（index<0||index>this.length-1）{
System.out.println（"index越界！
"）;
returnnull;
}elseif（index==0）{
Nodedele=headNode;
headNode=headNode.next;
length--;
returndele;
}else{
Nodem,n;
for（inti=0;ip=p.next;
}
m=p.prev;
n=p.next;
m.next=n;
n.prev=m;
length--;
returnp;
}
}
//逆置方法的实现
publicvoidnizhi（）{
for（inti=1;iNodenewone=delete（i）;
add（newone.data,0）;
}
}
//将链表的每个元素都按顺序输出
publicvoidprint（）{
p=headNode;
for（inti=0;iSystem.out.println（""+（p.data））;
p=p.next;
}
}
publicstaticvoidmain（Stringargs[]）{
//获取数据并创建链表
BufferedReaderbin=newBufferedReader（
newInputStreamReader（System.in））;
intlength=0;
System.out.println（"需要输入数据的个数：
"）;
try{
length=Integer.parseInt（bin.readLine（））;
}catch（NumberFormatExceptione）{
//TODOAuto-generatedcatchblock
e.printStackTrace（）;
}catch（IOExceptione）{
//TODOAuto-generatedcatchblock
e.printStackTrace（）;
}
Integer[]data_array=newInteger[length];
for（inti=0;iSystem.out.println（"输入第"+i+"个数据"）;
try{
data_array[i]=Integer.parseInt（bin.readLine（））;
}catch（NumberFormatExceptione）{
//TODOAuto-generatedcatchblock
e.printStackTrace（）;
}catch（IOExceptione）{
//TODOAuto-generatedcatchblock
e.printStackTrace（）;
}
}
Shuangshuang=newShuang（data_array）;
//shuang.nizhi（）;
shuang.add（9,0）;
//shuang.delete（）;
shuang.print（）;
}
}
五、测试数据
1、添加函数的测试
2、删除函数的测试
3、逆置函数的测试
六、测试情况
添加函数的测试
需要输入数据的个数：
5
输入第0个数据
1
输入第1个数据
2
输入第2个数据
3
输入第3个数据
4
输入第4个数据
5
现在将9添加到0号位置
现在进行遍历：
9
1
2
3
4
删除函数的测试
需要输入数据的个数：
5
输入第0个数据
1
输入第1个数据
2
输入第2个数据
3
输入第3个数据
4
输入第4个数据
5
现在删除最后一个数
现在进行遍历：
1
2
3
4
逆置函数的测试
需要输入数据的个数：
5
输入第0个数据
1
输入第1个数据
2
输入第2个数据
3
输入第3个数据
4
输入第4个数据
5
现在进行遍历：
1
2
3
4
5
现在进行逆置：
现在进行遍历：
5
4
3
2
1
树的创建及相关操作的实现
一、问题描述
二、数据结构
针对所处理的树：
1、存储结构
2、使用所选用语言的功能，实现上述的该存储结构
packagetree;
publicclassTreeNode{//树的节点的定义
TreeNodeleftch,rigthch;
intelement;
//构造方法
publicTreeNode（）{
//TODOAuto-generatedconstructorstub
}
publicTreeNode（intelement,TreeNodeleft,TreeNoderight）{
//TODOAuto-generatedconstructorstub
leftch=left;
rigthch=right;
this.element=element;
}
publicTreeNode（intelement）{
this.element=element;
leftch=rigthch=null;
}
}
三、逻辑设计
1、总体思路
先找出有用的数据存储结构-->编写相关方法-->完成对数据的操作
2、模块划分（以图示的方法给出各个函数的调用关系）
四、编码
packagetree;
importjava.io.BufferedReader;
importjava.io.IOException;
importjava.io.InputStreamReader;
importjava.util.ArrayList;
importjava.util.LinkedList;
publicclassTwoTree{
TreeNoderootNode;
publicTwoTree（）{
//TODOAuto-generatedconstructorstub
this.rootNode=newTreeNode（）;
}
publicTwoTree（TreeNoderoot）{
//TODOAuto-generatedconstructorstub
rootNode=root;
}
//1、利用先序遍历和中序遍历的结果建立二叉树
publicTreeNodecreatTree（ArrayListpreOrder,
ArrayListmidOrder）{
TreeNoderoot=null;
if（preOrder.size（）!
=0）{
Integerx=preOrder.get（0）;
root=newTreeNode（x）;
inti=midOrder.indexOf（x）;
ArrayListlist1=newArrayList（）;
ArrayListlist2=newArrayList（）;
ArrayListlist3=newArrayList（）;
ArrayListlist4=newArrayList（）;
for（intj=1;jlist1.add（preOrder.get（j））;
}
for（intj=0;jlist3.add（midOrder.get（j））;
}
for（intj=i+1;jlist2.add（preOrder.get（j））;
}
for（intj=i+1;jlist4.add（midOrder.get（j））;
}
root.leftch=creatTree（list1,list3）;
root.rigthch=creatTree（list2,list4）;
}
returnroot;
}
//2、实现二叉树的层次遍历
publicvoidcengOrder（）{
if（rootNode!
=null）{
ArrayListqueue=newArrayList（）;//队列
queue.add（rootNode）;
while（queue.size（）!
=0）{
TreeNodehead=queue.remove（0）;
System.out.println（""+head.element）;
if（head.leftch!
=null）{
queue.add（head.leftch）;
}
if（head.rigthch!
=null）{
queue.add（head.rigthch）;
}
}
}
}
publicvoidpreorder（TreeNoderoot）{
if（root!
=null）{
System.out.println（""+root.element）;
preorder（root.leftch）;
preorder（root.rigthch）;
}
}
//3、统计二叉树叶子结点的个数（递归）。
publicintcountLeafNode（TreeNoderoot）{
intm,n;
if（root!
=null）{
if（root.leftch==null&&root.rigthch==null）{
return1;
}else{
m=countLeafNode（root.leftch）;
n=countLeafNode（root.rigthch）;
returnm+n;
}
}
return0;
}
//4、将二叉树左右子树相互交换（递归）
publicvoidchangChild（TreeNoderoot）{
TreeNodeflag;
if（root!
=null）{
flag=root.leftch;
root.leftch=root.rigthch;
root.rigthch=flag;
changChild（root.leftch）;
changChild（root.rigthch）;
}
}
//判断是不是完全二叉树
publicbooleanisCompelete（TreeNoderoot）{
LinkedListqueue=newLinkedList（）;
TreeNodep;
if（root!
=null）{
queue.push（root）;
p=queue.pop（）;
while（p.leftch!
=null&&p.rigthch!
=null）{
queue.push（p.leftch）;
queue.push（p.rigthch）;
p=queue.pop（）;
}
if（!
（p.leftch==null&&p.rigthch!
=null））{
if（p.leftch!
=null）{
queue.push（p.leftch）;
p=queue.pop（）;
}
while（queue!
=null）{
if（!
（p.leftch==null&&p.rigthch==null））{
returnfalse;
}
p=queue.pop（）;
}
returntrue;
}
returnfalse;
}
returntrue;
}
//从键盘获取数组创建树
publicArrayListget_array（）{
BufferedReaderbin=newBufferedReader（
newInputStreamReader（System.in））;
intlength=0;
System.out.println（"需要输入数据的个数：
"）;
try{
length=Integer.parseInt（bin.readLine（））;
}catch（NumberFormatExceptione）{
//TODOAuto-generatedcatchblock
e.printStackTrace（）;
}catch（IOExceptione）{
//TODOAuto-generatedcatchblock
e.printStackTrace（）;
升级会员 