JAVA-链表实例
1.实现链表的步骤
- 1).实现Node节点类(用来保存链表中每个节点的数据,以及下一个节点成员)
- 2).实现LinkList链表类(用来封装Node节点类,和用户实现交互)
- 3).在LinkList类里,实现添加,删除,根据要查的Node数据来找表中的序号,根据要查的序号来找对应的Node数据.
- 4).在LinkList类里,实现toArrays方法,用来取出链表中的Node数据的数组
2.类的实现
/*节点类*/
class Node
{
private String data; //节点保存的数据
private Node next; //下个节点
public Node(String data){
this.data = data;
}
public String getData()
{
return data;
}
public void setData(String data)
{
this.data = data;
}
public Node getNext()
{
return next;
}
public void setNext(String data)
{
this.next = new Node(data);
}
/*Description: 添加节点
*return :
*/
public void addNode(String data)
{
if(getNext()!=null)
{
this.next.addNode(data);
}
else
{
this.setNext(data);
}
}
/*Description: 获取节点数据
*return :
*/
public String getData(int index)
{
String ret =null ;
if(index == 0) //如果递归到0,则返回当前数据
{
ret=data;
}
else //否则继续递归查找
{
ret=this.next.getData(--index);
}
return ret;
}
/*Description: 递归地查找data位于链表哪个序号
*return : -1(表示未找到)
*/
public int findIndex(String data,int index)
{
if(this.data.equals(data)) //已找到
{
return index;
}
else if (getNext()==null) //未找到
{
return -1;
}
return this.next.findIndex(data,++index);
}
/*Description: 递归地查找data,并删除
*data: 要找的data
*PreNode: 上个节点,如果为null则当前位于表头
*index: 表示当前位于链表哪个序号
*return : -1(表示未找到) 0~(len-1) (表示data位于链表哪个序号)
*/
public int delData(String data,Node PreNode,int index)
{
int ret = -1;
if(this.data.equals(data)) //删除
{
PreNode.next = this.next;
return index;
}
else if (getNext()==null) //未找到
{
return ret;
}
return this.next.delData(data,this,++index);
}
}
/*链表类*/
class LinkList
{
private Node next; //负责管理的节点
private int len; //统计节点长度
public LinkList(String data)
{
next = new Node(data);
len =1;
}
/*Description: 添加一个节点数据
*return :
*/
public void addData(String data)
{
this.next.addNode(data);
len++;
}
/*Description: 删除一个节点数据
*return : -1(未找到要删除的数据) 0~(len-1) (表示data位于链表哪个序号)
*/
public int delData(String data)
{
int ret=-1;
if(len>=0) //链表有数据
{
if(this.next.getData().equals(data)) //删除表头需要特殊处理
{
this.next = this.next.getNext();
ret = 0;
}
else
ret = next.delData(data,this.next,1);
}
if(ret!= -1) //已删除
{
len--;
}
return ret;
}
/*Description: 根据index找到对应的节点数据
*return : 返回节点数据
*/
public String getNodeData(int index)
{
String ret=null;
if(index>=0 && index<(len))
{
ret = next.getData(index);
}
return ret;
}
/*Description: 根据data查找节点Node位于链表哪个序号
*return : -1(表示未找到) 0~(len-1) (表示data位于链表哪个序号)
*/
public int findNodeIndex(String data)
{
int ret=-1;
if(len>=0) //链表有数据
{
ret = next.findIndex(data,0); //从序号0开始找
}
return ret;
}
/*Description: 将链表中所有的节点数据转为数组
*return :
*/
public String[] toArrays()
{
Node tmp=this.next;
String[] arr = new String[len];
for(int i=0; i< len; i++)
{
arr[i] = tmp.getData();
tmp = tmp.getNext();
}
return arr;
}
public int length()
{
return len;
}
}3.测试代码
public class Test{
public static void main(String args[]){
LinkList list = new LinkList("小A");
//添加节点数据
list.addData("小B");
list.addData("小C");
list.addData("小D");
list.addData("小E");
//打印节点数据
System.out.println("print Node data:");
for(int i=0;i<list.length();i++)
{
System.out.println(list.getNodeData(i));
}
System.out.println("---------------------");
//查找节点数据的序号
System.out.println("小A的index位于:"+list.findNodeIndex("小A"));
System.out.println("小D的index位于:"+list.findNodeIndex("小D"));
System.out.println("小F的index位于:"+list.findNodeIndex("小F")); //返回-1,表示未找到
//删除节点数据
System.out.println("删除小A,并打印小A之前的位置:"+list.delData("小A"));
System.out.println("删除小E,并打印小E之前的位置:"+list.delData("小E"));
//通过数组打印数据
System.out.println("\r\nprint Node data by toArrays() :");
String[] arr=list.toArrays();
for(int i=0;i<arr.length;i++)
{
System.out.println(arr[i]);
}
System.out.println("---------------------");
}
}运行打印:
PS:这样写,只是简单的实现某个数据类型的链表.在后面我们学习了JAVA-Object类,由于Object类是所有类的超类,所以,我们可以来实现满足所有类型的链表
接下来开始重新修改链表.
4.修改链表-将节点数据改为Object类型
class Node
{
private Object data; //节点保存的数据
private Node next; //下个节点
public Node(Object data){
this.data = data;
}
public Object getData() //获取数据
{
return data;
}
public void setData(Object data)
{
this.data = data;
}
public Node getNext()
{
return next;
}
public void setNext(Object data)
{
this.next = new Node(data);
}
/*Description: 添加节点
*return :
*/
public void addNode(Object data)
{
if(getNext()!=null)
{
this.next.addNode(data);
}
else
{
this.setNext(data);
}
}
/*Description: 获取节点数据
*return :
*/
public Object getData(int index)
{
Object ret =null ;
if(index == 0) //如果递归到0,则返回当前数据
{
ret=data;
}
else //否则继续递归查找
{
ret=this.next.getData(--index);
}
return ret;
}
/*Description: 递归地查找data位于链表哪个序号
*return : -1(表示未找到)
*/
public int findIndex(Object data,int index)
{
if(this.data.equals(data)) //已找到
{
return index;
}
else if (getNext()==null) //未找到
{
return -1;
}
return this.next.findIndex(data,++index);
}
/*Description: 递归地查找data,并删除
*data: 要找的data
*PreNode: 上个节点,如果为null则当前位于表头
*index: 表示当前位于链表哪个序号
*return : -1(表示未找到) 0~(len-1) (表示data位于链表哪个序号)
*/
public int delData(Object data,Node PreNode,int index)
{
int ret = -1;
if(this.data.equals(data)) //删除
{
PreNode.next = this.next;
return index;
}
else if (getNext()==null) //未找到
{
return ret;
}
return this.next.delData(data,this,++index);
}
}
/*链表类*/
class LinkList
{
private Node next; //负责管理的节点
private int len; //统计节点长度
public LinkList(Object data)
{
next = new Node(data);
len =1;
}
/*Description: 添加一个节点数据
*return :
*/
public void addData(Object data)
{
this.next.addNode(data);
len++;
}
/*Description: 删除一个节点数据
*return : -1(未找到要删除的数据) 0~(len-1) (表示data位于链表哪个序号)
*/
public int delData(Object data)
{
int ret=-1;
if(len>=0) //链表有数据
{
if(this.next.getData().equals(data)) //删除表头需要特殊处理
{
this.next = this.next.getNext();
ret = 0;
}
else
ret = next.delData(data,this.next,1);
}
if(ret!= -1) //已删除
{
len--;
}
return ret;
}
/*Description: 根据index找到对应的节点数据
*return : 返回节点数据
*/
public Object getNodeData(int index)
{
Object ret=null;
if(index>=0 && index<(len))
{
ret = next.getData(index);
}
return ret;
}
/*Description: 根据data查找节点Node位于链表哪个序号
*return : -1(表示未找到) 0~(len-1) (表示data位于链表哪个序号)
*/
public int findNodeIndex(Object data)
{
int ret=-1;
if(len>=0) //链表有数据
{
ret = next.findIndex(data,0); //从序号0开始找
}
return ret;
}
/*Description: 将链表中所有的节点数据转为数组
*return :
*/
public String[] toArrays()
{
Node tmp=this.next;
String[] arr = new String[len];
for(int i=0; i< len; i++)
{
arr[i] = tmp.getData().toString();
tmp = tmp.getNext();
}
return arr;
}
public int length()
{
return len;
}
}5.测试修改后的链表
接下来,我们便来写一个student学生类,然后通过我们修改后的链表来保存该类
5.1 student学生类如下所示:
/*学生类*/
class Student
{
String name; //名字
String clas; //班级
int score; //成绩
Student(String name,String clas,int score)
{
this.name = name;
this.clas = clas;
this.score = score;
}
/*覆写Object类的equals方法*/
public boolean equals(Object obj)
{
if(obj == null) //地址为null
return false;
if(obj instanceof Student == false) //非本类
{
System.out.println("ERR");
return false;
}
if(this == obj) //地址相同
return true;
Student st = (Student)obj;
if(this.name.equals(st.name) &&
this.clas.equals(st.clas) &&
this.score == st.score )
return true;
return false;
}
/*覆写Object类的toString方法*/
public String toString()
{
return "姓名:"+name+" 班级:"+clas+" 成绩:"+score;
}
}5.2 student学生类的测试代码如下所示:
Student xiaoA = new Student("小A","初1-6班",77);
Student xiaoB = new Student("小B","初2-1班",99);
Student xiaoC = new Student("小C","初1-2班",66);
Student xiaoD = new Student("小D","初2-2班",49);
Student xiaoE = new Student("小E","初2-3班",88);
Student xiaoF = new Student("小F","初2-3班",89);
//创建链表,并添加 xiaoA 链表节点
LinkList list = new LinkList(xiaoA);
//继续添加节点数据
list.addData(xiaoB);
list.addData(xiaoC);
list.addData(xiaoD);
list.addData(xiaoE);
//打印节点数据
System.out.println("print Node data:");
for(int i=0;i<list.length();i++)
{
System.out.println(list.getNodeData(i));
}
System.out.println("---------------------");
//查找节点数据的序号
System.out.println("小A的index位于:"+list.findNodeIndex(xiaoA));
System.out.println("小D的index位于:"+list.findNodeIndex(xiaoD));
System.out.println("小F的index位于:"+list.findNodeIndex(xiaoF)); //返回-1,表示未找到
//删除节点数据
System.out.println("删除小A,并打印小A之前的位置:"+list.delData(xiaoA));
System.out.println("删除小E,并打印小E之前的位置:"+list.delData(xiaoE));
//通过数组打印数据
System.out.println("\r\nprint Node data by toArrays() :");
String[] arr=list.toArrays();
for(int i=0;i<arr.length;i++)
{
System.out.println(arr[i]);
}
System.out.println("---------------------");5.3 打印如下:
下章学习: 7.JAVA-类继承、覆写、final关键字
本文参与 腾讯云自媒体分享计划，分享自作者个人站点/博客。
原始发表：2019-04-29 ，如有侵权请联系 cloudcommunity@tencent.com 删除
评论
登录后参与评论
推荐阅读
目录