6数据结构实验报告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。

实验报告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;}}。

课程名称：数据结构任课教师：实验题目：线性表的基本操作实验环境： Visual C++ 6.0实验目的：1、掌握线性表的定义；2、掌握线性表的基本操作，如建立、查找、插入和删除等。

实验内容：定义一个包含学生信息（学号，姓名，成绩）的的顺表序和链表，使其具有如下功能：(1)根据指定学生个数，逐个输入学生信息;(2)逐个显示学生表中所有学生的相关信息；(3)根据姓名进行查找，返回此学生的学号和成绩；(4)根据指定的位置可返回相应的学生信息（学号，姓名，成绩）；(5)给定一个学生信息，插入到表中指定的位置；int createStLink(struct Node *head,struct Node *stu){struct Node *p6,*p7,*p8;p7=head;p6=stu;if(head==NULL){head=p6;p6->next=NULL;}else{ //如果链表为空则在头结点创建信息while(p6->num > p7->num && p7->next!=NULL){p8=p7;p7=p7->next;}if(p6->num<=p7->num){if(head==p7)head=p6;elsep8->next=p6;p6->next=p7;}else{p7->next=p6;p6->next=NULL;}}N++;return 1;}int main(){struct Node *H,*stud;char M;int num1;H=initlist();(6)删除指定位置的学生记录;(7) 统计表中学生个数。

实验提示：学生信息的定义：typedef struct {char no[8]; //8位学号char name[20]; //姓名int price; //成绩}Student;顺序表的定义typedef struct {Student *elem; //指向数据元素的基地址int length; //线性表的当前长度}SqList；链表的定义：typedef struct LNode{Student data; //数据域struct LNode *next; //指针域}LNode,*LinkList;实验要求：(1) 程序要添加适当的注释，程序的书写要采用缩进格式。

实验报告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;｝｀｀｀五、实验结果通过对上述链表操作函数的调用，我们成功地创建、遍历、插入和删除了链表中的节点。

实验报告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.熟练掌握线性表在链式存储结构上的运算。

实验环境（硬/软件要求）：Windows 2000, Visual C++ 6.0实验内容：1.编写算法，根据用户输入的字符数据用尾插入法创建一个带头结点的单链表，“#”作为输入数据的结束符。

2.编写算法，实现在带有头结点的单链表中按序号查找的函数。

假设单链表中包含6个数据元素，测试数据是:①查找第0个;②查找第一个;③查找第2个;④查找第6个;⑤查找第7个;实验要求1.完成链表存储结构的类型设计。

2.完成链表带头结点尾插入法函数。

3.完成按序号查找函数。

4.编写主函数完成实验内容的要求。

【C语言源程序】#include <stdio.h>#include<stdlib.h>typedef char datatype;typedef struct node{datatype data;struct node *next;}linklist;linklist *createlist()/*尾插入法建立带头结点的单链表，返回表头指针*/{linklist*head,*s,*r;head=(linklist*)malloc(sizeof(linklist));/*生成头结点head*/r=head;printf("请输入字符产生的链表,以#结束\n");/*尾指针指向头结点*/ch=getchar();while(ch!='#') /*“#”为输入结束符*/{s=(linklist*)malloc(sizeof(linklist)); /*生成新结点*s*/s->data=ch;r->next=s; /*新结点插入表尾*/r=s; /*尾指针r指向新的表尾*/ch=getchar(); /*读入下一个结点的值*/}r->next=NULL;return head; /*返回表头指针*/} /*createlist*//*在带头结点的单链表head中查找第i个结点，若找到，则返回该结点的存储位置；否则返回NULL*/linklist *get(linklist *head,int i){int j;linklist *p;p=head;j=0; /*从头结点开始扫描*/while((p->next!=NULL) && (j<i)){p=p->next; /*扫描下一个结点*/j++; /*已扫描结点计数器*/}if(i==j)return p; /*找到第i个结点*/else return NULL; /*找不到，i<=0或i>n*/} /*GET*/void main(){linklist *head,*r;int num;head=createlist();printf("链表信息为:");r=head->next;while(r){printf("%c",r->data);r=r->next;}printf("请输入要查询的序号:\n");scanf("%d",&num);r=get(head,num);if(r==NULL)printf("没有查到\n");printf("查到的结果为:%c\n",r->data); }。

《数据结构与数据管理》实验报告学生姓名：徐桂平实验日期：2009/12/9实验二实验名称链表实验目的1、掌握链表的存储结构形式;2、熟练掌握动态链表结构及有关算法的设计。

实验题目1、建立含有n个数据元素的带头结点的单链表并输出该表中各元素的值。

2、删除单链表中重复的结点。

3、将一个已知的带头结点的单链表进行逆置运算。

4*、编号为1,2,…n的n个人按顺时针围成一圈，每人持有一正整数密码。

开始时任选一正整数m作为报数的上限值，从第一个人按顺时针自1开始报数，报m的人退出圈子，将他的密码作为新的m值。

在顺时针方向的下一个人开始重新从1报数，如此下去，直到所有人全部出列为止。

令m的最大值为30。

设计一个程序来输出出列顺序源程序代码：第一题：#include<stdio.h>#include"malloc.h"#define NULL 0typedef int ElemType;typedef struct LNode{ElemType data;struct LNode *next;}LNode,*LinkList;void main(){ int n,i;LinkList L,p,s;printf("输入链表元素个数n:");scanf("%d",&n);p=L=(LinkList)malloc(sizeof(LNode));for(i=1;i<=n;i++){s=(LinkList)malloc(sizeof(LNode)); p->next=s; p=s;}p->next=NULL; //在单链表中输入数据p=L->next;printf("输入%d这个结点数据:",n);for(i=1;i<=n;i++){ scanf("%d",&p->data); p=p->next; } //输出单链表中的元素的值p=L->next;printf("输出这些元素:");for(i=1;i<=n;i++){ printf("%5d",p->data); p=p->next;}printf("\n")；}第二题：#include<stdio.h>#include"malloc.h"#define NULL 0typedef int ElemType;typedef struct LNode{ElemType data;struct LNode *next;}LNode,*LinkList;void main(){ int n,i,w;LinkList L,p,s,pt,p1;printf("输入链表元素个数n:");scanf("%d",&n);p=L=(LinkList)malloc(sizeof(LNode));for(i=1;i<=n;i++){s=(LinkList)malloc(sizeof(LNode));p->next=s;p=s;}p->next=NULL;//在单链表中输入数据p=L->next;printf("输入%d这个接点数据:",n);for(i=1;p;i++){ scanf("%d",&p->data); p=p->next; }p=L->next;while(p){ w=p->data;for(pt=p->next,p1=p;pt;){ if(pt->data==w){ p1->next=pt->next；pt=pt->next;}Else { p1=pt; pt=pt->next;} }p=p->next; }p=L->next;for(i=1;p;i++){printf("%5d",p->data); p=p->next; }printf("\n"); }第三题：#include<stdio.h>#include"malloc.h"#define NULL 0typedef int ElemType;typedef struct LNode{ElemType date;struct LNode *next;}LNode,*LinkList;void main(){ int n,i;LinkList L,T,p,s,pt;printf("输入链表元素个数n:");scanf("%d",&n);p=L=(LinkList)malloc(sizeof(LNode));for(i=1;i<=n;i++){s=(LinkList)malloc(sizeof(LNode)); p->next=s；p=s;}p->next=NULL;//在单链表中输入数据p=L->next;printf("输入%d这个接点数据:",n);for(i=1;p;i++){ scanf("%d",&p->date); p=p->next; }p=L->next;T=(LinkList)malloc(sizeof(LNode));T->next=NULL;for(i=1;p;i++){ pt=p->next; p->next=T->next; T->next=p; p=pt;}p=T->next;printf("倒置为：\n");for(i=1;p;i++){printf("%5d",p->date);p=p->next;}printf("\n");}第四题：#include<stdio.h>#include"malloc.h"typedef int ElemType;typedef struct LNode{ElemType data1;ElemType data2;struct LNode *next;}LNode,*LinkList;void main(){ int n,m,i,t,e=0;LinkList L,p,s;printf("输入n和m:"); //n表示人数，m为第一次任选的正整数scanf("%d %d",&n,&m); //构造一个循环链表p=L=(LinkList)malloc(sizeof(LNode));for(i=1;i<=n;i++){s=(LinkList)malloc(sizeof(LNode)); p->next=s；p=s;}p->next=L->next; //对数据一进行初值化，密码p=L->next; //p指向第一个节点if(n<=30)for(i=1;i<=n;i++){ p->data1=i; p=p->next; }if(n>30){ for(i=1;i<=n;i++){p->data1=i%30; p=p->next;}p=L->next; //p指向第一个节点for(i=1;i<=n;i++){if(p->data1==0) p->data1=30; p=p->next; } }//对数据二进行初始化，位序p=L->next; //p指向第一个节点for(i=1;i<=n;i++){p->data2=i; p=p->next;}i=0; p=L->next; //p指向第一个节点while(t<n){if(p->data1!=0) e++;if(e==m){m=p->data1; p->data1=0;printf("%5d",p->data2); e=0; t++;}p=p->next; i++;if(i==n) i=0; }实验结果分析：线性表的链式存储结构可以用一组任意的存储单元存储线性表的数据元素，头结点是指在链表的第一个节点之前附设一个节点。

数据结构实验报告链表
《数据结构实验报告：链表》
在计算机科学领域，数据结构是一门重要的课程，它对于计算机程序的设计和性能有着至关重要的作用。

其中，链表是一种常见的数据结构，它在实际应用中有着广泛的用途。

在本次实验中，我们将深入研究链表这一数据结构，并通过实验来验证其性能和应用。

首先，我们需要了解链表的基本概念。

链表是由一系列节点组成的数据结构，每个节点包含数据和指向下一个节点的指针。

相比于数组，链表具有动态的内存分配和插入/删除操作的优势，但在访问元素时性能稍逊色。

因此，链表适用于需要频繁插入/删除操作的场景。

在本次实验中，我们将实现一个简单的链表数据结构，并进行一系列的操作。

首先，我们将实现链表的创建、插入、删除和遍历等基本操作，并通过实验验证其正确性和性能。

其次，我们将对比链表和数组在不同场景下的性能差异，以便更好地理解链表的适用场景和特点。

通过本次实验，我们将深入了解链表这一数据结构的原理和应用，掌握其基本操作和性能特点，为今后的程序设计和优化提供重要的参考。

同时，我们也将通过实验数据和分析来验证链表的优势和不足，为选择合适的数据结构提供依据。

希望本次实验能够为大家对数据结构和算法有更深入的理解和掌握提供帮助。

通过本次实验，我们对链表这一数据结构有了更深入的了解，并通过实验验证了其性能和应用。

链表作为一种常见的数据结构，在实际应用中有着广泛的用途，掌握其原理和操作对于程序设计和性能优化至关重要。

希望本次实验能够
为大家对数据结构和算法有更深入的理解和掌握提供帮助。

实验2 链表实验概述：一、实验目的本次实习的主要目的是为了使学生熟练掌握链表的基本操作以及在链式存储结构上的实现，包括创建、插入、删除、查找、以及合并等操作。

二、实验要求掌握链表存储方式，熟悉链式存储结构。

三、实验步骤用链表结构实现对多项式初始化、创建、插入、删除等运算。

步骤：输入第一个多项式：7x+2x3输入第二个多项式：8x+9x5输出第一个多项式输出第二个多项式输出两个多项式相加的结果：15x+2x3+9x5实验结果如图：四、实验环境（使用的软件和设备）（1）实习器材：多媒体计算机。

（2）实习地点：校内多媒体机房。

（3）实习软件: Win-TC实验内容：【实验过程】（实验步骤、记录、数据、分析）实验过程（提示）输入第一个多项式：7x+2x3输入第二个多项式：8x+9x5输出第一个多项式输出第二个多项式输出两个多项式相加的结果：15x+2x3+9x5【结果实验记录】（图形或图像）1.说明掌握情况#include<stdio.h>#include<stdlib.h>typedef struct{int sat1,sat2,sat3,sat4;}ElemType;typedef struct LNode{ElemType data;struct LNode *next;}LNode,*LinkList;LinkList InitList(){ LinkList L;L=(LinkList)malloc(sizeof(LNode)); L->next=NULL;return(L);}void InsLNode(LinkList L,ElemType x){ LinkList s,p;s=(LinkList)malloc(sizeof(LNode));s->data=x;p=L;while(p->next)p=p->next;s->next=NULL;p->next=s;}void AddPolyn(LinkList La,LinkList Lb){int sum;int a,b;LinkList pa,pb;pa=La->next;pb=Lb->next;a=pa->data.sat1;b=pb->data.sat1;sum=a+b;printf(" %dx%d exp",sum,pa->data.sat2);printf("+");printf(" %dx%d exp+",pa->data.sat3,pa->data.sat4); printf(" %dx%d exp\n",pb->data.sat3,pb->data.sat4);}void Print(LinkList L){ LinkList p;p=L->next;printf(" %dx%d exp",p->data.sat1,p->data.sat2); printf("+");printf(" %dx%d exp",p->data.sat3,p->data.sat4);}main() {LinkList La,Lb;ElemType c,b;int a,i;La=InitList();Lb= InitList();printf("Please input polynomial La:\n");scanf("%d %d",&c.sat1,&c.sat2);scanf("%d %d",&c.sat3,&c.sat4);InsLNode(La,c);printf("Please input polynomial Lb:\n");scanf("%d %d",&b.sat1,&b.sat2);scanf("%d %d",&b.sat3,&b.sat4);InsLNode(Lb,b);printf("polynomial La:");printf("\n");Print(La);printf("\n");printf("polynomial Lb:");printf("\n");Print(Lb);printf("\n");printf("La+Lb:");printf("\n");AddPolyn(La,Lb);printf("\n");getch();}2.裁图说明实验结果【心得体会、问题和建议】成绩：指导教师签名批阅日期：。

Java数据结构--链表Java数据结构--链表1. 介绍1.1 概述链表是一种常见的数据结构，它由一系列节点组成，每个节点包含数据和一个指向下一个节点的指针。

链表可以动态增删节点，具有灵活性和高效性。

1.2 链表的优点- 可以动态地插入和删除节点，不需要预先分配内存空间。

- 可以很方便地对链表中的数据进行遍历和访问。

1.3 链表的缺点- 需要额外的内存来存储节点间的指针，占用空间较大。

- 链表的节点不能随机访问，需要遍历整个链表才能找到指定节点。

2. 单向链表单向链表是最简单的链表结构。

每个节点只包含一个指向下一节点的指针。

2.1 节点定义单向链表的节点定义如下：```javaclass Node {int data;Node next;public Node(int data) {this.data = data;this.next = null;}}```2.2 链表操作单向链表常见的操作包括：- 在链表尾部插入节点：将新节点添加到链表尾部。

- 在链表头部插入节点：将新节点作为链表的新头节点。

- 在指定位置插入节点：将新节点插入到指定位置。

- 删除指定位置的节点：删除链表中指定位置的节点。

- 遍历链表：依次访问链表中的每个节点。

3. 双向链表双向链表在单向链表的基础上增加了一个指向前一节点的指针。

3.1 节点定义双向链表的节点定义如下：```javaclass DoublyNode {int data;DoublyNode prev;DoublyNode next;public DoublyNode(int data) {this.data = data;this.prev = null;this.next = null;}}3.2 链表操作双向链表和单向链表的操作类似，只是在插入和删除节点时需要同时更新前一节点的指针。

4. 循环链表循环链表是一种尾节点指向头节点的链表结构。

4.1 节点定义循环链表的节点定义与单向链表相同。

班级：姓名： 学号： 设计时间：《高级语言程序设计》课程设计报告一、应用程序的名称：链表二、应用程序的主题与设计目的：实现一个链表的建立、输出，并且完成节点的插入、删除操作。

三、应用程序简介： 1、基本结构A 、功能模块图B 、各模块流程图 （1）链表的建立：开辟一个新节点，使p1、P2指向它读入一个学生数据给p1所指的结点p 指向的节点并且p（3） 链表结点的删除（4）链表节点的插入2、基本内容：(源代码及注释) #include<stdio.h>#include<malloc.h>#define LEN sizeof(struct student) int n;struct student{int num;int score;struct student *next;};struct student *creat(void) /*定义函数，此函数带回一个指向链表头的指针*/{struct student *head;struct student *p1,*p2;n=0;p1=p2=(struct student *)malloc(LEN); /*开辟一个新单元*/ scanf("%d,%d",&p1->num,&p1->score);head=NULL;while(p1->num!=0){ n=n+1;if(n==1)head=p1;else p2->next=p1; /*把p1所指的结点连接在p2所指的结点后面*/p2=p1;p1=(struct student*)malloc(LEN);scanf("%d,%d",&p1->num,&p1->score);}p2->next=NULL;return(head); /*函数返回head的值，即链表中第一个节点的起始地址*/}void print(struct student*head){struct student*p;printf("\nNow,these %d records are:\n",n);p=head;if(head!=NULL)do{ printf("%d %d\n",p->num,p->score);p=p->next;}while(p!=NULL);}struct student*del(struct student*head,int num){struct student*p1,*p2;if(head==NULL){printf("\nlist null! \n");return head;}p1=head;while(num!=p1->num && p1->next!=NULL) /*p1指向的不是所要找的节点，且后有节点*/{ p2=p1;p1=p1->next;} /*p1后移一个节点*/if(num==p1->num) /*找到了*/{ if(p1==head)head=p1->next; /*若p1指向的首节点，把第二个节点地址赋予head*/else p2->next=p1->next; /*否则将下一个节点地址赋给前一节点地址*/printf("delete:%d\n",num);n=n-1;}else printf("%d not beed found!\n",num); /*找不到该节点*/ return(head);}struct student*insert(struct student*head,struct student*stud) {struct student*p0,*p1,*p2;p1=head; /*使p1指向第一个节点*/p0=stud; /*p0指向要插入的节点*/if(head==NULL) /*原来的链表是空表*/{head=p0;p0->next=NULL;} /*使p0指向的节点作为头结点*/else{while((p0->num>p1->num) && (p1->next!=NULL)){ p2=p1; /*使p2指向刚才p1指向的节点*/p1=p1->next; /*p1后移一个节点*/}if(p0->num<=p1->num){if(head==p1)head=p0; /*插到原来第一个节点之前*/else p2->next=p0; /*插到p2指向的节点之后*/ p0->next=p1;}else{ p1->next=p0;p0->next=NULL;} /*插到最后的节点之后*/}n=n+1; /*节点数加1*/return(head);}void main() /*作主调函数*/{ struct student *head,stu;long del_num;printf("input records:\n");head=creat(); /*建立链表，返回头指针*/print(head); /*输出全部节点*/printf("\ninput the deleted number:");scanf("%1d",&del_num); /*输入要删除的学号*/head=del(head,del_num); /*删除后链表的头地址*/print(head); /*输出全部节点*/printf("\ninput thr inserted record:"); /*输入要插入的节点*/ scanf("%d,%d",&stu.num,&stu.score);head=insert(head,&stu); /*插入一个节点，返回头结点地址*/ print(head); /*输出全部节点*/}四、主要运行界面的介绍：（在vc环境下）1、连接运行后，输入数据（以两组为例），组之间以逗号间隔，最后以数字0结束。