数据结构Java版实验报告

基于java数据结构实验报告+-+栈

实验报告break;case ')': if (stack1.isEmpty() || !stack1.pop().equals("(")) //遇见右括号时，出栈return "期望("; //检查出栈字符是否为左括号}}return (stack1.isEmpty()) ? "无" : "期望)"; //返回空串表示没有错误}public static void main(String args[]){String infix="((1+2)*3+4";System.out.println(infix+" ，编译错误："+Bracket.isMatched(infix));}4.中缀表达式转后缀表达式；根据后缀表达式求值。

（可选）运行结果：顺序栈表的测试及结果：单链栈表的测试及结果：实验总结：栈是特殊的线性表，其存储结构和线性表很相似，分为顺序存储和链式存储。

顺序存储类似于高级语言中的数组，可用数组的相关方法实运算，链式存储类似于高级语言中的指针，可通过类的对象引用实现指针运算。

栈只允许在其一端进行操作，对其算法的实现起到瓶颈的作用。

附：源程序：建立顺序栈，实现入栈，出栈等基本操作。

package StackTable;public class SequeueStack<T>{private int size=10;private int count;private int top;private T[] stack;public SequeueStack() {top=-1;stack=(T[])new Object[size];count=0;}public SequeueStack(int n) {top=-1;stack=(T[])new Object[n];count=0;}public boolean isEmpty() {return top==-1;}public boolean isFull() {return top==size;}public boolean push(T obj) {if (isFull()) {System.out.println("栈满");return false;}stack[++top]=obj;count++;return true;}public T pop() {if (isEmpty()) {System.out.println("栈空");return null;}T sc=stack[top--];count--;return sc;}public void list() {if(isEmpty()) {System.out.println("栈空");}for(int i=top;i>=0;i--) {System.out.println("stack["+i+"]="+stack[i]);}}public static void main(String[] args) {SequeueStack<String> stack1=new SequeueStack<String>(5);stack1.push("王帆");stack1.push("李明");stack1.push("李华");stack1.push("张三");stack1.push("李四");stack1.list();System.out.println("出栈的是："+stack1.pop());System.out.println("出栈后：");stack1.list();// TODO Auto-generated method stub}}掌握链栈基本操作的算法实现；package linkedList;class StackNode<T>{private T data;private StackNode next;public StackNode(T obj) {this.data =obj;}@Overridepublic String toString() {return"StackNode [data=" + data + "]";}public StackNode getNext() {return next;}public void setNext(StackNode next) {this.next = next;}}public class SingleLinkStack<T> {private StackNode top;public SingleLinkStack() {top=null;}public boolean isEmpty() {return top==null;}public boolean push(StackNode s) {s.setNext(top);top=s;return true;}public StackNode pop() {if (isEmpty()) {System.out.println("栈空");return null;}StackNode sc=top;top=top.getNext();return sc;}public void list() {StackNode temp=top;while(temp!=null) {System.out.println(temp);temp=temp.getNext();}}public static void main(String[] args) {StackNode<String> node1=new StackNode<String>("王帆");StackNode<String> node2=new StackNode<String>("小明");StackNode<String> node3=new StackNode<String>("小王");StackNode<String> node4=new StackNode<String>("小红");StackNode<String> node5=new StackNode<String>("小华");SingleLinkStack<String> list1 = new SingleLinkStack<String>();list1.push(node1);list1.push(node2);list1.push(node3);list1.push(node4);list1.push(node5);list1.list();System.out.println("出栈的是："+list1.pop());System.out.println("出栈后：");list1.list();// TODO Auto-generated method stub}}括号匹配问题package seqList;import java.util.Stack;public class Bracket {public static void main(String[] args) {String infix="((1+2)*3+4) ";System.out.println(infix+",编译错误："+Bracket.isMatched(infix));// TODO Auto-generated method stub}public static String isMatched(String infix) {Stack<String> stack1 = new Stack<String>();for (int i = 0; i < infix.length(); i++) {char ch=infix.charAt(i);switch(ch) {case'(': stack1.push(ch+"");break;case')':if(stack1.isEmpty()||!stack1.pop().equals("(")) {return"缺少(";}break;}}return (stack1.isEmpty())?"无":"缺少)";}}。

数据结构Java版实验报告

实现代码：
packagecfj;
importjava.util.Scanner;
publicclassData {
int[]cfj;
publicData(int[] str){
cfj=str;
}
publicvoidprintMax(){
intmax =cfj[0];
for(inti = 0; i<cfj.length;i++){
（2）理解抽象数据类型的定义，编写完整的程序实现一个抽象数据类型（如三元组）；
（3）认真阅读和掌握本实验的参考程序，上机运行程序，保存和打印出程序的运行结果，并结合程序进行分析。
二、实验内容及结果
（1）编程实现对一组从键盘输入的数据，计算将计算过程写成一个函数，并采用引用参数实现值的求解。
if(max <cfj[i]){
max =cfj[i];
}
}
System.out.println("最大值为："+max);
}
publicvoidprintMin(){
intmin =cfj[0];
for(inti = 0; i<cfj.length;i++){
if(min >cfj[i]){
min =cfj[i];
System.out.println("请输入第"+(i+1)+"数字");
cfj1 [i] = in.nextInt();
}
Data d =newData(cfj1);
d.printMax();
d.printMin();
}
}

6数据结构实验报告JAVA-链表

void creat() throws Exception {///*输入一系列整数，以 0 标志结束，将这些整数作为//data 域并用头插法建立一个带头结点的单链表
Scanner sc = new Scanner(System.in);// 构造用于输入的对象 for (int x=sc.nextInt(); x!=0; x=sc.nextInt())// 输入 n 个元素的值
⑶ 链表插入操作的基本步骤：先确定要插入的位置，如果插入位置合法，则再生成新的结点，最后通过修改链将新结点插入到指定的位置上。
⑷ 链表删除操作的基本步骤：先确定要删除的结点位置，如果位置合法，则再通过修改链使被删结点从链表中“卸下”，最后释放被删结点的空间。【核心算法描述】
⑴ 用头插法创建带头结点的单链表操作算法
立链表的过程是一个结点“逐个插入” 的过程。先建立一个只含头结点的空单链表，然后依次生成新结点，再不断地将其插入到链表的头部或尾部，分别称其为“头插法”和“尾插法”。
⑵ 链表查找操作的基本步骤：因链表是一种"顺序存取"的结构，则要在带头结点的链表中查找到第 i 个元素，必须从头结点开始沿着后继指针依次"点数"，直到点到第 i 个结点为止,如果查找成功，则用 e 返回第 i 个元素值。头结点可看成是第 0 个结点。
实验二链表
一、实验目的
熟练掌握线性表在链式存储结构上的基本操作。
二、实验平台操作系统：Windows7 或 Windows XP 开发环境：JAVA
三、实验内容及要求
建立单链表，并在单链表上实现插入、删除和查找操作四、实验的软硬件环境要求
硬件环境要求： PC 机（单机）
使用的软件名称、版本号以及模块： Netbeans 6.5 以上或 Eclipse、MyEclipse 等编程环境下。

Java数据结构实验报告

Java数据结构实验报告Java数据结构实验报告引言：数据结构是计算机科学中非常重要的一个领域，它研究如何组织和存储数据，以便能够高效地访问和操作。

在本次实验中，我们将使用Java语言实现几种常见的数据结构，并进行性能测试和分析，以便更好地理解它们的特点和应用场景。

一、数组：数组是最简单的数据结构之一，它由相同类型的元素组成，并按照一定的顺序存储在连续的内存空间中。

在Java中，数组的长度是固定的，一旦创建后就无法改变。

我们可以通过索引来访问数组中的元素，这使得数组的访问速度非常快。

在本次实验中，我们通过比较不同大小的数组在插入、删除和查找操作上的性能表现，来分析数组的优缺点。

实验结果显示，数组在查找操作上的性能非常好，时间复杂度为O(1)，但在插入和删除操作上的性能较差，时间复杂度为O(n)。

因此，数组适用于那些需要频繁访问元素，但很少进行插入和删除操作的场景。

二、链表：链表是另一种常见的数据结构，它由节点组成，每个节点包含数据和指向下一个节点的指针。

与数组不同，链表的长度可以动态改变，这使得它更加灵活。

在Java中，链表有多种实现方式，如单链表、双向链表和循环链表等。

在本次实验中，我们比较了不同类型链表在插入、删除和查找操作上的性能表现。

实验结果显示，单链表在插入和删除操作上的性能非常好，时间复杂度为O(1)，但在查找操作上的性能较差，时间复杂度为O(n)。

相比之下，双向链表在插入、删除和查找操作上都具有较好的性能，时间复杂度均为O(1)。

因此，链表适用于那些需要频繁进行插入和删除操作的场景。

三、栈和队列：栈和队列是两种特殊的数据结构，它们都是在一端进行插入和删除操作的。

栈遵循先进后出（LIFO）的原则，而队列遵循先进先出（FIFO）的原则。

在Java 中，栈和队列可以使用数组或链表来实现。

在本次实验中，我们通过比较数组栈、链表栈、数组队列和链表队列在插入、删除和查找操作上的性能表现，来分析它们的特点和适用场景。

java实验实验报告

java实验实验报告Java 实验实验报告一、实验目的本次 Java 实验的主要目的是通过实际操作和编程实践，深入理解和掌握 Java 编程语言的基本概念、语法结构、面向对象编程的思想以及常用类库的使用。

同时，培养我们解决实际问题的能力和编程思维，提高代码的质量和可读性。

二、实验环境1、操作系统：Windows 102、开发工具：IntelliJ IDEA3、 JDK 版本：18三、实验内容（一）基本语法练习1、数据类型与变量在 Java 中，我们学习了不同的数据类型，如整数类型（｀int`、｀long`）、浮点数类型（｀float`、｀double`）、字符类型（｀char`）和布尔类型（｀boolean`）。

通过定义和使用这些变量，我们能够存储和操作各种类型的数据。

｀｀｀javaint age ＝ 25;double salary ＝ 500050;char grade ＝＇A'；boolean isStudent ＝ true;｀｀｀2、控制结构包括条件语句（｀ifelse`、｀switch`）和循环语句（｀for`、｀while`、｀dowhile`）。

这些控制结构使我们能够根据不同的条件执行不同的代码块，或者重复执行一段代码。

｀｀｀javaint num ＝ 10;if （num ＞ 5) ｛Systemoutprintln(＂Number is greater than 5"）；｝ else ｛Systemoutprintln(＂Number is less than or equal to 5"）；｝switch （num) ｛Systemoutprintln(＂One"）；break;case 10:Systemoutprintln(＂Ten"）；break;default:Systemoutprintln(＂Unknown"）；｝for （int i ＝ 0; i ＜ 5; i+＋）｛Systemoutprintln(i)；｝int count ＝ 0;while （count ＜ 3) ｛Systemoutprintln(＂Count: ＂＋ count)；count+＋；｝count ＝ 0;Systemoutprintln(＂Count: ＂＋ count)；count+＋；｝ while （count ＜ 3)；｀｀｀（二）面向对象编程1、类与对象创建了自定义的类来表示现实世界中的实体。

数据结构java实验三

《数据结构（JA V A）》综合性、设计性实验成绩单开设时间：《数据结构（JA V A）》实验报告实验题目：栈和队列及递归算法指导教师：实验组长（姓名+学号）：组员（姓名+学号）：实验时间：组长签名：一、实验报告撰写提纲1、实验目的1．理解栈和队列抽象数据类型，掌握栈和队列的存储结构和操作实现，理解栈和队列在实际应用问题的作用。

2、实验内容（1）使用一个栈，将十进制转换成二进制。

（2）分别用循环单链表、循环双链表结构设计队列，并讨论他们之间的差别。

（3）使用3个队列分别保留手机最近10个“未接来电”、“已接来电”、“以拨电话”。

（4）走迷宫。

一个迷宫如图所示，他有一个入口和一个出口，其中白色单元表示通路，黑色单元表示不通路。

试寻找一条从入口到出口的路径，每一部只能从一个白色单元走到相（5骑士游历问题是指，在国际象棋的棋盘（8行*8列）上，一个马要遍历棋盘，即走到棋盘上的每一格，并且每隔只到达一次。

设码在棋盘的某一位置（x,y）上，按照“走马日”的规则，下一步有8个方向走，如图所示。

若给定起始位置（x0,y0）,使用站和队列探索出一条马遍历棋盘的路劲。

3(1)①审题：使用一个栈，将十进制转换成二进制。

②编程：本代码使用了一个顺序栈SeqStack，编写一个循环让十进制数除2的余数入站，然后让全部余数出栈，输出二进制数。

③验证结果：图 1（2）①审题：分别用循环单链表、循环双链表结构设计队列，并讨论他们之间的差别。

②编程：首先先编写一个队列抽象数据类型QQueue，然后编写循环单链表SlinkedQueue和双链表DlinkedQueue逐一实现Qqueue中的三个方法，即判断是否队列为空、入队和出队。

循环双链表所占的时间复杂度和空间复杂度比单链表多。

③验证结果：两个均可被调用。

（3）①审题：使用3个队列分别保留手机最近10个“未接来电”、“已接来电”、“以拨电话”。

②编程：1—10代表未接来电，11—20代表已接来电，21—30代表以拨电话，编写三个顺序栈stack1，stack2，stack3，运用条件语句存储10个号码，然后输出。

Java数据结构实验报告

Java数据结构实验报告《Java数据结构实验报告》摘要：本实验报告旨在介绍Java数据结构的相关知识，并通过实验验证其在实际应用中的效果。

通过对Java数据结构的学习和实验，我们可以更好地理解和掌握数据结构在软件开发中的重要性和应用方法。

1. 引言数据结构是计算机科学中的重要概念，它是指一组数据的组织方式和存储结构，是程序设计中最基本的概念之一。

Java作为一种广泛应用的编程语言，具有强大的数据结构支持，包括数组、链表、栈、队列、树等。

本实验报告将重点介绍Java数据结构的使用和实验结果。

2. 实验目的本实验旨在通过实际操作，掌握Java数据结构的基本概念、使用方法和实际应用。

具体包括以下几个方面：- 了解Java数据结构的基本概念和分类；- 掌握Java数据结构的常见操作和实现方法；- 通过实验验证Java数据结构在实际应用中的效果。

3. 实验内容本实验主要包括以下几个方面的内容：- 数组：学习数组的定义、初始化、访问和操作方法，并通过实验验证其效果；- 链表：学习链表的定义、插入、删除和遍历方法，并通过实验验证其效果；- 栈和队列：学习栈和队列的定义、操作方法，并通过实验验证其效果；- 树：学习树的定义、遍历和搜索方法，并通过实验验证其效果。

4. 实验结果通过实验，我们成功地掌握了Java数据结构的基本概念和操作方法，并验证了其在实际应用中的效果。

具体包括以下几个方面的结果：- 数组：我们成功地实现了数组的初始化、访问和操作，并验证了其在存储和检索数据方面的效果；- 链表：我们成功地实现了链表的插入、删除和遍历，并验证了其在数据组织和操作方面的效果；- 栈和队列：我们成功地实现了栈和队列的操作，并验证了其在数据存储和处理方面的效果；- 树：我们成功地实现了树的遍历和搜索，并验证了其在数据组织和检索方面的效果。

5. 结论通过本实验，我们对Java数据结构有了更深入的理解和掌握，了解了其在实际应用中的重要性和作用。

20140925 数据结构(JAVA版)实验报告

public Object delete(int i) throws Exception{ if(size == 0){ throw new Exception("链表已空无元素可删！"); } if(i < 0 || i > size - 1){ throw new Exception("参数错误！"); }
实验数据记录及分析（或程序及运行结果）
第 14 页共 18 页
实验报告
评语：
第 15 页共 18 页
实验报告
实验六：图
实验目的：
1. 掌握图的存储结构； 2. 掌握图的相关操作，从而解决实际问题。
实验内容
一、实验内容 1、构建一个 Java Application。 2、定义一个名为 Stu 包，在这个包中定义一个实现显示学生的学号、姓名、性别和班级的 Student 类；然后定义另一个引用 Stu 包的类，在这个类中用 Stu 包中的 Student 类生成一个对象。 3、定义接口，继承接口，实现接口的实验。二、实训步骤第一：新建一个名为 Exp1 的工程。第二：包的创建与使用。算法分析：先在两个 java 源文件中分别定义了两个包，并且在第 1 个包中定义了一个 MyClass1 类，在第 2 个包中定义了一个 MyClass2 类。在第三个 java 源文件的主类 TestPackage 中分别引用前面定义的两个包，并分别将 MyClass1 类和 MyClass2 类实例化。 1、在该工程中新建一个 java 源文件，并输入如下代码： package Mypackage; //定义包 Mypackage public class MyClass1 { //定义类 MyClass1 public void show() { System.out.println("这是类 MyClass1"); } } 2、在该工程中再新建一个 java 源文件，并输入如下代码： package Mypackage.Mypackage1; //定义包 Mypackage.Mypackage1 public class MyClass2 { //定义类 MyClass2 public void show(){ System.out.println("这是类 MyClass2"); } }

华南农业大学数据结构java版实验二

实验报告二线性表华南农业大学信息（软件）学院《数据结构（JA V A）》综合性、设计性实验成绩单开设时间：2017学年第二学期一，实验目的：（1）理解线性表的逻辑结构、两种存储结构和数据操作，熟练运用JAVA语言实现线性表的基本操作，分析各种操作算法特点和时间复杂度。

（2）掌握单链表的遍历、插入和删除等操作算法，实现多项式相加。

二，实验内容：1、设计一个有序顺序表（元素已排序，递增或递减），实现插入、删除等操作，元素插入位置由其值决定。

实现：（1）升序排序顺序表类名为：SortedSeqList，存成文件；（2）另外编写文件来演示调用排序顺序表public class SortedSeqList {private int MAX_SIZE = 10;private int[] ary = new int[MAX_SIZE];private int length = 0;public SortedSeqList(int[] array) {if (array == null || == 0) {= 0;} else {ary = array;length = ;}}public void clear() {length = 0;}public boolean isEmpty() {return length == 0;}public void delete(int index) throws Exception {if (length == 0) {throw new Exception("No elment to delete");}int newAry[] = new int[ - 1];for (int i = 0, j = 0; i < ; i++) {if (i == index) {continue;} else {newAry[j++] = ary[i];}}ary = newAry;length--;}public int insert(int value) throws Exception {if (length == MAX_SIZE) {throw new Exception("List is full, can't insert more");}int[] newAry = new int[length + 1];int i = 0, j = 0;for (; i < ; i++, j++) {if (ary[i] >= value) {newAry[j] = value;break;} else {newAry[j] = ary[i];}}while (i < {newAry[++j] = ary[i];i++;}ary = newAry;length++;return value;}public void display() {"\nList now is: ");for (int i = 0; i < ; i++) {+ "\t");}}}（2）文件来演示调用排序顺序表public class SortedSeqList_ex {public static void main(String[] args) throws Exception {int[] ary = {1, 2, 3, 5, 7};SortedSeqList list = new SortedSeqList(ary);();(4);();(2);();}}（3）实验结果2、在SinglyLinkedList类中增加下列成员方法。

基于java数据结构实验链表实验报告

实验报告PersonNode cur=head.next;while(cur!=null) {length++;cur=cur.next;}return length;}2 双向链表的实现3 public static void reverselist(PersonNode head) {if(head.next==null||head.next.next==null)//表为空或者只有一个节点return;PersonNode cur=head.next;PersonNode next=null;PersonNode reverseHead=new PersonNode(0, "");while(cur!=null) {next=cur.next;cur.next=reverseHead.next;reverseHead.next=cur;cur=next;}head.next=reverseHead.next;}4运行结果单链表的测试及结果：双链表的测试及结果：附：源程序：package linkedList;public class SingleLinkedListDemo {public static void main(String[] args) {PersonNode person1= new PersonNode(1, "lihua");PersonNode person2= new PersonNode(2, "wangfan");PersonNode person3= new PersonNode(3, "wangxi");PersonNode person4= new PersonNode(3, "xiaohu");SingleLinkedList singlelist = new SingleLinkedList();singlelist.add(person1);// singlelist.add(person2);singlelist.add(person3);// singlelist.add(person4);System.out.println("链表为：");singlelist.list();System.out.println("倒数第2个节点为：");singlelist.daoshu(singlelist.getHead(), 2);singlelist.addbyorder(person2);System.out.println("插入后：");singlelist.list();singlelist.update(person4);System.out.println("修改后：");singlelist.list();singlelist.del(2);System.out.println("删除后：");singlelist.list();System.out.println("单链表的长度为"+SingleLinkedList.getlength(singlelist.getHead()));singlelist.reverselist(singlelist.getHead());System.out.println("反转后：");singlelist.list();// TODO Auto-generated method stub}}class PersonNode{public int no;public String name;public PersonNode next;public PersonNode(int no, String name) {super();this.no = no; = name;}public String toString() {return"PersonNode [no="+no+",name="+name+"]";}}class SingleLinkedList{private PersonNode head = new PersonNode(0,"");public PersonNode getHead() {return head;}public void daoshu(PersonNode head,int k) { if(head.next==null)return;int size=getlength(head);PersonNode temp = head.next;int x=0;while(temp!=null) {x++;if(x==size-k+1) {System.out.println(temp);break;}temp=temp.next;}}public void reverselist(PersonNode head) {if(head.next==null||head.next.next==null)return;PersonNode reversehead = new PersonNode(0, "");PersonNode cur = head.next;PersonNode nextnode = null;while(cur!=null) {nextnode=cur.next;cur.next=reversehead.next;reversehead.next=cur;cur=nextnode;}head.next=reversehead.next;}//插入到队尾public void add(PersonNode personnode) {PersonNode temp = head;//找到队尾while(true) {if(temp.next==null)break;temp=temp.next;}temp.next=personnode;}public void list() {if(head.next==null) {System.out.println("链表为空");return;}PersonNode temp=head.next;while(true) {if(temp==null)break;System.out.println(temp);temp=temp.next;}}public void addbyorder(PersonNode newn) { if(head.next==null) {System.out.println("表为空");return;}PersonNode temp=head.next;boolean flag=false;while(true) {if(temp.next==null) {break;}if(temp.next.no==newn.no) {System.out.println("要插入的节点已存在");break;}if(temp.next.no>newn.no) {flag=true;break;}temp=temp.next;}if(flag) {newn.next=temp.next;temp.next=newn;}}public void update(PersonNode newn) {if(head.next==null) {System.out.println("表为空");return;}PersonNode temp = head.next;boolean flag=false;while(true) {if(temp==null)break;if(temp.no==newn.no) {flag=true;break;}temp=temp.next;}if(flag) {=;}else {System.out.printf("没有找到编号为%d的节点，不能修改"+newn.no);}}public void del(int no) {PersonNode temp = head;boolean flag=false;while(true) {if(temp.next==null)break;if(temp.next.no==no) {flag=true;break;}temp=temp.next;}if(flag) {temp.next=temp.next.next;}else {System.out.printf("要删除的节点%d不存在" +no);}}public static int getlength(PersonNode head) {if(head.next==null)return 0;PersonNode temp=head.next;int length=0;while(temp!=null) {length++;temp=temp.next;}return length;}}。

计算机java数据结构实践报告

计算机java数据结构实践报告下载提示：该文档是本店铺精心编制而成的，希望大家下载后，能够帮助大家解决实际问题。

文档下载后可定制修改，请根据实际需要进行调整和使用，谢谢！本店铺为大家提供各种类型的实用资料，如教育随笔、日记赏析、句子摘抄、古诗大全、经典美文、话题作文、工作总结、词语解析、文案摘录、其他资料等等，想了解不同资料格式和写法，敬请关注！Download tips: This document is carefully compiled by this editor. I hope that after you download it, it can help you solve practical problems. The document can be customized and modified after downloading, please adjust and use it according to actual needs, thank you! In addition, this shop provides you with various types of practical materials, such as educational essays, diary appreciation, sentence excerpts, ancient poems, classic articles, topic composition, work summary, word parsing, copy excerpts, other materials and so on, want to know different data formats and writing methods, please pay attention!计算机Java数据结构实践报告1. 引言在现代计算机科学领域，数据结构是构建程序和解决问题的基础。

基于java数据结构链表实验报告

实验报告PersonNode cur=head.next;PersonNode next=null;PersonNode reverseHead=new PersonNode(0, "");while(cur!=null) {next=cur.next;cur.next=reverseHead.next;reverseHead.next=cur;cur=next;}head.next=reverseHead.next;}4运行结果单链表的测试及结果：双链表的测试及结果：附：源程序：package linkedList;public class SingleLinkedListDemo {public static void main(String[] args) {PersonNode person1= new PersonNode(1, "lihua");PersonNode person2= new PersonNode(2, "wangfan");PersonNode person3= new PersonNode(3, "wangxi");PersonNode person4= new PersonNode(3, "xiaohu");SingleLinkedList singlelist = new SingleLinkedList();singlelist.add(person1);// singlelist.add(person2);singlelist.add(person3);// singlelist.add(person4);System.out.println("链表为：");singlelist.list();System.out.println("倒数第2个节点为：");singlelist.daoshu(singlelist.getHead(), 2);singlelist.addbyorder(person2);System.out.println("插入后：");singlelist.list();singlelist.update(person4);System.out.println("修改后：");singlelist.list();singlelist.del(2);System.out.println("删除后：");singlelist.list();System.out.println("单链表的长度为"+SingleLinkedList.getlength(singlelist.getHead()));singlelist.reverselist(singlelist.getHead());System.out.println("反转后：");singlelist.list();// TODO Auto-generated method stub}}class PersonNode{public int no;public String name;public PersonNode next;public PersonNode(int no, String name) {super();this.no = no; = name;public String toString() {return"PersonNode [no="+no+",name="+name+"]"; }}class SingleLinkedList{private PersonNode head = new PersonNode(0,"");public PersonNode getHead() {return head;}public void daoshu(PersonNode head,int k) { if(head.next==null)return;int size=getlength(head);PersonNode temp = head.next;int x=0;while(temp!=null) {x++;if(x==size-k+1) {System.out.println(temp);break;}temp=temp.next;}public void reverselist(PersonNode head) { if(head.next==null||head.next.next==null) return;PersonNode reversehead = new PersonNode(0, "");PersonNode cur = head.next;PersonNode nextnode = null;while(cur!=null) {nextnode=cur.next;cur.next=reversehead.next;reversehead.next=cur;cur=nextnode;}head.next=reversehead.next;}//插入到队尾public void add(PersonNode personnode) { PersonNode temp = head;//找到队尾while(true) {if(temp.next==null)break;temp=temp.next;}temp.next=personnode;}public void list() {if(head.next==null) {System.out.println("链表为空");return;}PersonNode temp=head.next;while(true) {if(temp==null)break;System.out.println(temp);temp=temp.next;}}public void addbyorder(PersonNode newn) { if(head.next==null) {System.out.println("表为空");return;}PersonNode temp=head.next;boolean flag=false;while(true) {if(temp.next==null) {break;}if(temp.next.no==newn.no) {System.out.println("要插入的节点已存在");break;}if(temp.next.no>newn.no) {flag=true;break;}temp=temp.next;}if(flag) {newn.next=temp.next;temp.next=newn;}}public void update(PersonNode newn) {if(head.next==null) {System.out.println("表为空");return;}PersonNode temp = head.next;boolean flag=false;while(true) {if(temp==null)break;if(temp.no==newn.no) {flag=true;break;}temp=temp.next;}if(flag) {=;}else {System.out.printf("没有找到编号为%d的节点，不能修改"+newn.no);}}public void del(int no) {PersonNode temp = head;boolean flag=false;while(true) {if(temp.next==null)break;if(temp.next.no==no) {flag=true;break;}temp=temp.next;}if(flag) {temp.next=temp.next.next;}else {System.out.printf("要删除的节点%d不存在" +no);}}public static int getlength(PersonNode head) { if(head.next==null)return 0;PersonNode temp=head.next;int length=0;while(temp!=null) {length++;temp=temp.next;}return length;}}。

基于java数据结构实验队列实验报告

实验报告// TODO: handle exceptionSystem.out.println(e.getMessage());}();System.out.println("队头数据为："+res);} catch (Exception e) {// TODO: handle exceptionbreak;case 'h':try {int res=myQueue.peekqueueSystem.out.println(e.getMessage());}case 'e':scanner.close();loop=false;break;default:break;}}System.out.println("exit");}运行结果：顺序队列运行测试及结果：顺序循环队列运行测试及结果：实验总结：通过这一次的实验，我不仅实现了队列的算法，还解决了上次作业遗留下来的问题。

队列是只允许在一端进行插入操作，在另一端进行删除操作的线性表。

允许插入的一端为队尾，允许删除的一端为队头，先进先出，相邻元素具有前驱与后继关系。

附：源程序：顺序队列：package main;public class Sequeue<T> {private int Maxsize=20;private int front,rear;private T[] arr;public Sequeue(){front=rear=-1;arr=(T[])new Object[Maxsize];}public Sequeue(int n){front=rear=-1;arr=(T[])new Object[n];}public boolean isEmpty(){return rear==front;}public boolean isFull(){return rear==Maxsize-1;}public void add(T obj){if(isFull()){System.out.println("duilieyiman");return;}rear++;arr[rear]=obj;}public T getQueue(){if(isEmpty()){throw new RuntimeException("null");}front++;return arr[front];}public void show(){if(isEmpty()){System.out.println("null");}for(int i=front+1;i<=rear;i++){System.out.print("arr["+i+"]="+arr[i]+" ");}}public T peekQueue(){if (isEmpty()) {throw new RuntimeException("队空，不能取数据");}return arr[front+1];}public static void main(String[] args) {Sequeue<String> queue1 = new Sequeue<String>(5);queue1.add("li");queue1.add("ke");queue1.add("wu");queue1.add("fa");queue1.add("xi");queue1.show();System.out.println();System.out.println("出队的是："+queue1.getQueue()); System.out.println("出队后：");queue1.show();// TODO Auto-generated method stub}}循环顺序队列package main;public class CircleQueue<T> {private int Maxsize=20;private int front,rear;private T[] arr;public CircleQueue(){front=rear=0;arr}public CircleQueue(int n){front=rear=0;arr=(T[])new Object[n];}public boolean isEmpty(){return rear==front;}public boolean isFull(){return front==(rear+1)%Maxsize;}public void add(T obj){if(isFull()){System.out.println("duilieyiman");return;}rear=(rear+1)%Maxsize;arr[rear]=obj;}public T getQueue(){if(isEmpty()){throw new RuntimeException("null");}front=(front+1)%Maxsize;return arr[front];}public void show(){if(isEmpty()){System.out.println("null");}for(int i=front+1;i<=front+count();i++){System.out.print("arr["+i+"]="+arr[i]+" ");}System.out.println();}public int count(){return (rear+Maxsize-front)%Maxsize;}public T peekQueue(){if (isEmpty()) {throw new RuntimeException("队空，不能取数据");}return arr[(front+1)%Maxsize];}public static void main(String[] args) {CircleQueue<String> queue2 = new CircleQueue<String>(6);queue2.add("li");queue2.add("ke");queue2.add("wu");queue2.add("fa");queue2.add("xi");queue2.show();System.out.println();System.out.println("出队的是："+queue2.getQueue());System.out.println("出队后：");queue2.show();System.out.println("此时对头为："+queue2.peekQueue());// TODO Auto-generated method stub}}。

数据结构实验报告模板

数据结构实验报告模板选课时间段：选课号：杭州电子科技大学管理学院实验报告课程名称：数据结构（java版）实验名称：栈和队列的基本操作指导教师：金鹏学生姓名：崔海雨学生学号：09032323实验日期：一、实验目的：1、掌握栈的顺序存储结构。

2、掌握栈特点，即先进后出原则。

3、掌握栈基本操作实现方法。

4、熟练掌握顺序队、链队的存储原理；5、熟练掌握顺序队、链队的Java语言实现方法；6、掌握队列空、队满的判断条件；7、了解循环队列与普通队列实现上的不同及其解决方二、实验内容：1、栈首先创建栈，并置top指针为-1，栈处于空的状态。

第二入栈，先判断栈是否是满栈。

满栈的话，不做入栈操作，未满的话，做入栈操作。

第三出栈，先判断栈是否为空，如果是空栈的话，不能做出栈操作，非空的话做出栈操作。

2、队列首先创建空队，置队首指针，队尾指针为-1第二入队操作，判断队列是否已满，队满的话，不能入队，未满的话，做入队操作。

第三出队操作，判断队是否为空，如果空队的话，不能出队，未空的话，做处队操作。

三、实验步骤1．需求分析：描述栈抽象数据类型的SStack接口的声明package dataStructure.linearList;public interface SStack //栈接口{boolean isEmpty(); //判断是否空栈，若空栈返回trueboolean push(E element); //元素element入栈，若操作成功返回trueE pop(); //出栈，返回当前栈顶元素，若栈空返回nullE get(); //取栈顶元素值，未出栈，若栈空返回null}顺序栈类具体操作方法的声明：package dataStructure.linearList;import dataStructure.linearList.SStack;public class SeqStack implements SStack //顺序栈类{private Object value[]; //存储栈的数据元素private int top; //top为栈顶元素下标public SeqStack(int capacity) //构造指定容量的空栈{this.value = new Object[Math.abs(capacity)];this.top=-1;}public SeqStack() //构造默认容量的空栈{this(10);}public boolean isEmpty() //判断是否空栈，若空栈返回true{return this.top==-1;}public boolean push(E element) //元素element入栈，若操作成功返回true{if (element==null)return false; //空对象（null）不能入栈if (this.top==value.length-1) //若栈满，则扩充容量{Object[] temp = this.value;this.value = new Object[temp.length*2];for (int i=0; i<="" p="">this.value[i] = temp[i];}this.top++;this.value[this.top] = element;return true;}public E pop() //出栈，返回当前栈顶元素，若栈空返回null{if (!isEmpty())return (E)this.value[this.top--];elsereturn null;}public E get() //取栈顶元素值，未出栈，栈顶元素未改变{if (!isEmpty())return (E)this.value[this.top];elsereturn null;}public String toString() //返回栈中各元素的字符串描述{String str="{";if (this.top!=-1)str += this.value[this.top].toString();for (int i=this.top-1; i>=0; i--)str += ", "+this.value[i].toString();return str+"} ";}实例引用public static void main(String args[]){SeqStack stack = new SeqStack(20);System.out.print("Push: ");char ch='a';for(int i=0;i<5;i++){String str = (char)(ch+i)+"";stack.push(str);System.out.print(str+" ");}System.out.println("\n"+stack.toString());System.out.print("Pop : ");while(!stack.isEmpty()) //全部出栈System.out.print(stack.pop().toString()+" ");System.out.println();}四、实验总结（结果分析和体会）栈及列的声明模块在课本有具体的内容可供参考，所以较为容易。

基于java数据结构链表实验报告

实验报告PersonNode cur=head.next;PersonNode next=null;PersonNode reverseHead=new PersonNode(0, "");while(cur!=null) {next=cur.next;cur.next=reverseHead.next;reverseHead.next=cur;cur=next;}head.next=reverseHead.next;}4运行结果单链表的测试及结果：双链表的测试及结果：附：源程序：package linkedList;public class SingleLinkedListDemo {public static void main(String[] args) {PersonNode person1= new PersonNode(1, "lihua");PersonNode person2= new PersonNode(2, "wangfan");PersonNode person3= new PersonNode(3, "wangxi");PersonNode person4= new PersonNode(3, "xiaohu");SingleLinkedList singlelist = new SingleLinkedList();singlelist.add(person1);// singlelist.add(person2);singlelist.add(person3);// singlelist.add(person4);System.out.println("链表为：");singlelist.list();System.out.println("倒数第2个节点为：");singlelist.daoshu(singlelist.getHead(), 2);singlelist.addbyorder(person2);System.out.println("插入后：");singlelist.list();singlelist.update(person4);System.out.println("修改后：");singlelist.list();singlelist.del(2);System.out.println("删除后：");singlelist.list();System.out.println("单链表的长度为"+SingleLinkedList.getlength(singlelist.getHead()));singlelist.reverselist(singlelist.getHead());System.out.println("反转后：");singlelist.list();// TODO Auto-generated method stub}}class PersonNode{public int no;public String name;public PersonNode next;public PersonNode(int no, String name) {super();this.no = no; = name;public String toString() {return"PersonNode [no="+no+",name="+name+"]"; }}class SingleLinkedList{private PersonNode head = new PersonNode(0,"");public PersonNode getHead() {return head;}public void daoshu(PersonNode head,int k) { if(head.next==null)return;int size=getlength(head);PersonNode temp = head.next;int x=0;while(temp!=null) {x++;if(x==size-k+1) {System.out.println(temp);break;}temp=temp.next;}public void reverselist(PersonNode head) { if(head.next==null||head.next.next==null) return;PersonNode reversehead = new PersonNode(0, "");PersonNode cur = head.next;PersonNode nextnode = null;while(cur!=null) {nextnode=cur.next;cur.next=reversehead.next;reversehead.next=cur;cur=nextnode;}head.next=reversehead.next;}//插入到队尾public void add(PersonNode personnode) { PersonNode temp = head;//找到队尾while(true) {if(temp.next==null)break;temp=temp.next;}temp.next=personnode;}public void list() {if(head.next==null) {System.out.println("链表为空");return;}PersonNode temp=head.next;while(true) {if(temp==null)break;System.out.println(temp);temp=temp.next;}}public void addbyorder(PersonNode newn) { if(head.next==null) {System.out.println("表为空");return;}PersonNode temp=head.next;boolean flag=false;while(true) {if(temp.next==null) {break;}if(temp.next.no==newn.no) {System.out.println("要插入的节点已存在");break;}if(temp.next.no>newn.no) {flag=true;break;}temp=temp.next;}if(flag) {newn.next=temp.next;temp.next=newn;}}public void update(PersonNode newn) {if(head.next==null) {System.out.println("表为空");return;}PersonNode temp = head.next;boolean flag=false;while(true) {if(temp==null)break;if(temp.no==newn.no) {flag=true;break;}temp=temp.next;}if(flag) {=;}else {System.out.printf("没有找到编号为%d的节点，不能修改"+newn.no);}}public void del(int no) {PersonNode temp = head;boolean flag=false;while(true) {if(temp.next==null)break;if(temp.next.no==no) {flag=true;break;}temp=temp.next;}if(flag) {temp.next=temp.next.next;}else {System.out.printf("要删除的节点%d不存在" +no);}}public static int getlength(PersonNode head) { if(head.next==null)return 0;PersonNode temp=head.next;int length=0;while(temp!=null) {length++;temp=temp.next;}return length;}}。

数据结构java实验一

《数据结构（JA V A）》综合性、设计性实验成绩单开设时间：《数据结构（JA V A）》实验报告实验题目：算法设计与分析指导教师：实验组长（姓名+学号）：组员（姓名+学号）：实验时间：年月日组长签名：年月日一、实验报告撰写提纲1、实验目的（1分）了解数据结构课程的目的，性质和主要内容，理解数据结构和算法的基本概念，熟悉算法的描述方法，算法时间复杂度和空间复杂度的分析和计算方法。

2、实验内容（2分）（1）判断已按升序排序。

实现isSorted()方法判断整数（对象）数组元素是否已按升序排序，生命如下：Public static boolean isSorted(int[] table) //判断整数数组是否已按升序排序Public static boolean isSorted(Comparable[] table)// 判断对象数组是否已按升序排序（2）数组逆置。

将一个已知数组中所有元素的次序颠倒为相反次序，求算法的时间复杂度和空间复杂度。

（3）用递归算法求两个整数的最大公因数。

设有不全为0的两个整数a和b,记gcd(a,b)为他们的最大公因数，即同时能整除a和b的公因数中的最大者。

按照欧几里德（Euclid）的辗转相除法。

gcd(a,b)具有如下性质：用递归算法实现gcd(a,b),并给下列调用：①求两个整数a，b的最小公倍数；②求三个数a,b,c的最大公约数3、实验步骤与结果（3分）(1)○1审题。

确定题目所要求的方法是实现判断整数数组(对象数组)是否已按升序排序的功能。

○2编程。

创建一个主类，定义一个整数数组(对象数组)，利用输出语句输出实现该方法得到的结果。

定义isSorted()方法，先判断输入数组是否为空，若为空，则返回flase；然后利用一个循环语句，逐个判断第i个元素是否比第i+1个元素大，若发现这种情况，则返回false，否则为true。

验证结果。

输入一系列数据，验证结果是否符合程序要求。

基于java数据结构实验二叉树实验报告

实验报告p=p.getLeft();}}}运行结果：二叉搜索树：实验总结：通过这次实验，我掌握了二叉树的结构原理以及它的先序，中序，后序遍历，运用递归的方法实现和不用递归的方法实现。

二叉搜索树的原理和算法实现，根据二叉搜索树的特点，运用二分法进行二叉搜索树的一系列操作。

附：源程序：二叉树：package tree;import java.util.Deque;import java.util.LinkedList;public class BinaryTree<T>{private BinaryTreeNode root;public BinaryTree(BinaryTreeNode root) { super();this.root = root;}public BinaryTree() {this.root=null;}public BinaryTreeNode getRoot() {return root;}public void setRoot(BinaryTreeNode root) { this.root = root;}@Overridepublic String toString() {return "BinaryTree [root=" + root + "]";}private void preorder(BinaryTreeNode p) { if(p!=null) {System.out.print(p.getData()+"\t");preorder(p.getLchild());preorder(p.getRchild());}}public void preorder() {System.out.println("先序遍历：");preorder(root);}private void inorder(BinaryTreeNode p) { if(p!=null) {inorder(p.getLchild());System.out.print(p.getData()+"\t");inorder(p.getRchild());}}public void inorder() {System.out.println("中序遍历：");inorder(root);}private void postorder(BinaryTreeNode p) { if(p!=null) {postorder(p.getLchild());postorder(p.getRchild());System.out.print(p.getData()+"\t");}}public void postorder() {System.out.println("后序遍历：");postorder(root);}private int size(BinaryTreeNode p) {if(p==null) {return 0;}int lchildsize=size(p.getLchild());int rchildsize=size(p.getRchild());return lchildsize+rchildsize+1;}public int size() {System.out.println("节点数为：");return size(root);}private int height(BinaryTreeNode p) {if (p==null) {return 0；}int hl=height(p.getLchild());int hr=height(p.getRchild());return (hl>hr)?hl+1:hr+1;}public int height() {System.out.println("高度为：");return height(root);}public void showleaves(BinaryTreeNode p) {if (p!=null) {if (p.getLchild()==null&&p.getRchild()==null) {System.out.print(p.getData()+"\t");}showleaves(p.getLchild());showleaves(p.getRchild());}}public void pretravel() {BinaryTreeNode p=root;Deque<BinaryTreeNode> mystack=new LinkedList<BinaryTreeNode>();if(p!=null) {mystack.push(p);while(!mystack.isEmpty()) {p=mystack.pop();System.out.print(p.getData()+" ");if(p.getRchild()!=null) {mystack.push(p.getRchild());}if (p.getLchild()!=null) {mystack.push(p.getLchild());}}}}}二叉搜索树package tree;public class BinartSearchtree {private Node root;public BinartSearchtree(Node root) { super();this.root = root;}public BinartSearchtree() {root=null;}public void insearch(int x) {if(root==null) {root=new Node(x);return;}Node p=root;while (p!=null) {if(x>p.getData()) {if(p.getRight()==null) {p.setRight(new Node(x));return;}p=p.getRight();}else {if (p.getLeft()==null) {p.setLeft (new Node(x));return;}p=p.getLeft();}}}public Node find(int x) {Node p=root;while(p!=null) {if(x>p.getData()) {p=p.getRight();}else if(x<p.getData()) {p=p.getLeft();}else {return p;}}return null;}public void preorder() {System.out.println("先序遍历：");preorder(root);}private void preorder(Node p) {if(p!=null) {System.out.print(p.getData()+" ");preorder(p.getLeft());preorder(p.getRight());}}public Node minNode(Node p) {// Node p=root;while(p.getLeft()!=null) {p=p.getLeft();}return p;}public Node maxNode(Node p) {// Node p=root;while(p.getRight()!=null) {p=p.getRight();}return p;}public Node delete(int x, Node p) {Node temp;if(p==null) {System.out.println("error");return null;}else if (x<p.getData()) {p.setLeft(delete(x, p.getLeft()));}else if (x>p.getData()) {p.setRight(delete(x, p.getRight()));}else {if (p.getLeft()!=null&&p.getRight()!=null) { temp=maxNode(p.getLeft());p.setData(temp.getData());p.setLeft(delete(p.getData(), p.getLeft()));}else {if (p.getLeft()==null) {p=p.getRight();}else if (p.getRight()==null) {p=p.getRight();}}}return p;}。

数据结构(Java版)线性表的实现和应用[完整版]

实验报告
课程名称数据结构
实验项目线性表的实现及应用
实验仪器PC机一台
学院_____ 专业
班级/学号
姓名
实验日期
成绩
指导教师
北京信息科技大学
信息管理学院
（数据结构课程上机）实验报告
3.
1.实验名称、实验目的、实验内容、实验要求由教师确定，实验前由教师事先填好，然后作为实验报告模
版供学生使用；
2.实验准备由学生在实验或上机之前填写，教师应该在实验前检查；
3.实验过程由学生记录实验的过程，包括操作过程、遇到哪些问题以及如何解决等；
4.实验总结由学生在实验后填写，总结本次实验的收获、未解决的问题以及体会和建议等；
5.源程序、代码、具体语句等，若表格空间不足时可作为附录另外附页。

数据结构Java版实验报告

基于java数据结构实验报告+-+栈

数据结构Java版实验报告

6数据结构实验报告JAVA-链表

Java数据结构实验报告

java实验实验报告

数据结构java实验三

Java数据结构实验报告

20140925 数据结构(JAVA版)实验报告

华南农业大学数据结构java版实验二

基于java数据结构实验 链表实验报告

计算机java数据结构实践报告

基于java数据结构链表实验报告

基于java数据结构实验 队列实验报告

数据结构实验报告模板

基于java数据结构链表实验报告

数据结构java实验一

基于java数据结构实验 二叉树实验报告

数据结构(Java版)线性表的实现和应用[完整版]

基于java数据结构实验链表实验报告

基于java数据结构实验队列实验报告

基于java数据结构实验二叉树实验报告