基于java数据结构实验 链表实验报告
链表的实验报告
front->next=alist.front->next;
cout<<"复制构造函数"<<endl;
}
//touchafa
template<class T>
linklist<T>::linklist(T a[],int n)
{
front=new Node<T>;
front->next=NULL;
找到要插入的结点的前一个结点新结点的指针域指向p然后p前面的结点指向这个新的结点这样这个新的结点就插入到了链表里面3代码的时间复杂度
数据结构实验报告
1.
2.
2.1
2.2
2.3
算法一:
template<class T>
linklist<T>::linklist(T a[],int n)
{
front=new Node<T>;
T x=q->data;
delete q;
return x;
}
[1]算法功能:删除链表中的某个元素
[2]思想:删除就是先找到要删除的元素的前面的元素,然后前面的这个结点直接指向这个结点的下一个结点,然后再把这个指针删除。
[3]时间复杂度:O(n)
[4]代码逻辑:
1.从第一个结点开始,查找第i-1个元素,设为P指向该结点,如果查找失败则抛出异常
front->next=NULL;
for(int i=n-1;i>=0;i--)
{
Node<T>*s=new Node<T>;
s->data=a[i];
数据结构实验报告
数据结构实验报告
本次数据结构实验的任务主要包括两部分,分别是学习使用链表数据结构和掌握链表排序算法。
在此基础上,我们完成了一组关于链表基本操作和排序算法的实验。
实验一:链表基本操作
在这个实验中,我们学习了链表的插入、删除、查找等基本操作。
链表的插入和删除操作是通过一个链表节点来实现的。
链表节点包括一个数据域和一个指向下一个节点的指针域。
通过修改指针域,我们就可以实现节点的插入和删除操作。
具体来说,我们编写了一个基本的链表程序,其中包括链表头指针初始化、链表节点插入、链表节点删除、查找指定节点等操作。
通过对程序的调试和功能测试,我们验证了链表操作的正确性。
实验二:链表排序算法
在这个实验中,我们学习了链表排序算法,并编写了链表的快速排序和归并排序两种算法。
快速排序是一种分治思想的排序算法,通过选择一个基准元素,分别将小于和大于基准元素的元素分别放在它的左右两边,再递归地对左右两个子序列进行排序,最终得到有序序列。
归并排序是另一种经典的排序算法,它利用归并思想,将两个有序序列合并成一个更大的有序序列,这个过程不断重复,最终得到完整的有序序列。
通过实现这两种排序算法,并在大样本数据下进行测试,我们验证了算法的正确性和效率。
实验总结:
通过本次实验,我们深入学习了链表数据结构的相关基本操作和排序算法的实现原理。
同时,在实际编程实践中,我们也掌握了链表程序的调试、测试和优化技术。
这些都是我们今后从事软件开发工作需要掌握的重要技能,在这个方面的积累将会对我们有很大帮助。
6数据结构实验报告JAVA-链表
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单链表实验
实验一单链表实验
一、实验目的
1、熟悉JDK开发环境。
2、熟悉JCreator编辑器的使用。
3、掌握用上机调试单链表的基本方法。
2、掌握单链表的插入、删除、修改等算法的实现。
二、实现内容
1、单链表基本操作的实现
[问题描述]
首先创建单链表,申请一个结点空间,并置x为其数据域值,最后修改前一个结点的指针指向新插入结点。
第二,对单链表中的符合要求的数据删除。
并要在带头结点的单链表h中进行寻找给定键值的数据。
然后再删除相关节点,释放空间。
第三,对符合要求的数据进行修改,在带头结点的单链表h中进行寻找给定键值的数据。
然后对该数据进行修改。
[基本要求]用链式存储结构实现存储
[实现提示]链式存储结构不是随机存储结构,即不能直接取到单链表中某个结点,而要从单链表的头结点开始一个一个地计数寻找,比较给定键值,确定查找位置,在作相关操作。
[程序实现]
三、思考题
1.输入10组数据测试,分别完成,插入、删除、修改等操作。
2.修改所给代码,用单链表的方式实现通讯录,可以对通讯录作插入、删除、显示、
修改等操作。
3.如果要删除第i个数据元素,应该如何修改前述算法?
4.分析实例程序的各个模块功能,分别写出实例程序的插入、删除、修改等算法的
实现过程。
5.分析比较循环单链表的插入、删除、修改算法和本算法的不同点。
1。
Java数据结构实验报告
Java数据结构实验报告《Java数据结构实验报告》摘要:本实验报告旨在介绍Java数据结构的相关知识,并通过实验验证其在实际应用中的效果。
通过对Java数据结构的学习和实验,我们可以更好地理解和掌握数据结构在软件开发中的重要性和应用方法。
1. 引言数据结构是计算机科学中的重要概念,它是指一组数据的组织方式和存储结构,是程序设计中最基本的概念之一。
Java作为一种广泛应用的编程语言,具有强大的数据结构支持,包括数组、链表、栈、队列、树等。
本实验报告将重点介绍Java数据结构的使用和实验结果。
2. 实验目的本实验旨在通过实际操作,掌握Java数据结构的基本概念、使用方法和实际应用。
具体包括以下几个方面:- 了解Java数据结构的基本概念和分类;- 掌握Java数据结构的常见操作和实现方法;- 通过实验验证Java数据结构在实际应用中的效果。
3. 实验内容本实验主要包括以下几个方面的内容:- 数组:学习数组的定义、初始化、访问和操作方法,并通过实验验证其效果;- 链表:学习链表的定义、插入、删除和遍历方法,并通过实验验证其效果;- 栈和队列:学习栈和队列的定义、操作方法,并通过实验验证其效果;- 树:学习树的定义、遍历和搜索方法,并通过实验验证其效果。
4. 实验结果通过实验,我们成功地掌握了Java数据结构的基本概念和操作方法,并验证了其在实际应用中的效果。
具体包括以下几个方面的结果:- 数组:我们成功地实现了数组的初始化、访问和操作,并验证了其在存储和检索数据方面的效果;- 链表:我们成功地实现了链表的插入、删除和遍历,并验证了其在数据组织和操作方面的效果;- 栈和队列:我们成功地实现了栈和队列的操作,并验证了其在数据存储和处理方面的效果;- 树:我们成功地实现了树的遍历和搜索,并验证了其在数据组织和检索方面的效果。
5. 结论通过本实验,我们对Java数据结构有了更深入的理解和掌握,了解了其在实际应用中的重要性和作用。
数据结构链表实验报告
实验报告填写说明(实验项目名称、实验项目类型必须与实验教学大纲保持一致)1.实验环境:实验用的软、硬件环境。
2.实验目的:根据实验教学大纲,写出实验的要求和目的。
3.实验原理:简要说明本实验项目所涉及的理论知识。
4.实验方案:这是实验报告极其重要的容。
对于验证性验,要写清楚操作方法,需要经过哪几个步骤来实现其操作。
对于设计性和综合性实验,还应写出设计思路和设计方法。
对于创新性实验,还应注明其创新点。
5.实验过程:写明执行实验方案的实验过程。
6.实验结论:根据实验过程中得到的结果,做出结论。
7.实验小结:本次实验的体会和建议。
8.指导教师评语及成绩:指导教师依据学生的实际报告内容,给出本次实验报告的评价和成绩。
1 实验环境:VC++6.02 实验目的 :掌握单链表的基本操作在链式存储结构上的实现。
3实验原理:(1)#define MAXSIZE 5 //链表的最大长度typedef struct{ElemType data;int cur;}component,SLinkList[MAXSIZE];(2)动态分配的物理结构,每个结点值域指向其直接后继结点,指针为数据元素之间逻辑关系的映象。
4实验方案:根据链表的结构编写主函数,调用链表的构造空表算法,查找算法,插入算法以及删除算法,验证算法的正确性。
5实验过程:(1).编写算法以及主函数(2).编译运行出错,查找错误(3).改正错误,重新编译运行,没有错误(4).输入测试数据,验证结果,得出结论(5).保存结果,写入实验报告中6实验结论附录1:源程序。
数据结构顺序表链表试验报告
数据结构顺序表链表试验报告数据结构试验报告一、引言数据结构是计算机科学中非常重要的一个概念,它用于组织和存储数据,以便能够高效地进行检索和操作。
顺序表和链表是两种常见的数据结构,它们在实际应用中都有各自的优势和局限性。
本报告将对顺序表和链表进行试验比较,以评估它们在不同场景下的性能和适合性。
二、实验目的本次试验的目的是比较顺序表和链表在插入、删除和查找操作上的性能差异,并分析其时间复杂度和空间复杂度。
通过实验结果,可以对不同场景下选择合适的数据结构提供参考。
三、实验内容1. 顺序表实验a. 创建一个包含100个元素的顺序表;b. 在表尾插入一个元素;c. 在表头插入一个元素;d. 在表的中间位置插入一个元素;e. 删除表尾的一个元素;f. 删除表头的一个元素;g. 删除表的中间位置的一个元素;h. 查找一个元素;i. 遍历整个顺序表。
2. 链表实验a. 创建一个包含100个节点的链表;b. 在链表尾部插入一个节点;c. 在链表头部插入一个节点;d. 在链表的中间位置插入一个节点;e. 删除链表尾部的一个节点;f. 删除链表头部的一个节点;g. 删除链表的中间位置的一个节点;h. 查找一个节点;i. 遍历整个链表。
四、实验结果与分析1. 顺序表实验结果a. 在表尾插入一个元素的平均时间为0.1ms;b. 在表头插入一个元素的平均时间为0.2ms;c. 在表的中间位置插入一个元素的平均时间为0.5ms;d. 删除表尾的一个元素的平均时间为0.1ms;e. 删除表头的一个元素的平均时间为0.2ms;f. 删除表的中间位置的一个元素的平均时间为0.5ms;g. 查找一个元素的平均时间为1ms;h. 遍历整个顺序表的平均时间为10ms。
2. 链表实验结果a. 在链表尾部插入一个节点的平均时间为0.2ms;b. 在链表头部插入一个节点的平均时间为0.1ms;c. 在链表的中间位置插入一个节点的平均时间为0.5ms;d. 删除链表尾部的一个节点的平均时间为0.2ms;e. 删除链表头部的一个节点的平均时间为0.1ms;f. 删除链表的中间位置的一个节点的平均时间为0.5ms;g. 查找一个节点的平均时间为2ms;h. 遍历整个链表的平均时间为5ms。
链表实验报告
链表实验报告一、实验目的链表是一种常见的数据结构,本次实验的主要目的是深入理解链表的概念、原理和操作,通过实际编程实现链表的创建、插入、删除、遍历等基本操作,掌握链表在数据存储和处理中的应用,提高对数据结构的理解和编程能力。
二、实验环境本次实验使用的编程语言为 C 语言,开发工具为 Visual Studio Code。
三、实验原理链表是一种动态的数据结构,它由一系列节点组成,每个节点包含数据和指向下一个节点的指针。
链表的优点是可以灵活地进行插入和删除操作,不需要像数组那样移动大量的数据。
链表分为单向链表、双向链表和循环链表等。
单向链表只有一个指向下一个节点的指针,双向链表有指向前一个节点和后一个节点的指针,循环链表的尾节点指向头节点,形成一个环形结构。
四、实验步骤1、单向链表的创建定义链表节点结构体,包含数据域和指针域。
编写创建链表的函数,通过动态分配内存创建链表节点,并将节点连接起来。
2、单向链表的插入操作实现头部插入、尾部插入和中间插入的函数。
在插入时,需要处理指针的更新,确保链表的连接正确。
3、单向链表的删除操作编写删除指定节点的函数。
删除节点时,要释放被删除节点的内存,并更新相邻节点的指针。
4、单向链表的遍历实现遍历链表并打印节点数据的函数。
5、双向链表的创建与操作类似于单向链表,定义双向链表节点结构体,并实现创建、插入、删除和遍历的函数。
注意双向链表中指针的更新方式与单向链表的不同。
6、循环链表的创建与操作定义循环链表节点结构体,创建循环链表。
实现循环链表的插入、删除和遍历操作,处理好尾节点与头节点的连接。
五、实验结果与分析1、单向链表成功创建了单向链表,并能够正确进行头部、尾部和中间的插入操作。
删除操作也能准确删除指定节点,并释放内存。
遍历输出的结果与预期相符。
2、双向链表双向链表的创建和各种操作都能正常执行,指针的更新没有出现错误。
在双向链表中,插入和删除操作的效率相对单向链表有所提高,因为可以直接通过前向指针进行操作。
计算机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;}}。
实验链表实验报告
实验链表实验报告一、实验目的本次实验的主要目的是深入理解链表这种数据结构的概念、特点和操作方法,并通过实际编程实现来提高对链表的应用能力。
二、实验环境本次实验使用的编程语言为C++,开发工具为Visual Studio 2019。
三、实验原理链表是一种常见的数据结构,它由一系列节点组成,每个节点包含数据和指向下一个节点的指针。
与数组不同,链表的内存分配是动态的,并且可以方便地进行插入和删除操作,而不需要移动大量的元素。
链表分为单向链表、双向链表和循环链表等多种类型。
在本次实验中,我们主要实现单向链表。
单向链表的节点结构通常包含数据域和指针域。
数据域用于存储节点的数据,指针域用于指向下一个节点。
通过遍历链表的指针,可以访问链表中的每个节点。
四、实验内容1、链表节点的定义```cppstruct ListNode {int data;ListNode next;ListNode(int x) : data(x), next(NULL) {}};```2、链表的创建```cppListNode createList(){ListNode head = NULL;ListNode tail = NULL;int num;cout <<"请输入链表中的数字(输入-1 结束):";cin >> num;while (num!=-1) {ListNode newNode = new ListNode(num);if (head == NULL) {head = newNode;tail = newNode;} else {tail>next = newNode;tail = newNode;}cin >> num;}return head;}```3、链表的遍历```cppvoid traverseList(ListNode head) {ListNode curr = head;while (curr!= NULL) {cout << curr>data <<"";curr = curr>next;}cout << endl;}```4、链表的插入```cppvoid insertNode(ListNode& head, int position, int value) {ListNode newNode = new ListNode(value);if (position == 0) {newNode>next = head;head = newNode;return;}ListNode curr = head;int count = 0;while (curr!= NULL && count < position 1) {curr = curr>next;count++;}if (curr == NULL) {cout <<"插入位置超出链表长度" << endl; return;}newNode>next = curr>next;curr>next = newNode;}```5、链表的删除```cppvoid deleteNode(ListNode& head, int position) {if (head == NULL) {cout <<"链表为空,无法删除" << endl; return;}if (position == 0) {ListNode temp = head;head = head>next;delete temp;return;}ListNode curr = head;ListNode prev = NULL;int count = 0;while (curr!= NULL && count < position) {prev = curr;curr = curr>next;count++;}if (curr == NULL) {cout <<"删除位置超出链表长度" << endl; return;}prev>next = curr>next;delete curr;}```五、实验结果通过对上述链表操作函数的调用,我们成功地创建、遍历、插入和删除了链表中的节点。
基于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数据结构链表实验报告
实验报告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;}}。
数据结构链表的插入和删除实验报告范文
数据结构链表的插入和删除实验报告范文实验报告及详细设计第三次实验报告——单链表的建链表,插入结点,删除结点运算一需求分析1、在演示程序中,浮现的元素以数字浮现2、演示程序在计算机终端上,用户在键盘上输入演示程序中规定的运算命令,相应的输入数据和运算结果显示在终端上3、程序执行的命令包括如下:(1)定义结构体(2)链表的初始化及创建(3)元素的插入(4)元素的删除(5)链表的打印结果4、测试数据二概要设计1、可能需要用到有序表的抽象数据类型定义:ADTLit{数据对象:D={ai|ai∈ElemL,i=1,2,...,n,n≥0}数据关系:R1={<ai-1,ai>|ai-1,ai∈D,i=2,...,n}基本操作:CreateLit_L(&L,n)操作结果:逆序位输入 n 个元素的值,建立带头结点的单链线性表 L LitInert(L,i,e)初始条件:线性表 L 存在操作结果:在 L 中第 i 个位置之前插入新的数据元素 eLitDelete (&L,i)初始条件:线性表 L 存在且非空实验报告及详细设计操作结果:删除 L 的第 i 个元素,并用 e 返回其值, L 的长度减 1 }ADTLit;2、程序包含的主要模块:(1)已给定的函数库:(2)单链表结构体:(3)链表初始化及创建:(4)主程序:(5)操模块作(插入、删除、输出函数):三详细设计结构体typedeftructLNode//结点类型{intdata;//数值域tructLNode 某 ne 某 t;//指针域}LNode,某 Linklit;LinklitInitlit_L(intn)//创建带头结点的单链表{LinklitL;LinklitP;inti;实验报告及详细设计L=(Linklit)malloc(izeof(LNode));L->ne 某 t=NULL;/某先建立一个带头结点的单链表某请输入%d个数据for(i=n;i>0;--i){P=(Linklit)malloc(izeof(LNode));/某生成新结点某/某输入元素值某/P->ne 某 t=L->ne 某 t;/某插入到表头某/L->ne 某 t=P;}returnL;}插入函数LinklitLitInert_L(LinklitL,inti,inte)//单链表的插入{LinklitP,S;intj;P=L;j=0;while(P&&j<i-1)实验报告及详细设计{P=P->ne 某 t;++j;}//寻觅第 i-1 个节点if(!P| |j>i-1)错S=(Linklit)malloc(izeof(LNode));//生成新节点 S->data=e;S->ne 某 t=P->ne 某 t;//插入到 S 中P->ne 某 t=S;returnP;}删除函数LinklitLitDelete_L(LinklitL,inti)//单链表的删除{ LinklitP,S;intj;P=L;j=0;while(P->ne 某 t&&j<i-1){P=P->ne 某 t;实验报告及详细设计++j;}//寻觅第个节点,并令 P 指向其前驱if(!(P->ne 某 t) | |j>i-1)错S=P->ne 某 t;P->ne 某 t=S->ne 某 t;//删除并释放节点free(S);returnP;}输出函数voidprintlit_L(LinklitL)//输出单链表{while(L->ne 某 t!=NULL){L=L->ne 某 t;}}主函数实验报告及详细设计intmain(){LinklitL;inti,choice,n,e;请输入链表元素个数L=Initlit_L(n);请输入操作元素的位置请选择执行语句,选择输入 1 执行插入操作或者选择输入 2 执行删除操作witch(choice){cae1:{请输入插入元素的值:L=LitInert_L(L,i,e);插入后的链表为:printlit_L(L);};break;实验报告及详细设计cae2:{L=LitDelete_L(L,i);删除后的链表为printlit_L(L);};break;}}库函数某 Bae.h(程序名)某/#include<tring.h>#include<ctype.h>#include<malloc.h>/某 malloc()等某/#include<limit.h>/某 INT_MA 某等某/#include<tdio.h>/某 EOF(=^Z 或者 F6),NULL 某/ #include<tdlib.h>/某 atoi()某/#include<io.h>/某 eof()某/#include<math.h>/某 floor(),ceil(),ab()某/#include<proce.h>/某 e 某 it()某//某函数结果状态代码某/#defineTRUE1#defineFALSE0实验报告及详细设计#defineOK1#defineERROR0#defineINFEASIBLE-1/某#defineOVERFLOW-2 因为在 math.h 中已定义 OVERFLOW 的值为 3, 故去掉此行某/typedefintStatu;/某 Statu 是函数的类型,其值是函数结果状态代码,如 OK 等某/typedefintBoolean;/某 Boolean 是布尔类型,其值是 TRUE 或者FALSE 四调试分析:操作函数中的指针变换错用了数组中的 L++;应该为 L=L->ne 某 t;五用户手册:看提示内容六测试结果1)输入 n 的个数为 3,链表的初始赋值为: 123,操作数 i 的位置为2,执行 choice=1,插入值为 4,操作后的结果为: 34212)输入 n 的个数为 4,链表的初始赋值为: 1234,操作数 i 的位置为 5,执行 choice=1,插入值为 5,操作后的结果为:“没有返回值”3)输入 n 的个数为 3,链表的初始赋值为: 123,操作数 i 的位置为 0,执行 choice=1,插入值为 4,操作后的结果为:“没有返回值”4)输入 n的个数为 3,链表的初始赋值为: 123,操作数 i 的位置为 2,执行choice=2,操作后的结果为: 31实验报告及详细设计5)输入 n 的个数为 3,链表的初始赋值为: 123,操作数 i 的位置为4,执行 choice=2,操作后的结果为:“没有返回的值”6)输入 n 的个数为 3,链表的初始赋值为: 123,操作数 i 的位置为 0,执行 choice=2,操作后的结果为:“没有返回的值”。
基于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;}。
数据结构实验报告-链表
数据结构实验报告-链表院系:计算机学院实验课程:数据结构实验实验项⽬:实验⼆利⽤链表实现学⽣健康系统指导⽼师:开课时间:专业:计算机类班级:学⽣:学号:实验⼆利⽤链表实现学⽣健康系统1.综设实验题⽬利⽤链表实现学⽣健康系统2.中⽂摘要本实验是利⽤链表这⼀经典的数据结构来实现⼀个学⽣健康系统,从⽽学⽣的健康信息和相应的个⼈信息可以很⽅便地通过这个系统进⾏增、删、查、改等操作。
3.关键词课程名称数据结构实验实验项⽬利⽤链表实现学⽣健康系统实验时间年⽉⽇实验指导⽼师实验评分链表健康系统C++4.前⾔实验⽬的:想要通过链表这⼀数据结构来实现学⽣健康情况管理的⼏个操作功能。
实验意义:⽅便相关⼈员对学⽣健康信息的管理和操作。
实验内容:主要是新建学⽣健康系统、插⼊学⽣的数据、删除学⽣的数据、从⽂件读取学⽣健康数据、将学⽣的健康等信息写⼊到⽂件、查询指定学⽣的相关信息、在屏幕上输出学⽣相关信息等功能。
健康表中学⽣的信息有学号、姓名、出⽣⽇期、性别、⾝体状况等。
5.实验设计由于该实验主要涉及到链表这⼀存储结构,因此整个实验的关键点便在于对链表这个数据结构的建⽴和操作上。
常见的链表的操作有:建⽴链表、往链表中插⼊数据、从链表中删除数据、查找链表中的元素、修改链表中的元素、销毁链表。
由此,经过对问题的仔细分析之后,发现我们所要实现的健康系统的增、删、查、改等功能与链表这⼀数据结构的关系是:增加学⽣数据相当于往链表中的插⼊数据的操作;删除学⽣数据相当于从链表中的删除数据的操作;查找学⽣数据相当于链表中的查找元素的操作;修改学⽣数据相当于链表中的修改元素的操作;因此,我们可以直接⽤链表来存储所有学⽣的信息,每⼀个学⽣的信息集就是链表中的⼀个节点,这样,就使得我们的健康系统的问题归约到了链表的实现问题上了。
在这个链表的设计上,每⼀个节点包含有相应学⽣的所有信息和⼀个指向下⼀个节点的指针,学⽣的信息包括:学号、姓名、出⽣⽇期、性别和健康信息,分别采⽤C++中的string, string, int, bool 和string类型来表⽰。
数据结构实验报告链表
数据结构实验报告链表
《数据结构实验报告:链表》
在计算机科学领域,数据结构是一门重要的课程,它对于计算机程序的设计和性能有着至关重要的作用。
其中,链表是一种常见的数据结构,它在实际应用中有着广泛的用途。
在本次实验中,我们将深入研究链表这一数据结构,并通过实验来验证其性能和应用。
首先,我们需要了解链表的基本概念。
链表是由一系列节点组成的数据结构,每个节点包含数据和指向下一个节点的指针。
相比于数组,链表具有动态的内存分配和插入/删除操作的优势,但在访问元素时性能稍逊色。
因此,链表适用于需要频繁插入/删除操作的场景。
在本次实验中,我们将实现一个简单的链表数据结构,并进行一系列的操作。
首先,我们将实现链表的创建、插入、删除和遍历等基本操作,并通过实验验证其正确性和性能。
其次,我们将对比链表和数组在不同场景下的性能差异,以便更好地理解链表的适用场景和特点。
通过本次实验,我们将深入了解链表这一数据结构的原理和应用,掌握其基本操作和性能特点,为今后的程序设计和优化提供重要的参考。
同时,我们也将通过实验数据和分析来验证链表的优势和不足,为选择合适的数据结构提供依据。
希望本次实验能够为大家对数据结构和算法有更深入的理解和掌握提供帮助。
通过本次实验,我们对链表这一数据结构有了更深入的了解,并通过实验验证了其性能和应用。
链表作为一种常见的数据结构,在实际应用中有着广泛的用途,掌握其原理和操作对于程序设计和性能优化至关重要。
希望本次实验能够
为大家对数据结构和算法有更深入的理解和掌握提供帮助。
链表实验报告总结
链表实验报告总结链表实验报告总结篇一:顺序表,链表总结实验报告实验报告实验目的:学生管理系统(顺序表)实验要求:1.建表2.求表长3.插入4.查找5.删除6.列表7.退出源程序:#include#include#include#define MaxSize 1000typedef struct{char xh[40];char xm[40];int cj;}DataType; //学生的结构typedef struct {DataType data[MaxSize]; //定义表的数据类型int length; //数据元素分别放置在data[0]到data[length-1]当中} SqList; //表的结构void liebiao(SqList *L)//{int k,n;char q;printf("请输入,输入学生的个数:\n"); fflush(stdin);scanf("%d",&n);for(k=0;k {printf("请输入学生学号\n");scanf("%s",L->data[k].xh);printf("请输入学生名字\n");scanf("%s",L->data[k].xm);printf("请输入学生成绩\n");scanf("%d",&L->data[k].cj); 建立表格}。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验报告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;}}。