Java数据结构链表的插入与删除
数据结构单链表插入、删除和修改实验报告
计算机学院实验报告课程名称:数据结构实验名称:单链表学生姓名:***学生学号:***********实验日期:2012一、实验目的1.理解数据结构中带头结点单链表的定义和逻辑图表示方法。
2.掌握单链表中结点结构的C++描述。
3.熟练掌握单链表的插入、删除和查询算法的设计与C++实现。
二、实验内容1.编制一个演示单链表插入、删除、查找等操作的程序。
三、实验步骤1.需求分析本演示程序用C++6.0编写,完成单链表的生成,任意位置的插入、删除,以及确定某一元素在单链表中的位置。
①输入的形式和输入值的范围:插入元素时需要输入插入的位置和元素的值;删除元素时输入删除元素的位置;查找操作时需要输入元素的值。
在所有输入中,元素的值都是整数。
②输出的形式:在所有三种操作中都显示操作是否正确以及操作后单链表的内容。
其中删除操作后显示删除的元素的值,查找操作后显示要查找元素的位置。
③程序所能达到的功能:完成单链表的生成(通过插入操作)、插入、删除、查找操作。
④测试数据:A.插入操作中依次输入11,12,13,14,15,16,生成一个单链表B.查找操作中依次输入12,15,22返回这3个元素在单链表中的位置C.删除操作中依次输入2,5,删除位于2和5的元素2.概要设计1)为了实现上述程序功能,需要定义单链表的抽象数据类型:(1)insert初始化状态:单链表可以不为空集;操作结果:插入一个空的单链表L。
(2)decelt操作结果:删除已有的单链表的某些结点。
(3)display操作结果:将上述输入的元素进行排列显示。
(4)modify操作结果:将上述输入的某些元素进行修改。
(5)save操作结果:对上述所有元素进行保存。
(6)load操作结果:对上述元素进行重新装载。
3.使用说明程序执行后显示======================1.单链表的创建2.单链表的显示3.单链表的长度4.取第i个位置的元素5.修改第i个位置的元素6.插入元素到单链表里7.删除单链表里的元素8.合并两个单链表9.退出系统=======================5.源代码:#include<iostream>using namespace std;#define true 1#define false 0#define ok 1#define error 0#define overflow -2typedef int Status;typedef int ElemType;typedef struct LNode{ ElemType data;struct LNode *next;}LNode,*LinkList;void CreateList(LinkList &L,int n){ LinkList p;L=new LNode;L->next=NULL;LinkList q=L;for(int i=1;i<=n;i++){ p=new LNode;cin>>p->data;p->next=NULL;q->next=p;q=p; }}Status GetElem(LinkList L,int i,ElemType &e){ LinkList p=L->next;int j=1;while(p&&j<i){ p=p->next;++j; }if(!p||j>i) return error;e=p->data;return ok;}Status LinkInsert(LinkList &L,int i,ElemType e) { LinkList p=L;int j=0;while(p&&j<i-1){ p=p->next;++j; }if(!p||j>i-1)return error;LinkList s=new LNode;s->data=e;s->next=p->next;p->next=s;return ok;}Status ListDelete(LinkList &L,int i,ElemType &e){ LinkList p=L;LinkList q;int j=0;while(p->next&&j<i-1){p=p->next;++j; }if(!(p->next)||j>i-1) return error;q=p->next;p->next=q->next;e=q->data;delete(q);return ok;}void MergeList(LinkList &La,LinkList &Lb,LinkList &Lc) {LinkList pa,pc,pb;pa=La->next;pb=Lb->next;Lc=pc=La;while(pa&&pb){ if(pa->data<=pb->data){ pc->next=pa;pc=pa;pa=pa->next; }else{ pc->next=pb;pc=pb;pb=pb->next; }}pc->next=pa?pa:pb;delete(Lb);}void show(LinkList L){ LinkList p;p=L->next;while(p){ cout<<p->data<<"-->";p=p->next; }cout<<endl;}int Length(LinkList L,int i){ i=0;LinkList p=L->next;while(p){ ++i;p=p->next; }return i;}void xiugai(LinkList L){ int i,j=1;ElemType k;ElemType e,m;LinkList p=L->next;cout<<"请输入要修改的元素位置(0<i<length):";cin>>i;GetElem(L,i,e);cout<<"该位置的元素:"<<e<<endl;cout<<"修改后的元素值:";cin>>k;while(p&&j<i){ p=p->next;++j; }m=p->data;p->data=k;cout<<"修改后的单链表显示如下:"<<endl;show(L);}void hebing(){ int a,b;LinkList La,Lb,Lc;cout<<"请输入第一个有序链表的长度:"<<endl;cin>>a;cout<<"请输入第一个有序链表的元素共("<<a<<"个):"<<endl;CreateList(La,a);show(La);cout<<"请输入第二个有序链表的长度:"<<endl;cin>>b;cout<<"请输入第二个有序链表的元素共("<<b<<"个):"<<endl;CreateList(Lb,b);show (Lb);MergeList(La,Lb,Lc);cout<<"合并后的有序链表如下:"<<endl;show(Lc);}void main(){ int select;int x;ElemType y;LinkList list;for(;;){ cout<<" 单链表的基本操作"<<endl;cout<<" 1.单链表的创建"<<endl;cout<<" 2.单链表的显示"<<endl;cout<<" 3.单链表的长度"<<endl;cout<<" 4.取第i个位置的元素"<<endl;cout<<" 5.修改第i个位置的元素"<<endl;cout<<" 6.插入元素到单链表里"<<endl;cout<<" 7.删除单链表里的元素"<<endl;cout<<" 8.合并两个单链表"<<endl;cout<<" 9.退出系统"<<endl;cout<<"请选择:";cin>>select;switch(select){ case 1:cout<<"请输入单链表的长度:"<<endl;cin>>x;cout<<"请输入"<<x<<"个元素"<<endl;CreateList(list,x);break;case 2: cout<<"单链表显示如下:"<<endl;show(list);break;case 3: int s;cout<<"单链表的长度为:"<<Length(list,s)<<endl;break;case 4: cout<<"请选择所要取出元素的位置:";cin>>x;while(x<0||x>Length(list,s)){ cout<<"输入有误,请重新输入"<<endl;cout<<"请选择所要取出元素的位置:";cin>>x; }GetElem(list,x,y);cout<<"该位置的元素为:"<<y<<endl;break;case 5: xiugai(list); break;case 6: cout<<"请选择要插入的位置:"; cin>>x;while(x<0||x>Length(list,s)){ cout<<"输入有误,请重新输入"<<endl;cout<<"请选择所要插入元素的位置:";cin>>x; }cout<<"要插入的元素值:";cin>>y;LinkInsert( list,x,y);cout<<"插入后单链表显示如下:"<<endl;show(list);break;case 7: cout<<"请选择要删除的位置:"; cin>>x;while(x<0||x>Length(list,s)){ cout<<"输入有误,请重新输入"<<endl;cout<<"请选择所要删除元素的位置:";cin>>x; }ListDelete(list,x,y);cout<<"要删除的元素值:"<<y<<endl;cout<<"删除后的单链表显示如下:"<<endl;show(list);break;case 8: hebing();break;case 9: exit(0);break;default : cout<<"输入有误,请重新输入"<<endl;break;}}}6.测试结果四、实验总结(结果分析和体会)单链表的最后一个元素的next为null ,所以,一旦遍历到末尾结点就不能再重新开始;而循环链表的最后一个元素的next为第一个元素地址,可返回头结点进行重新遍历和查找。
Java连接MySql数据库,并且实现插入、删除、更新、选择操作
天之火–Qutr的专栏君子终日乾乾,夕惕若,厉,无咎。
HomeJava连接MySql数据库,并且实现插入、删除、更新、选择操作!这是我最近写的一个连接MySql数据库的一个例子,主要实现了插入,删除,更新,选择操作,用的环境是j2sdk1.4.2_08,Eclipse3.1。
以前我的同事用Python 写了同样的类,非常的好用,支持了我们公司的大部分业务,现在我们慢慢改用Java了,所以我用Java重写了一遍。
一方面在今后的业务中能够用到,另一方面熟悉一下Java。
下面我把在Eclipse3.1下怎样配置数据库连接信息简单说一下。
1.启动Eclipse3.1。
2.建立一个Java project就叫DbConnect 吧,再在该Project下建立一个新类也叫DbConnect 吧。
3.右击DbConnect.java文件点import,选择Archive file然后选择你的mysql-connector-java-3.1.8-bin.jar文件,点Finish。
你会看到有好些文件被加载进来,OK这就是连接MySql所需的驱动信息。
如果到了这里你都成功的话那么恭喜你,你已经成功一半了!:)4.接下来把我下面的代码copy到你的Java文件中,修改相关的数据库连接信息运行一下。
OK?我说一下那个mysql-connector-java-3.1.8-bin.jar文件,其实这就是一个MySql的驱动,各数据库厂商提供了不同的适用于JDBC的驱动使得在Java中连接数据库非常简单。
这里我就不多说了,以后我会写篇专门介绍数据库驱动的文章。
关于MySql的驱动还有更新版本的,你需要到MySql的网站上去下载,这个网上到处都是,我就不多说了。
下面看程序,有些地方我写了详细的注释应该能看懂。
这个类是非常有特色的,在每个方法的传人参数和返回值不变的情况下,希望高手能提出改进意见。
多指教,谢谢!/*** 数据库连接、选择、更新、删除演示*///import java.sql.*;import java.sql.Connection;import java.sql.Statement;import java.sql.ResultSet;import java.sql.DriverManager;import java.util.*;public class DbConnect{/////////////////////////////////////////———–>>>数据成员and 构造函数private Connection dbconn;private Statement dbstate;private ResultSet dbresult;DbConnect(){dbconn = null;dbstate = null;dbresult = null;}/////////////////////////////////////////———–>>>类方法public void print(String str)//简化输出{System.out.println(str);}//end print(…)/*** 连接MySql数据库* @param host* @param port* @param dbaName* @param usName* @param psw* @return bool值,连接成功返回真,失败返回假*/public boolean dbConnection(String host, String port, String dbaName, String usName, String psw){String driverName = "com.mysql.jdbc.Driver";//"org.gjt.mm.mysql.Driver"两个驱动都可以用String dbHost = host;//数据库的一些信息String dbPort = port;String dbName = dbaName;String enCoding = "?useUnicode=true&characterEncoding=gb2312"; //解决MySql中文问题,要连续写不能空格String userName = usName;String Psw = psw;String url = "jdbc:mysql://" + dbHost + ":" + dbPort + "/" + dbName + enCoding;try{Class.forName(driverName).newInstance();dbconn = DriverManager.getConnection(url, userName, Psw);//getConnection(url, userName, Psw)从给的driver中选择合适的去连接数据库//return a connection to the URL}catch(Exception e){print("url = " + url); //发生错误时,将连接数据库信息打印出来print("userName = " + userName);print("Psw" + Psw);print("Exception: " + e.getMessage());//得到出错信息}if (dbconn != null)//dbconn != null 表示连接数据库成功,由异常保证!?return true;elsereturn false;}// end boolean dbConnection(…)/*** 对数据库表进行选择操作!* @param tableName 数据库表名* @param fieles 字段名* @param selCondition 选择条件* @return 一个含有map的List(列表)*/public ArrayList dbSelect(String tableName, ArrayList fields, String selCondition){ArrayList mapInList = new ArrayList();String selFields = "";for (int i = 0; i<fields.size(); ++i)selFields += fields.get(i) + ", ";String selFieldsTem = selFields.substring(0, selFields.length() – 2);//根据String的索引提取子串try{dbstate = dbconn.createStatement();String sql = "select " + selFieldsTem + " from " + tableName + selCondition;print("sql = " + sql);try{dbresult = dbstate.executeQuery(sql);}catch(Exception err){print("Sql = " + sql);print("Exception: " + err.getMessage());}while(dbresult.next()){Map selResult = new HashMap();selResult.put("message_type", dbresult.getString("message_type"));selResult.put("message_content",dbresult.getString("message_content"));mapInList.add(selResult);}}catch(Exception e){print("Exception: " + e.getMessage());}return mapInList;}//end String dbSelect(…)/*** 对数据库表中的记录进行删除操作* @param tableName* @param condition* @return bool值,表示删除成功或者失败。
java数据结构笔试题目
java数据结构笔试题目Java数据结构笔试题目⒈数组●数组的基本概念●数组的声明和初始化●数组的访问和修改●多维数组●数组的常见操作(排序、查找、插入、删除)⒉链表●链表的基本概念●链表的实现(单链表、双链表、循环链表)●链表的插入和删除●链表的反转●链表的常见操作(查找、更新、合并)⒊栈和队列●栈的基本概念和特点●栈的实现和应用●队列的基本概念和特点●队列的实现和应用●栈和队列的比较⒋树●树的基本概念和术语●二叉树的基本概念和实现●二叉树的遍历(前序、中序、后序)●二叉搜索树●平衡二叉树和红黑树⒌图●图的基本概念和术语●图的表示方法(邻接矩阵、邻接表)●图的遍历算法(深度优先搜索、广度优先搜索)●最短路径算法(Dijkstra、Floyd-Warshall)●最小树算法(Prim、Kruskal)⒍散列表●散列函数的定义和特点●散列表的基本概念和实现●冲突解决方法(开放寻址法、链表法)●散列表的性能分析和优化●哈希算法和应用⒎堆●堆的基本概念和特点●堆的实现(二叉堆、斐波那契堆)●堆的应用(优先队列、堆排序)●堆的性能分析和优化●堆与其他数据结构的联系⒏排序算法●冒泡排序●插入排序●选择排序●快速排序●归并排序●堆排序●希尔排序●桶排序和基数排序⒐搜索算法●顺序搜索●二分搜索●插值搜索●哈希搜索●广度优先搜索●深度优先搜索●A搜索算法⒑字符串匹配算法●暴力匹配算法●KMP算法●Boyer-Moore算法●Rabin-Karp算法●后缀树和后缀数组1⒈复杂度分析●时间复杂度●空间复杂度●最好、最坏和平均情况复杂度●复杂度的比较和选择●复杂度分析的实例附件:无法律名词及注释:⒈版权:著作权法所赋予作品创作者对其原创作品的独占权利。
⒉商标:商标法所保护的一种标识,用于区分和识别特定商品或服务的来源。
⒊专利:专利法所赋予的一种权利,用于保护发明者的发明创造,限制他人在专利权期限内制造、使用、销售、进口该发明。
链表的插入操作总结
链表的插⼊操作总结链表是⼀种经常使⽤的数据结构,有单链表, 双向链表及其循环链表之分.
插⼊操作是链表的基本操作之中的⼀个.但⼤部分⼈在初学时,多少会感到有些迷惑.
以下时本⼈的⼀些⼩经验.
1 后向插⼊和前向插⼊
如果当前节点为P.
后向插⼊是指在p节点后插⼊新节点.
前向插⼊是指在p节点后插⼊新节点.
对于单链表⽽⾔,仅仅有后向插⼊.
2 基本规律
1) 先保存原链表结构不变,即先改动新节点的前后指针,然后再先远后近.
2) 先远后近是指先改动离p节点远的指针,在改动离它近的指针.
3 链表操作⽰意图
下图是可⾏的⼏种链表插⼊⽅法.都是依照上述的基本规律实现的.⾃⼰能够依据⾃⼰的喜好选择⼀种.。
删除节点的方法
删除节点的方法在计算机科学中,删除节点是常见的一种操作。
在数据结构中,节点是数据的存储单元,每个节点通常包含一个值和一个指向下一个节点的引用。
当需要删除一个节点时,通常需要先找到该节点,然后将其从数据结构中删除。
本文将介绍几种常见的删除节点的方法,并讨论它们的优缺点。
一、单链表中删除节点单链表是一种常见的数据结构,它由一系列节点组成,每个节点包含一个值和一个指向下一个节点的引用。
在单链表中,删除一个节点通常需要先找到该节点的前一个节点,然后将其指向下一个节点。
具体的步骤如下:1. 遍历单链表,找到需要删除的节点的前一个节点。
2. 将需要删除的节点的引用从前一个节点指向下一个节点。
3. 释放需要删除的节点的内存空间。
下面是一个示例代码:```void deleteNode(Node* head, int value) {Node* prev = NULL;Node* curr = head;while (curr != NULL && curr->value != value) {prev = curr;curr = curr->next;}if (curr != NULL) {if (prev != NULL) {prev->next = curr->next;} else {head = curr->next;}free(curr);}}```二、双向链表中删除节点双向链表与单向链表类似,不同之处在于每个节点不仅有一个指向下一个节点的引用,还有一个指向前一个节点的引用。
在双向链表中删除一个节点,需要将其前一个节点的“下一个”引用指向其后一个节点,同时将其后一个节点的“上一个”引用指向其前一个节点。
具体的步骤如下:1. 遍历双向链表,找到需要删除的节点。
2. 将需要删除的节点的前一个节点的“下一个”引用指向其后一个节点。
3. 将需要删除的节点的后一个节点的“上一个”引用指向其前一个节点。
节点删除操作方法
节点删除操作方法节点删除是一种常见的数据结构操作,用于从数据结构中删除一个指定的节点。
节点删除操作的实现方法因不同数据结构而异,下面将就几种常见的数据结构——链表、二叉树和图——来分别说明它们的节点删除操作方法。
首先,链表是一种由节点组成的数据结构,其中每个节点包含数据以及指向下一个节点的指针。
在链表中进行节点删除操作,主要有以下几种情况:1. 删除头节点:如果要删除的是链表的头节点,只需将头指针指向第二个节点即可。
可以通过以下代码实现:c++Node* temp = head;head = head->next;delete temp;2. 删除尾节点:要删除链表的尾节点,需要遍历整个链表,找到尾节点的前一个节点,然后将其指向null。
可以通过以下代码实现:c++Node* cur = head;while (cur->next->next != nullptr)cur = cur->next;delete cur->next;cur->next = nullptr;3. 删除中间节点:要删除链表的中间节点,需要找到待删除节点的前一个节点,然后将其指向待删除节点的下一个节点。
可以通过以下代码实现:c++Node* cur = head;while (cur->next->data != target)cur = cur->next;Node* temp = cur->next;cur->next = temp->next;delete temp;接下来,我们来看二叉树的节点删除操作。
二叉树是一种每个节点最多有两个子节点的树结构。
二叉树的节点删除有以下几种情况:1. 删除叶子节点:如果要删除的节点是叶子节点,只需将其父节点指向null即可。
2. 删除只有左子树或只有右子树的节点:如果要删除的节点只有左子树或只有右子树,只需将其父节点指向其子节点即可。
从链表删除节点常用的方法
从链表删除节点常用的方法
从链表中删除节点有几种常见的方法,具体方法取决于要删除的节点位置和链表结构。
以下是一些常用的方法:
直接删除:
如果知道要删除节点的位置,可以直接修改该节点的指针,将其指向下一个节点的指针,从而跳过要删除的节点。
然后,释放要删除节点的内存空间。
这种方法的时间复杂度为O(1)。
前驱节点删除:
如果知道要删除节点的位置,可以通过找到该节点的上一个节点,并将其指向下下个节点,从而实现删除效果。
这种方法要求能够找到要删除节点的上一个节点,时间复杂度为O(n)。
虚拟头节点:
在链表头部添加一个虚拟头节点,这样每个节点的删除操作就变成了对头节点的操作。
如果要删除的节点是头节点,则将头节点指向下一个节点即可。
如果要删除的节点不是头节点,则需要找到该节点的上一个节点,并将其指向下下个节点。
这种方法的时间复杂度为O(1)。
双指针删除:
使用两个指针分别指向要删除节点的上一个节点和要删除节点本身。
首先将上一个节点的指针指向下下个节点,然后释放要删除节点的内存空间。
最后将当前指针向前移动一位。
这种方
法的时间复杂度也为O(1)。
这些方法各有优缺点,应根据实际情况选择合适的方法进行链表节点的删除操作。
JAVA数据结构——单链表的操作
单链表的操作方法一:package ch02;(1)建立结点类Node.javapublic class Node {public Object data;//存放结点数据值public Node next;//存放后继结点//无参构造函数public Node(){ this(null,null);}//只有结点值的构造函数public Node(Object data){ this(data,null);}//带有节点值和后继结点的构造函数public Node(Object data,Node next){ this.data=data;this.next=next;}}(2)建立链表及操作LinkList.javapackage ch02;import java.util.Scanner;public class LinkList implements IList{public Node head;//单链表的头指针//构造函数初始化头结点public LinkList(){head=new Node();}//构造函数构造长度为n的单链表public LinkList(int n,boolean Order) throws Exception{ this();if(Order)create1(n); //头插法顺序建立单链表elsecreate2(n); //尾插法逆序建立单链表}//头插法顺序建立单链表public void create1(int n) throws Exception{Scanner sc=new Scanner(System.in);System.out.println("请输入结点的数据(头插法):”);for(int i=0;i<n;i++){insert(0,sc.next());}}//尾插法逆序建立单链表public void create2(int n) throws Exception{Scanner sc=new Scanner(System.in);System. out.println("请输入结点的数据(尾插法):");for(int i=0;i<n;i++){insert(length(),sc.next());}}//将链表置空public void clear(){head.data=null;head.next=null;}//判断链表是否为空public boolean isEmpty(){return head.next==null;}//返回链表长度public int length(){Node p=head.next;int length=0;while(p!=null){p=p.next;length++;//返回P不空长度length加1}return length;}//读取并返回第i个位置的数据元素public Object get(int i) throws Exception {Node p=head.next;int j;//从首结点开始向后查找,直到9指向第i个结点或者p为nullfor(j=0;j<i&&p!=null;j++){ p=p.next;}if(j>i||p==null)//i不合法时抛出异常throw new Exception("第"+i+”个数据元素不存在”);return p.data;}//插入乂作为第i个元素public void insert(int i, Object x) throws Exception{ Node p=head;int j=-1;//寻找第i个结点的前驱i-1while(p!=null&&j<i-1){p=p.next;j++;}if(j>i-l||p==null)//i不合法时抛出异常throw new Exception("插入位置不合法”);Node s=new Node(x);s.next=p.next;p.next=s;}//删除第i个元素public void remove(int i) throws Exception{ Node p=head;int j=-1;while(p!=null&&j<i-1){//寻找第i-1 个节点p=p.next;j++;}if(j>i-1||p.next==null)throw new Exception("删除位置不合法”);p.next=p.next.next;}//返回元素x首次出现的位序号public int indexOf(Object x) {Node p=head.next;int j=0;while(p!=null&&!p.data.equals(x)){p=p.next;j++;if(p!=null)return j;elsereturn -1;}public void display(){Node p=head.next;while(p!=null){if(p.next==null)System.out.print(p.data);elseSystem.out.print(p.data+"f );p=p.next;}}}(3)建立测试类Test.javappublic class test {public static void main(String[] args) throws Exception { // TODO Auto-generated method stubScanner sc=new Scanner(System.in);boolean or;int xz,xx;System.out.println("请选择插入的方法:0、头插法,1、尾插法");xz=sc.nextInt();if(xz!=0)or=true;elseor=false;System. out.println("请插入的结点的个数:”);xx=sc.nextInt();LinkList L=new LinkList(xx,or);System.out.println("建立的链表为:");L.display();System.out.println();System.out.println("链表的长度:"+L.length());System. out.println(”请输入查找的结点的数据:”);Object x=sc.next();int position=L.indexOf(x);System.out.println("结点的数据为:"+x+"的位置为:"+position); System. out.println("请输入删除的结点的位置:”);int sr=sc.nextInt();L.remove(sr);L.display();System.out.println();System.out.println("链表的长度:"+L.length()); }品P rob I em & J a vs d oc / Declaration Q Error Log 里Con sole-M、、■=:termin8ted> test [3] [Java Application] C U &ert\Ad im i n i st rat o r\Ap p Data\L o cs I请选择插入.的方法:0、头插法,lv星插法请插入的特点的个数:请愉入结点的颓据(尾插法):A B C E D F建立的旌表为;A+B T C+E T D+F链表的长度:6请输入查找的结点的数据:结点的数据为:E的位置为:3请输入删除的结点的位置,R+B T E+DW道表的长度:S方法二(引入get和set方法)Package sy;import java.util.Scanner;//单链表的结点类public class Node {private Object data; //存放结点值private Node next; //后继结点的引用public Node() { //无参数时的构造函数this(null, null);}public Node(Object data) { // 构造值为data 的结点this(data, null);}public Node(Object data, Node next) {//构造值为data 和next 的结点构造函数this.data = data;this.next = next;}public Object getData() { return data;}public void setData(Object data) {this.data = data;}public Node getNext() { return next;public void setNext(Node next) { this.next = next;}}//实现链表的基本操作类public class LinkList {Node head=new Node();//生成一个带头结点的空链表//根据输入的一系列整数,以0标志结束,用头插法建立单链表public void creat() throws Exception {Scanner sc = new Scanner(System.in); //构造用于输入的对象for (int x=sc.nextInt(); x!=0; x=sc.nextInt()) //输入若干个数据元素的值(以0结束) insert(0, x);//生成新结点,插入到表头}//返回带头结点的单链表中第i个结点的数据域的值。
Java核心数据结构(List、Map、Set)原理与使用技巧
Java核⼼数据结构(List、Map、Set)原理与使⽤技巧JDK提供了⼀组主要的数据结构实现,如List、Set等常⽤数据结构。
这些数据都继承⾃java.util.Collection接⼝,并位于java.util包内。
⼀、List接⼝最重要的三种List接⼝实现:ArrayList、Vector、LinkedList。
它们的类图如下:可以看到,3种List均来⾃AbstratList的实现。
⽽AbstratList直接实现了List接⼝,并扩展⾃AbstratCollection。
ArrayList和Vector使⽤了数组实现,可以认为,ArrayList封装了对内部数组的操作。
⽐如向数组中添加、删除、插⼊新的元素或数组的扩展和重定义。
对ArrayList或者Vector的操作,等价于对内部对象数组的操作。
ArrayList和Vector⼏乎使⽤了相同的算法,它们的唯⼀区别可以认为是对多线程的⽀持。
ArrayList没有对⼀个⽅法做线程同步,因此不是线程安全的。
Vector中绝⼤多数⽅法都做了线程同步,是⼀种线程安全的实现。
因此ArrayList和Vector的性能特性相差⽆⼏。
LinkedList使⽤了循环双向链表数据结构。
LinkedList由⼀系列表项连接⽽成。
⼀个表项总是包含3个部分:元素内容、前驱表项和后驱表项。
如图所⽰:LinkedList的表项源码:private static class Node<E> {E item;Node<E> next;Node<E> prev;Node(Node<E> prev, E element, Node<E> next) {this.item = element;this.next = next;this.prev = prev;}}⽆论LinkedList是否为空,链表都有⼀个header表项,它既是链表的开始,也表⽰链表的结尾。
第2章线性表(2)-数据结构教程(Java语言描述)-李春葆-清华大学出版社
public void Setsize(int nlen)
//设置线性表的长度
{ int len=size();
if (nlen<0 || nlen>len)
throw new IllegalArgumentException("设置长度:n不在有效范围内");
s
s.next=head.next;
ai
head.next=s;
head
…
∧
9/85
public void CreateListF(E[] a) { LinkNode<E> s;
for (int i=0;i<a.length;i++) { s=new LinkNode<E>(a[i]);
s.next=head.next; head.next=s; } }
12/85
3. 线性表基本运算在单链表中的实现
查找序号为i(0≤i≤n-1,n为单链表中数据结点个数)的结点
private LinkNode<E> geti(int i) { LinkNode<E> p=head;
int j=-1; while (j<i) { j++;
p=p.next; } return p; }
//尾插法:由数组a整体建立单链表
//t始终指向尾结点,开始时指向头结点 //循环建立数据结点s //新建存放a[i]元素的结点s //将s结点插入t结点之后
//将尾结点的next置为null
a=('a','b','c','d'),调用CreateListR
java linkedlist的常用方法
java linkedlist的常用方法Java LinkedList 是Java集合框架中提供的一个双向链表实现类。
它提供了许多常用的方法,方便我们对链表进行操作和管理。
本文将介绍LinkedList的常用方法,包括添加元素、删除元素、获取元素、修改元素、查找元素等操作。
1. 添加元素LinkedList提供了多种方法来添加元素。
常用的方法有:- add(E e):在链表末尾添加一个元素。
- addFirst(E e):在链表头部插入一个元素。
- addLast(E e):在链表末尾插入一个元素。
- add(int index, E element):在指定位置插入一个元素。
2. 删除元素LinkedList也提供了多种方法来删除元素。
常用的方法有:- remove():删除并返回链表的第一个元素。
- removeFirst():删除并返回链表的第一个元素。
- removeLast():删除并返回链表的最后一个元素。
- remove(int index):删除指定位置的元素。
3. 获取元素LinkedList提供了多种方法来获取元素。
常用的方法有:- getFirst():返回链表的第一个元素。
- getLast():返回链表的最后一个元素。
- get(int index):返回指定位置的元素。
4. 修改元素LinkedList允许修改链表中的元素。
常用的方法有:- set(int index, E element):将指定位置的元素替换为新的元素。
5. 查找元素LinkedList提供了多种方法来查找元素。
常用的方法有:- contains(Object o):判断链表中是否包含指定的元素。
- indexOf(Object o):返回链表中第一次出现指定元素的索引。
- lastIndexOf(Object o):返回链表中最后一次出现指定元素的索引。
6. 遍历元素LinkedList可以使用迭代器或增强for循环来遍历元素。
数据结构Java版第二章习题
(依据自己的状况选作部分习题,不要剽窃)第二章习题次序储存线性表一判断题1.线性表的逻辑次序与储存次序老是一致的。
×2.次序储存的线性表能够按次号随机存取。
√3.次序表的插入和删除操作不需要付出很大的时间代价,由于每次操作均匀只有近一半的元素需要挪动。
×4.线性表中的元素能够是各种各种的,但同一线性表中的数据元素拥有同样的特征,所以是属于同一数据对象。
√5.在线性表的次序储存构造中,逻辑上相邻的两个元素在物理地点上其实不必定紧邻。
×6.在线性表的次序储存构造中,插入和删除时,挪动元素的个数与该元素的地点相关。
√二单项选择题 ( 请从以下 A,B,C,D 选项中选择一项 )1.线性表是 ( A )。
(A)一个有限序列,能够为空;(B)一个有限序列,不可认为空;(C)一个无穷序列,能够为空;(D)一个无序序列,不可认为空。
2.对次序储存的线性表,设其长度为n,在任何地点上插入或删除操作都是等概率的。
插入一个元素时均匀要挪动表中的( A )个元素。
(A) n/2(B) n+1/2(C) n -1/2(D) n三填空题1.在次序表中做插入操作时第一检查___表能否满了 ______________。
四算法设计题1.设线性表寄存在向量A[arrsize]的前elenum个重量中,且递加有序。
试写一算法,将x插入到线性表的适合地点上,以保持线性表的有序性。
而且剖析算法的时间复杂度。
2.已知一次序表A,其元素值非递减有序摆列,编写一个函数删除次序表中剩余的值同样的元素。
3.编写一个函数,从一给定的次序表A 中删除值在 x~y(x<=y) 之间的所有元素,要求以较高的效率来实现。
提示:能够先将序表中所有在 x~y 之的元素置成一个特别的,其实不立刻除它,而后从最后向前挨次描,拥有特别的元素后,移后来面的元素将其除去。
4.性表中有 n 个元素,每个元素是一个字符,存于向量R[n] 中,写一算法,使 R 中的字符按字母字符、数字字符和其余字符的序摆列。
数据结构实验,线性表的插入和删除,单链表操作,Huffman编码树
{ int i,j,k,x1,x2,m1,m2;
for(i=1;i<(2*n);i++)
{ t[i].pa=t[i].lc=t[i].rc=0;
if(i<=n)
t[i].data=w[i];
else
t[i].data=0;
}
for(i=1;i<n;i++)
{ m1=m2=MAX;
x1=x2=0;
for(j=1;j<(n+i);j++)
ListCount=0;
int nOperateState;
while(TRUE)
{
printf( "选择你要操作的方法,1为插入,2为删除,3为查询!4为退出\r\n ");
scanf("%d",&nOperateState);
switch(nOperateState)
{
case 1:
InsertInfo();
{
printf("请不要重复插入相同学号的信息\r\n");
LocalFree(Info);
return;
}
ptemp=ptemp->pNext;
}
}
if (ListHead)
{
if (ListCount==1)
{
ListTail=Info;
ListTail->pNext=NULL;
ListHead->pNext=ListTail;
temp->stu_num,temp->stu_age,temp->stu_english_grade);
双向链表上的插入和删除算法
编写程序,演示在双向链表上的插入和删除算法。
问题分析:1、在双向链表上操作首先要生成一个双向链表:1>节点定义struct DuLNode{ElemType data;DuLNode *prior;DuLNode *next;};2.> 创建双列表L=(DuLinkList)malloc(sizeof(DuLNode));L->next=L->prior=L;3>输入链表数据;2、3、对向链表进行插入操作算法:在节点p的前面加入一个新的节点q:q=(DuLinkList)malloc(sizeof(DuLNode));q->data=e;q->prior=p->prior;q->next=p;p->prior->next=q;p->prior=q;4、对双向链表进行删除操作算法删除给定节点p得到的代码如下:#include<iostream>#include<malloc.h>#define OK 1#define ERROR 0using namespace std;typedef int ElemType;typedef int status;struct DuLNode{ ElemType data;DuLNode *prior;DuLNode *next;};typedef DuLNode *DuLinkList;status DuListInsert_L(DuLinkList L,int i , ElemType e)//插入函数{DuLinkList p=L; //定义两个指向头节点的指针DuLinkList q=L;int j=0;while(p->next!=L&&j<i) //判断p是否到最后一个数据{p=p->next;j++;}if(p->next==L||j<i) //如果p是最后一个节点或者插入位置大于链表节点数{printf("无效的插入位置!\n");return ERROR;}//创建新节点q,数据为e,指针为nullq=(DuLinkList)malloc(sizeof(DuLNode));q->data=e;q->prior=p->prior;q->next=p;p->prior->next=q;p->prior=q;return OK;}status DuListDelete_L(DuLinkList L,int i , ElemType &e)//删除{DuLinkList p=L;int j=0;while(p->next!=L&&j<i){p=p->next;j++;}if(p->next==L||j<i){return ERROR;}p->prior->next=p->next;p->next->prior=p->prior;e=p->data;free(p);return OK;}int main(){ //初始化双向循环链表LDuLinkList L;L=(DuLinkList)malloc(sizeof(DuLNode)); //创建空双列表头结点L->next=L->prior=L;DuLNode *p,*q;ElemType e;//给L赋初始值p=L;q=L;while(cin>>e){p->next=(DuLNode*)malloc(sizeof(DuLNode));//分配新的节点q=p;p=p->next; //p指向新的节点p->data=e; //新结点的数据域为刚输入的ep->next=L; //新结点的指针域为头结点,表示这是单链表的最后一个结点p->prior=q;L->prior=p;}//p指向头指针,逐一输出链表的每个结点的值p=L;while(p->next!=L) //输出原列表{cout<<p->next->data<<' ';p=p->next;}cin.clear(); //清除上一个cin的错误信息cin.ignore(); //清空输入流int i;cout<<"输入待插入的元素e:";cin>>e;cout<<"输入待插入的位置i:";cin>>i;if(DuListInsert_L(L,i,e)){cout<<"插入后的双链为:";p=L;while(p->next!=L){cout<<p->next->data<<' ';p=p->next;}}printf("\n");p=L;while(p->next!=L) //输出列表{cout<<p->next->data<<' ';p=p->next;}int k;cin.clear(); //清除上一个cin的错误信息cin.ignore(); //清空输入流cout<<"要删除第几个节点k :";cin>>k;if(DuListDelete_L(L,k,e)){cout<<"被删除的元素为:"<<e<<endl;cout<<"删除后的元素为:";p=L;while(p->next!=L) //输出删除后的列表{cout<<p->next->data<<' ';p=p->next;}}elsecout<<"删除出错";return 0;}得到的结果如图罗达明电科一班学号2010301510028 2013、3、17。
java中linklist用法
Java中LinkList用法概述L i nk Li st(链表)是一种常见的数据结构,它是由一系列节点组成的,每个节点包含了数据以及指向下一个节点的指针。
在J av a中,L i nk Li s t是一个具有动态大小的集合,可以在任意位置插入、删除元素。
创建LinkLi st创建一个Li nk Li st对象非常简单,只需使用Ja va提供的L i nk ed Li st类即可。
下面是创建一个Li n kL is t对象的示例代码:```j av aL i nk ed Li st<S tr ing>li nk Li st=n ew Lin k ed Li st<>();```LinkL ist的常用方法L i nk Li st提供了丰富的方法来操作链表的元素,下面介绍一些常用的方法:1.添加元素-`ad dF ir st(E e)`:在链表的开头插入元素。
-`ad dL as t(Ee)`:在链表的末尾插入元素。
-`ad d(in ti nd ex,Ee)`:在指定位置插入元素。
例如,如下代码演示了如何向链表中添加元素:```j av al i nk Li st.a dd Fi rst("A pp le");l i nk Li st.a dd La st("Ba na na");l i nk Li st.a dd(1,"O r an ge");```2.获取元素-`ge tF ir st()`:获取链表的第一个元素。
-`ge tL as t()`:获取链表的最后一个元素。
-`ge t(in ti nd ex)`:获取指定位置的元素。
以下代码展示了如何获取链表中的元素:```j av aS t ri ng fi rs tE le men t=l in kL is t.ge tFi r st();S t ri ng la st El em ent=li nk Li st.g et Las t();S t ri ng el em en tA tIn d ex=l in kL is t.get(1);```3.删除元素-`re mo ve Fi rs t()`:删除链表的第一个元素。
线性表的插入和删除数据结构
线性表的插入和删除(数据结构) 线性表是一种基本的数据结构,它由一组有序的元素构成,每个元素最多只有一个前驱和一个后继。
在数据结构中,线性表可以通过链式存储和顺序存储两种方式来实现。
其中,链式存储使用节点来存储数据和地址,顺序存储则使用数组来存储数据。
下面就以链式存储为例,介绍一下线性表的插入和删除操作。
一、线性表的插入在线性表中插入一个元素,需要遵循以下步骤:1.申请一个新节点,并将要插入的元素存储在新节点中。
2.如果该元素要插入到链表的头部,直接将该节点插入到头节点的位置,并更新头节点指针;否则,遍历链表直到找到要插入的位置。
3.将新节点插入到要插入的位置,并修改该节点的前驱和后继节点的指针,使其指向新节点。
4.更新头节点指针,使其指向新的头节点。
struct Node {int data;struct Node *next;};void insert(struct Node **head_ref, int new_data){struct Node *temp, *new_node;new_node = (struct Node *)malloc(sizeof(struct Node));new_node->data = new_data;new_node->next = (*head_ref);(*head_ref) = new_node;}在以上示例代码中,insert函数使用了传引用技术的指针来操作头节点指针head_ref。
通过传递头节点的地址,该函数可以修改头节点指针。
函数先将头节点指针所指向的头节点保存到temp节点中,然后将新节点的data域设置为new_data,将新节点的next域设置为头节点原先指向的节点,最后将头节点指针指向新节点。
这样就完成了在链表头部插入一个节点的操作。
二、线性表的删除在线性表中删除一个元素,需要遵循以下步骤:1.遍历链表,找到要删除的元素所在的节点。
链表的基本操作
链表的基本操作
链表是一种通用的数据结构,它利用指针对数据元素的每一个节点进行存储,当需要访问任何指定的节点时,受益于指针技术,可以较快的访问指定节点。
在一般的链表中,可以进行如下几种基本操作:
1.插入:链表可以在既有链表中的任何一个位置插入数据元素,通过改变相应指针指向,实现插入操作。
2.删除:链表也可以通过调整相应指针指向,实现删除操作。
3.搜索:在链表中搜索某个元素可以采用顺序搜索的方式,从链表的首元节点开始,逐个比较,直到找到所要查找节点。
4.遍历:链表可以从链表的首元节点开始,按照指针指向,依次访问每一个节点,从而实现对链表的元素的遍历。
5.修改:修改链表可以通过先将要修改的节点找出来,然后调整相应的数据值来实现。
链表的基本操作是一个非常常用的数据结构,可以有效的提高编程效率,更加方便的实现某些算法,广泛应用于很多的计算机程序。
所以在学习更多的数据结构的时候,了解链表的基本操作,也是一个不可忽视的组成部分。
数据结构java语言描述
数据结构java语言描述数据结构是计算机科学中的一门重要课程,它研究如何组织和存储数据,以便于程序的操作和使用。
在现代计算机科学中,数据结构被广泛应用于算法设计、程序设计、数据库系统、网络通信等领域。
本文将以《数据结构Java语言描述》为标题,介绍数据结构的基本概念、分类、常用算法和Java语言实现。
一、基本概念数据结构是指数据元素之间的关系,包括数据元素的类型、组织方式和操作方法。
常见的数据结构有线性结构、树形结构和图形结构。
线性结构是指数据元素之间存在一个前驱和一个后继,例如数组、链表、栈和队列等;树形结构是指数据元素之间存在一个父子关系,例如二叉树、堆和哈夫曼树等;图形结构是指数据元素之间存在多种关系,例如有向图、无向图和带权图等。
数据结构的基本操作包括插入、删除、查找和遍历等。
插入操作是将一个新的数据元素插入到已有数据结构中,删除操作是将一个已有数据元素从数据结构中删除,查找操作是在数据结构中查找一个指定的数据元素,遍历操作是按照一定的方式遍历数据结构中的所有数据元素。
二、分类数据结构可以按照不同的方式进行分类,常见的分类方法包括线性结构、树形结构、图形结构、顺序存储结构和链式存储结构等。
1.线性结构线性结构是指数据元素之间存在一个前驱和一个后继,数据元素之间的关系具有线性的特点。
常见的线性结构包括数组、链表、栈和队列等。
数组是一种线性结构,它是由一组连续的存储单元组成的,每个存储单元存储一个数据元素。
数组的特点是支持随机访问,但插入和删除操作效率较低。
链表是一种线性结构,它是由一组不连续的存储单元组成的,每个存储单元存储一个数据元素和一个指向下一个存储单元的指针。
链表的特点是插入和删除操作效率较高,但访问操作效率较低。
栈是一种线性结构,它是一种后进先出(LIFO)的数据结构,支持插入和删除操作。
栈的应用包括表达式求值、函数调用和回溯算法等。
队列是一种线性结构,它是一种先进先出(FIFO)的数据结构,支持插入和删除操作。
链表结点插入删除选择题
链表结点插入删除选择题以下是一些链表结点插入删除的选择题:●题目1:在一个带头结点的单链表中,将结点x插入到结点p之后,则需要修改哪些指针?答案:需要修改p的next指针和x的next指针。
●题目2:在一个带头结点的单链表中,将结点x插入到表头,则需要修改哪些指针?答案:需要修改头结点的next指针和x的next指针。
●题目3:在一个带头结点的单链表中,删除结点x,则需要修改哪些指针?答案:需要修改x的前驱结点的next指针和x的next指针。
●题目4:在一个带头结点的单链表中,删除表头结点,则需要修改哪些指针?答案:需要修改头结点的next指针。
●题目5:在一个带头结点的单链表中,删除表尾结点,则需要修改哪些指针?答案:需要修改表尾结点的前驱结点的next指针。
以下是一些链表结点插入删除的简答题:简答题1:在一个带头结点的单链表中,将结点x插入到结点p之后,其具体操作步骤是什么?答案:●找到结点p。
●将结点x的next指针指向结点p的next。
●将结点p的next指针指向结点x。
简答题2:在一个带头结点的单链表中,将结点x插入到表头,其具体操作步骤是什么?答案:●将结点x的next指针指向头结点的next。
●将头结点的next指针指向结点x。
简答题3:在一个带头结点的单链表中,删除结点x,其具体操作步骤是什么?答案:●找到结点x。
●将结点x的前驱结点的next指针指向结点x的next。
●释放结点x的内存。
简答题4:在一个带头结点的单链表中,删除表头结点,其具体操作步骤是什么?答案:●将头结点的next指针指向头结点的next的next。
●释放头结点的内存。
简答题5:在一个带头结点的单链表中,删除表尾结点,其具体操作步骤是什么?答案:●找到表尾结点的前驱结点。
●将表尾结点的前驱结点的next指针指向NULL。
●释放表尾结点的内存。
数据结构中链表及常见操作
链表1 定义链表(Linked list)是一种常见的基础数据结构,是一种线性表,但是并不会按线性的顺序存储数据,而是在每一个节点里存到下一个节点的指针(Pointer)。
由于不必须按顺序存储,链表在插入的时候可以达到O(1)的复杂度,比另一种线性表顺序表快得多,但是查找一个节点或者访问特定编号的节点则需要O(n)的时间,而顺序表相应的时间复杂度分别是O(logn)和O(1)。
使用链表结构可以克服数组链表需要预先知道数据大小的缺点,链表结构可以充分利用计算机内存空间,实现灵活的内存动态管理。
但是链表失去了数组随机读取的优点,同时链表由于增加了结点的指针域,空间开销比较大。
在计算机科学中,链表作为一种基础的数据结构可以用来生成其它类型的数据结构。
链表通常由一连串节点组成,每个节点包含任意的实例数据(data fields)和一或两个用来指向明上一个或下一个节点的位置的链接("links")。
链表最明显的好处就是,常规数组排列关联项目的方式可能不同于这些数据项目在记忆体或磁盘上顺序,数据的访问往往要在不同的排列顺序中转换。
而链表是一种自我指示数据类型,因为它包含指向另一个相同类型的数据的指针(链接)。
链表允许插入和移除表上任意位置上的节点,但是不允许随机存取。
链表有很多种不同的类型:单向链表,双向链表以及循环链表。
2 结构2.1 单向链表链表中最简单的一种是单向链表,它包含两个域,一个信息域和一个指针域。
这个链接指向列表中的下一个节点,而最后一个节点则指向一个空值。
一个单向链表的节点被分成两个部分。
第一个部分保存或者显示关于节点的信息,第二个部分存储下一个节点的地址。
单向链表只可向一个方向遍历。
链表最基本的结构是在每个节点保存数据和到下一个节点的地址,在最后一个节点保存一个特殊的结束标记,另外在一个固定的位置保存指向第一个节点的指针,有的时候也会同时储存指向最后一个节点的指针。
一般查找一个节点的时候需要从第一个节点开始每次访问下一个节点,一直访问到需要的位置。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
}
temp1=temp1.next;
}
}
if(x1==0){System.out.println("没有找到您要找的书");}
System.out.println("查找完毕");
} //遍历查找方法书名
public void findNo(String no)
{
Point temp2=head.next;
String s=null;
int j=0,x=0;
while((s=inTwo.readLine())!=null)
{
if(x==0)
{
x=1;
System.out.println(s);
}
else
{
Book book1=new Book();
String ss[]=s.split("\\t");
}catch(IOException e)
{System.out.println(e);}
list.output();
System.out.println("请输入你要查找的方法(1是按书名查找,2是按编号查找):");
int ch=0;
String t1=null;
Scanner readOne=new Scanner(System.in);
for(j=0;j<3;j++)
{
book1.no=ss[0];
=ss[1];
book1.price=Integer.parseInt(ss[2]);
} //这种字符串的解析不会用
list.addTail(book1);
}
}
inTwo.close();
inOne.close();
t1=read.nextLine();
list.findNo(t1);
}
else{System.out.println("您的输入有误");}
System.out.println("请您输入你要删除书的书名:");
String t2=null;
t2=read.nextLine();
list.delete(t2);
list.output();
System.out.println("请你输入你要插入的位置:");
System.out.println("请你输入书的信息:");
int t3=0;
t3=readOne.nextInt();
book.no=read.nextLine();
=read.nextLine();
import java.util.*;
import java.io.*;
public class zhangyue {
public static void main(String args[]){
File readFile=new File("F://book.txt");
Book book=new Book();
int x2=0;
System.out.println("查询结果是:");
if(isEmpity())
{
System.out.println("链表是空的");
}
else
{
while(temp2!=null&&temp2.date.getNo()!=no)
{
//System.out.println("执行到了这一步");
} //查找书编号
public void delete(String na1)
{
Point temp3=head.next;
while(temp3!=null&&temp3.date.getName()!=na1)
{
if(na1.equals(temp3.date.getName()))
{
//Point q=temp3.next;
//s.date=date;
Point temp4=head.next;
for(int i=0;i<n;i++)
{
temp4=temp4.next;
}
s.next=temp4.next;
temp4.next=s;
System.out.println("插入完毕");
} //插入
public void output()
{
this.date=date;
}
public Point getNext()
{
return next;
}
public void setNext(Point next)
{
this.next=next;
}
}
class Mylist
{
private Point head=null; //表头
private Point tail=null; //表尾
book.price=readOne.nextInt();
list.insert(book, t3);
}
}
class Book
{
String no;
String name;
int price;
public Book(String no,String name,int price)
{
this.no=no;
}
public void addHead(Book date)
{
head=new Point(date,head);
}
public void addTail(Book date)
{
Point tail=new Point(date,null);
Point temp=head;
while ( temp.getNext() != null)
}
public String toString()
{
return no+" "+name+" "+price;
}
//重写tostring方法
} //book类,以及返回book的no,name,price
class Point
{
Book date=null;
Point next=null;
public Point(Book date)
{
Point w=head.next;
for(w=head.next;w!=null;w=w.next)
{
System.out.println(w.getDate()+" ");
}
}
}
private int length;
int i;
Scanner read=new Scanner(System.in);
public Mylist()
{
this.head=new Point();
//tail=head;
length=0;
}
public boolean isEmpity()
{
return head==null;
temp3.next=temp3.next.next;
//delete q;
}
temp3=temp3.next;
}
System.out.println("删除完毕");
}//删除
public void insert(Book date,int n)
{
Point s=new Point(date); //这个地方不知道有没有的方法
{temp=temp.getNe Nhomakorabeat();
}
temp.setNext(tail);
length++;
} //添加
public void findName(String na)
{
int x1=0;
System.out.println("查询结果是:");
if(isEmpity())
{
System.out.println("链表是空的");
}
else
{
Point temp1=head.next;
while(temp1!=null&&temp1.date.getName()!=na)
{
if(na.equals(temp1.date.getName()))
{
System.out.println(temp1.date.toString());
if(no.equals(temp2.date.getNo()))
{
System.out.println(temp2.date.toString());
x2=1;
}
temp2=temp2.next;
}
}
if(x2==0){System.out.println("没有找到您要找的书");}
System.out.println("查找完毕");
=name;
this.price=price;
}
public Book(){};
public String getNo()
{
return no;
}
public String getName()
{
return name;