12-9java面向对象之链表操作
链表属于数据结构中的基本操作。
链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，操作复杂。
使用链表结构可以克服 数组链表需要预先知道数据大小的缺点，链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。但是链表失去了 数组随机读取的优点，同时链表由于增加了结点的 指针域，空间开销比较大。在计算机科学中，链表作为一种基础的 数据结构可以用来生成其它类型的数据结构。链表通常由一连串节点组成，每个节点包含任意的实例数据（data fields）和一或两个用来指向上一个/或下一个节点的位置的链接（"links"）。链表最明显的好处就是，常规 数组排列关联项目的方式可能不同于这些数据项目在 记忆体或 磁盘上顺序，数据的存取往往要在不同的排列顺序中转换。而链表是一种自我指示 数据类型，因为它包含指向另一个相同类型的 数据的 指针（ 链接）。链表允许插入和移除表上任意位置上的 节点，但是不允许 随机存取。链表有很多种不同的类型： 单向链表， 双向链表以及 循环链表。
链表相当于一个队伍，内部存储的是队伍的人员，通过next来指向下一个对象。
1.链表介绍
案例：火车头->A->B->C 用链表的方式进行实现
class Node //建立节点类，节点中保存数据和下一个对象
{
//封装属性
private String data; //建立数据，可以是任何数据类型
private Node next; //作为连接的下一个对象
//构造方法
public Node(String data)
{
this.data = data;
}
//属性的获取和设置方法
public void setData(String data)
{
this.data = data;
}
public String getData()
{
return this.data;
}
public void setNext(Node next)
{
this.next = next;
}
public Node getNext()
{
return this.next;
}
}
public class TestChain
{
public static void main(String [] args)
{
//建立节点
Node root = new Node("火车头");
Node n1 = new Node("车厢A");
Node n2 = new Node("车厢B");
Node n3 = new Node("车厢C");
//建立节点的关系
root.setNext(n1);
n1.setNext(n2);
n2.setNext(n3);
//打印出这种关系
print(root);
}
public static void print(Node node)
{
if (node != null) //如果该节点存在即打印
{
System.out.println(node.getData());
if (node.getNext() != null) //同时指向下一个节点
{
print(node.getNext());
}
}
}
}
之前博客更新过程中，更多的是把简单代码贴上去，今后将增加这一个讲解的过程。
1.Node类是我们的目标，他相当于对车厢的归类。Node中包含两个部分，第一个就是data，他可以是任何的数据类型；第二个就是Node类的next，他表示该对象所连接的下一个对象。
2.封装我就不多说了，主要是属性data的封装，至于类，需要在程序中实例化。
3.getter和setter函数是所有类中必须存在的
4.主程序中，
//建立节点
Node root = new Node("火车头");
Node n1 = new Node("车厢A");
Node n2 = new Node("车厢B");
Node n3 = new Node("车厢C");
//建立节点的关系
root.setNext(n1);
n1.setNext(n2);
n2.setNext(n3);
Node root = new Node("火车头");
Node n1 = new Node("车厢A");
Node n2 = new Node("车厢B");
Node n3 = new Node("车厢C");
//建立节点的关系
root.setNext(n1);
n1.setNext(n2);
n2.setNext(n3);
首先，实例化节点，其中root代表的是根节点，非常关键；其次，建立节点的联系，通过类中的set来指明下一个连接的对象。最后，打印。这里强调一下打印函数。
public static void print(Node node)
{
if (node != null)//如果该节点存在即打印
{
System.out.println(node.getData());
if (node.getNext() != null)//同时指向下一个节点
{
print(node.getNext());
}
}
}
{
if (node != null)//如果该节点存在即打印
{
System.out.println(node.getData());
if (node.getNext() != null)//同时指向下一个节点
{
print(node.getNext());
}
}
}
打印函数，传递的是对象node。首先，判断node是不是空，如果对象是空，则没有打印的必要；其次不为空则打印data数据，并且判断是否有下一个对象和他相连，有的话，递归调用，这时候的参数就是下一个对象，用getNext（）获取。
2.单向链表的实现
上文更多的是手工排列，如何实现自动？
一个基本的链表操作如下：
1.增加数据，用户只关心数据是什么，不关心数据的保存
2.输出数据，有多少个数据，就全部输出，用户不关系如何找到
3.查找数据是否存在
4.删除
不管链表如何实现，都需要Node类进行支持。
class Node //建立节点类，节点中保存数据和下一个对象
{
//封装属性
private String data; //建立数据，可以是任何数据类型
private Node next; //作为连接的下一个对象
//构造方法
public Node(String data)
{
this.data = data;
}
//属性的获取和设置方法
public void setData(String data)
{
this.data = data;
}
public String getData()
{
return this.data;
}
public void setNext(Node next)
{
this.next = next;
}
public Node getNext()
{
return this.next;
}
}2.1增加数据以及打印
用户增加数据，不关心Node，只关心数据（属性）。用户通过方法增加数据，必须由程序将数据封装成节点，使用Node的构造方法实现，否则无法完成next的引用问题。
在增加数据变为节点之后，首先判断该操作（link）是否有根节点，没有的话，就把增加的节点赋值到根节点，否则，节点自己动作，找到合适的位置。那么如何找到合适的位置呢？
首先，判断当前节点指向的next是否为空。空则表明新节点放在当前节点后面即可；否则，说明当前节点还指向下一个节点，用下一个节点来递归调用该方法。
案例：
class Node //建立节点类，节点中保存数据和下一个对象
{
//封装属性
private String data; //建立数据，可以是任何数据类型
private Node next; //作为连接的下一个对象
//构造方法
public Node(String data)
{
this.data = data;
}
//属性的获取和设置方法
public void setData(String data)
{
this.data = data;
}
public String getData()
{
return this.data;
}
public void setNext(Node next)
{
this.next = next;
}
public Node getNext()
{
return this.next;
}
//新节点找到合适的位置
public void addNode(Node newnode)
{
if (this.getNext() == null) //当前节点指向空，则可以把新节点排在这
{
this.setNext(newnode);
}else
{
this.getNext().addNode(newnode);
}
}
public void printNode()
{
System.out.println(this.getData()); //输出当前的数据
if (this.getNext() != null) //还有下一个节点
{
this.getNext().printNode();
}
}
}
class Link //链表操作类
{
private Node root; //定义根节点
public void add(String data) //增加数据,需要把数据变为节点
{
Node newnode = new Node(data);
if (this.root == null) //根节点为空
{
this.root = newnode;
}else
{
this.root.addNode(newnode);
}
}
public void print() //输出的全部数据
{
if (this.root != null)
{
this.root.printNode();
}
}
}
public class TestChain
{
public static void main(String [] args)
{
Link link = new Link();
String root = "火车头";
String n1 = "车厢1";
String n2 = "车厢2";
String n3 = "车厢3";
link.add(root);
link.add(n1);
link.add(n2);
link.add(n3);
link.print();
}
}
解释：
public void add(String data) //增加数据,需要把数据变为节点
{
Node newnode = new Node(data);
if (this.root == null) //根节点为空
{
this.root = newnode;
}else
{
this.root.addNode(newnode);
}
}首先，Node newnode = new Node(data);把增加的属性封装为节点；其次判断this.root是否为空，如果根节点为空，新节点即为根节点；否则要调用Node类进行增加节点。
在Node类中，
if (this.getNext() == null) //当前节点指向空，则可以把新节点排在这
{
this.setNext(newnode);
}else
{
this.getNext().addNode(newnode);
}以上的这一切都归功于this关键字的操作，this代表的当前对象，那个对象调用了方法this就代表他。
2.2数据查找操作
class Node //建立节点类，节点中保存数据和下一个对象
{
//封装属性
private String data; //建立数据，可以是任何数据类型
private Node next; //作为连接的下一个对象
//构造方法
public Node(String data)
{
this.data = data;
}
//属性的获取和设置方法
public void setData(String data)
{
this.data = data;
}
public String getData()
{
return this.data;
}
public void setNext(Node next)
{
this.next = next;
}
public Node getNext()
{
return this.next;
}
//新节点找到合适的位置
public void addNode(Node newnode)
{
if (this.getNext() == null) //当前节点指向空，则可以把新节点排在这
{
this.setNext(newnode);
}else
{
this.getNext().addNode(newnode);
}
}
//类中查找数据
public boolean containsNode(String data)
{
if (this.getData().equals(data)) //当前相等
{
return true;
}
else if (this.getNext() == null) //找完了
{
return false;
}
else //还要继续找
{
return this.getNext().containsNode(data);
}
}
//类中打印数据
public void printNode()
{
System.out.println(this.getData()); //输出当前的数据
if (this.getNext() != null) //还有下一个节点
{
this.getNext().printNode();
}
}
}
class Link //链表操作类
{
private Node root; //定义根节点
public void add(String data) //增加数据,需要把数据变为节点
{
Node newnode = new Node(data);
if (this.root == null) //根节点为空
{
this.root = newnode;
}else
{
this.root.addNode(newnode);
}
}
public void print() //输出的全部数据
{
if (this.root != null)
{
this.root.printNode();
}
}
public boolean contains(String data) //定义查找数据的方法
{
if (this.root == null && data == null && "".equals(data))
{
return false; //不用判断
}
return this.root.containsNode(data); //否则调用Node类中的查找
}
}
public class TestChain
{
public static void main(String [] args)
{
Link link = new Link();
String root = "火车头";
String n1 = "车厢1";
String n2 = "车厢2";
String n3 = "车厢3";
link.add(root);
link.add(n1);
link.add(n2);
link.add(n3);
link.print();
System.out.println(link.contains("火车头1"));
}
}
解释：
首先判断根节点是否存在，不存在直接返回false。存在用根节点开始调用查找函数。在该函数中，首先判断当前节点的属性是否相同，相同返回true；否则判断如果next指向空了，则false，否则用next递归调用。
2.3数据删除操作
能查找就能删除，因为删除之前必须保证删除的节点存在。删除节点就是空出节点的过程。在删除的过程中注意是否是根节点，如果是根节点，不同节点的删除方式不同。
案例：
class Node //建立节点类，节点中保存数据和下一个对象
{
//封装属性
private String data; //建立数据，可以是任何数据类型
private Node next; //作为连接的下一个对象
//构造方法
public Node(String data)
{
this.data = data;
}
//属性的获取和设置方法
public void setData(String data)
{
this.data = data;
}
public String getData()
{
return this.data;
}
public void setNext(Node next)
{
this.next = next;
}
public Node getNext()
{
return this.next;
}
//新节点找到合适的位置
public void addNode(Node newnode)
{
if (this.getNext() == null) //当前节点指向空，则可以把新节点排在这
{
this.setNext(newnode);
}else
{
this.getNext().addNode(newnode);
}
}
//类中查找数据
public boolean containsNode(String data)
{
if (this.getData().equals(data)) //当前相等
{
return true;
}
else if (this.getNext() == null) //找完了
{
return false;
}
else //还要继续找
{
return this.getNext().containsNode(data);
}
}
//类中删除数据
public void deleteNode(String data)
{
if (this.getNext().getData().equals(data))
{
this.setNext(this.getNext().getNext());
}else if (this.getNext().getNext() !=null)
{
this.getNext().deleteNode(data);
}
}
//类中打印数据
public void printNode()
{
System.out.println(this.getData()); //输出当前的数据
if (this.getNext() != null) //还有下一个节点
{
this.getNext().printNode();
}
}
}
class Link //链表操作类
{
private Node root; //定义根节点
public void add(String data) //增加数据,需要把数据变为节点
{
Node newnode = new Node(data);
if (this.root == null) //根节点为空
{
this.root = newnode;
}else
{
this.root.addNode(newnode);
}
}
public void print() //输出的全部数据
{
if (this.root != null)
{
this.root.printNode();
}
}
public boolean contains(String data) //定义查找数据的方法
{
if (this.root == null && data == null && "".equals(data))
{
return false; //不用判断
}
return this.root.containsNode(data); //否则调用Node类中的查找
}
//删除
public void delete(String data)
{
if (this.contains(data)) //要删除的节点是存在的
{
if (this.root.getData().equals(data)) //说明要删除的内容是根节点,则根赋值为后面的节点
{
this.root = this.root.getNext();
} else
{
this.root.deleteNode(data);
}
}
}
}
public class TestChain
{
public static void main(String [] args)
{
Link link = new Link();
String root = "火车头";
String n1 = "车厢1";
String n2 = "车厢2";
String n3 = "车厢3";
link.add(root);
link.add(n1);
link.add(n2);
link.add(n3);
link.print();
System.out.println(link.contains("火车头1"));
link.delete("车厢3");
link.delete("车厢1");
System.out.println("删除之后的结果：");
link.print();
}
}
这里的删除要先用查找进行判断，具体过程不再解释。
核心：this关键字的使用，引用传递。
祝大家健健康康，快快乐乐。