上、简单的单端链表
完整代码向下拉
链表是一种常用的数据结构，在插入和移除操作中有着优秀的表现，同为数据结构的数组哭晕，其实数组的访问效率比链表高多了有木有。
我们先看一下链表的样子
有同学可能要说了，这不就是我们生活中的交通工具——火车，没错链表的结构和下图简直就是一个模子刻出来的。(咳咳，忽略这灵魂的画法)
通过火车示意图可以观察到，火车由火车头和n节车厢组成，每节车厢都与下一节车厢相连，能理解这句话，链表你就掌握一半了。
以小学掌握的物品分类知识来对上图进行面向对象抽象，火车整体可以认为是链表，火车又由车厢组成的，同样可以理解链表是由节点组成的，链表起到了组合节点的作用。
1、创建节点(车厢)
车厢都有哪些特点呢？车厢能存放物品，车厢与下一节车厢相连。
public class Node {
public Object data;//存放的数据
public Node next;//指向下一个节点
public Node(Object value) {
this.data = value;
}
//展示节点数据
public void display() {
System.out.print(data+" ");
}
}
2、创建链表（将车厢组合）
在现实中我们要想查看整个火车由一个十分暴力的方法，那就是找到火车头，找到火车头后沿着每节车厢向后查找就可以完整的查看整辆火车。
public class LinkList {
private Node first;//第一个节点
}
在代码中 Node 类已经声明了指向下一个节点的属性，所以只需要找到第一个节点，调用next属性即可无限向后查找。
3、判断链表是否为空
第一个节点为空即为链表为空
public boolean isEmpty() {
return first == null;
}
4、添加数据到链表的头部
添加数据到链表头部，就是将新节点的next指向原来的首节点，再将新节点标记为first即可。
public void addFirst(Object value) {
Node newNode = new Node(value);//创建新节点
if (isEmpty()) {
first = newNode;//没有节点时直接标记为首节点
} else {
newNode.next = first;//新节点next指向旧的首节点
first = newNode;
}
}
5、移除首节点
并非真正意义上的移除，而是将first指向first.next的内存地址，而原来的first会被垃圾回收器回收。
public Node removeFirst() {
if (isEmpty()) {
return null;
}
Node tmp = first;
first = first.next;
return tmp;
}
6、查看链表
由于链表中的每个节点都有变量指向下一个节点，所有可以使用循环递进获取下一个节点实现遍历的效果。
public void display() {
Node current = first;//先从首节点开始
while (current != null) {
current.display();//节点不为空，则打印该节点信息
current = current.next;//获取当前节点的下个节点重新放入current中
System.out.println();
}
}
7、根据值查找链表中的节点
需要遍历节点，将每个节点的值都与要查找的值进行比对，如果值不相等就一直循环，直到最后一个节点为空时表示没有查到。
public Node find(Object value) {
if (isEmpty()) {
return null;
}
Node current = first;
while (current.data != value) {
if (current.next==null){
return null;
}
current = current.next;
}
return current;
}
8、根据值移除节点
移除时同样遍历所有节点，但要保存查到节点的之前节点(previous)，如果查到的节点是第一个节点，直接移除第一个，否则就将前一个节点指向要移除节点的下一个。
public Node remove(Object value){
if (isEmpty()) {
return null;
}
Node current = first;
Node previous = first;
while (current.data != value) {
if (current.next==null){
return null;
}
previous = current;
current = current.next;
}
if (current==first){
removeFirst();
}else{
previous.next=current.next;
}
return current;
}
9、完整代码
public class LinkList {
private Node first;//第一个节点
public void addFirst(Object value) {
Node newNode = new Node(value);//创建新节点
if (isEmpty()) {
first = newNode;//没有节点时直接标记为首节点
} else {
newNode.next = first;//新节点next指向旧的首节点
first = newNode;
}
}
public Node removeFirst() {
if (isEmpty()) {
return null;
}
Node tmp = first;
first = first.next;
return tmp;
}
public void display() {
Node current = first;//先从首节点开始
while (current != null) {
current.display();//节点不为空，则打印该节点信息
current = current.next;//获取当前节点的下个节点重新放入current中
System.out.println();
}
}
public Node find(Object value) {
if (isEmpty()) {
return null;
}
Node current = first;
while (current.data != value) {
if (current.next==null){
return null;
}
current = current.next;
}
return current;
}
public Node remove(Object value){
if (isEmpty()) {
return null;
}
Node current = first;
Node previous = first;
while (current.data != value) {
if (current.next==null){
return null;
}
previous = current;
current = current.next;
}
if (current==first){
removeFirst();
}else{
previous.next=current.next;
}
return current;
}
public boolean isEmpty() {
return first == null;
}
public static void main(String[] args) {
LinkList linkList = new LinkList();
linkList.addFirst("a");
linkList.addFirst("b");
System.out.println("-0---");
linkList.remove("a");
linkList.display();
}
public class Node {
public Object data;//存放的数据
public Node next;//指向下一个节点
public Node(Object value) {
this.data = value;
}
//展示节点数据
public void display() {
System.out.print(data+" ");
}
}
}
单端链表还是有一些不足，比如我们要操作最后一个节点需要遍历整个链表，下一节咱们实现双端链表，提高操作最后一个节点的效率。
中、操作更简单的双端链表
上节文章中咱们了解了链表的结构及原理，但是还有些美中不足的地方，就是无法快速的访问链表中的最后一个节点。
在这节文章中咱们来解决这个问题，一起来吧。
首先先看如何快速访问尾节点，其实这个可以通过一个变量指向尾节点，在做插入、删除时更新尾节点即可。
1、创建节点
节点用于存储数据和下一个节点相连
public class Node {
public Object data;//存放的数据
public Node next;//指向下一个节点
public Node(Object value) {
this.data = value;
}
//展示节点数据
public void display() {
System.out.print(data + " ");
}
}
2、创建链表
操作节点和指向首尾两个节点
public class DoubleEndLinkList {
private Node first;//第一个节点
private Node last;//最后一个节点
}
3、向前添加节点
如果加入的节点是第一个节点，这个节点是首节点同时也是尾节点。如果已经有节点则让新节点指向原来的首节点，让首节点指向新节点。
public void addFirst(Object value) {
Node newNode = new Node(value);
if (isEmpty()) {
//如果为空，尾节点指向此节点
last = newNode;
}
//更替新节点
newNode.next = first;
first = newNode;
}
4、向后添加节点
和向前添加相反，因为链表中last始终指向最后一个节点，所以操作last节点。
public void addLast(Object value) {
Node newNode = new Node(value);
if (isEmpty()) {
//如果为空，首节点和尾节点指向此节点
first = newNode;
last = newNode;
return;
}
//更替尾节点
last.next = newNode;
last = newNode;
}
5、移除首节点
移除首节点时将首节点的下一个节点标记为首节点即可，直到首节点与尾节点相同时(这时也意味这只剩一个节点)不再需要轮替，直接将首尾节点设置为null。
public Node removeFirst() {
if (isEmpty()) {
return null;
}
Node tmp = first;
//仅剩一个节点时
if (first == last) {
first = null;
last = null;
return tmp;
}
//无论有多少个节点都会轮替到first==last
first = first.next;
return tmp;
}
6、完整代码
package com.jikedaquan.datastruct;
public class DoubleEndLinkList {
private Node first;//第一个节点
private Node last;//最后一个节点
public void addFirst(Object value) {
Node newNode = new Node(value);
if (isEmpty()) {
//如果为空，尾节点指向此节点
last = newNode;
}
//更替新节点
newNode.next = first;
first = newNode;
}
public void addLast(Object value) {
Node newNode = new Node(value);
if (isEmpty()) {
//如果为空，首节点和尾节点指向此节点
first = newNode;
last = newNode;
return;
}
//更替尾节点
last.next = newNode;
last = newNode;
}
public Node removeFirst() {
if (isEmpty()) {
return null;
}
Node tmp = first;
//仅剩一个节点时
if (first == last) {
first = null;
last = null;
return tmp;
}
//无论有多少个节点都会轮替到first==last
first = first.next;
return tmp;
}
public void display() {
Node current = first;//先从首节点开始
while (current != null) {
current.display();//节点不为空，则打印该节点信息
current = current.next;//获取当前节点的下个节点重新放入current中
System.out.println();
}
}
public boolean isEmpty() {
return first == null;
}
public static void main(String[] args) {
DoubleEndLinkList linkList = new DoubleEndLinkList();
linkList.addLast("e");
linkList.addFirst("a");
linkList.addFirst("b");
linkList.removeFirst();
linkList.removeFirst();
linkList.removeFirst();
linkList.display();
System.out.println("-0---");
linkList.addLast("c");
linkList.addFirst("1");
linkList.display();
System.out.println("-0---");
linkList.removeFirst();
linkList.removeFirst();
linkList.addLast(9);
linkList.display();
System.out.println("-0---");
linkList.display();
}
public class Node {
public Object data;//存放的数据
public Node next;//指向下一个节点
public Node(Object value) {
this.data = value;
}
//展示节点数据
public void display() {
System.out.print(data + " ");
}
}
}
双端链表能同时向首尾添加新元素，用双端链表实现队列也成为了可能(比用数组实现效率更高)，但是如何快速移除最后一个元素(因为不能快速的追溯之前的元素)成为了一个新难题，请看下一节 双向链表！
下、方便高效的双向链表
单向链表每个节点指向下一个节点，而双向链表是指每个节点还指向了前一个节点。这样做的好处是可以快速的移除最后一个元素。
1、保存数据的节点
节点除了指向下一个节点还要指向前一个节点
public class Node {
public Object data;//存放的数据
public Node previous;//指向前一个节点
public Node next;//指向下一个节点
public Node(Object value) {
this.data = value;
}
//展示节点数据
public void display() {
System.out.print(data + " ");
}
}
2、创建链表指向首元素和尾元素
public class TwoWayLinkList {
private Node first;
private Node last;
}
3、向前添加元素
考虑到链表为空时，首元素和尾元素均指向新元素。
public void addFirst(Object value) {
Node newNode = new Node(value);
if (isEmpty()) {
last = newNode;
first = newNode;
return;
}
//新首元素指向旧首元素
newNode.next = first;
//旧首元素的前一个指向新首元素
first.previous = newNode;
//更替首元素
first = newNode;
}
4、向后添加元素
由于是双向的，所以之前的引用和之后的引用都要更新
public void addLast(Object value) {
Node newNode = new Node(value);
if (isEmpty()) {
first = newNode;
last = newNode;
return;
}
//更替尾元素
newNode.previous = last;
last.next = newNode;
last = newNode;
}
5、移除首元素
如果过已是最后一个元素，直接将首尾设置为null，其他情况进行轮替。
public Node removeFirst() {
Node removeNode = first;
//如果当前已是最后一个元素
if (first.next == null) {
first = null;
last = null;
return removeNode;
}
//首元素指向下一个元素
first = first.next;
//将新首元素指向的之前的元素设为null
first.previous = null;
return removeNode;
}
6、移除尾元素
和移除首元素类似
public Node removeLast() {
Node removeNode = last;
if (last.previous == null) {
first = null;
last = null;
return null;
}
//尾元素指向旧尾元素之前的元素
last = last.previous;
//将新尾元素的下一个元素设为null
last.next = null;
return removeNode;
}
7、根据值移除节点
从第一个元素开始遍历，如果值不相同就一直遍历，没有元素匹配返回null，有元素相同时将之前的元素指向当前元素的下一个，将当前元素下一个指向前一个。
public Node remove(Object value) {
if (isEmpty()){
return null;
}
Node current = first;
while (current.data != value) {
if (current.next == null) {
return null;
}
current = current.next;
}
current.previous.next = current.next;
current.next.previous = current.previous;
return current;
}
8、完整代码
package com.jikedaquan.datastruct;
public class TwoWayLinkList {
private Node first;
private Node last;
public void addFirst(Object value) {
Node newNode = new Node(value);
if (isEmpty()) {
last = newNode;
first = newNode;
return;
}
//新首元素指向旧首元素
newNode.next = first;
//旧首元素的前一个指向新首元素
first.previous = newNode;
//更替首元素
first = newNode;
}
public void addLast(Object value) {
Node newNode = new Node(value);
if (isEmpty()) {
first = newNode;
last = newNode;
return;
}
//更替尾元素
newNode.previous = last;
last.next = newNode;
last = newNode;
}
public Node removeFirst() {
Node removeNode = first;
//如果当前已是最后一个元素
if (first.next == null) {
first = null;
last = null;
return removeNode;
}
//首元素指向下一个元素
first = first.next;
//将新首元素指向的之前的元素设为null
first.previous = null;
return removeNode;
}
public Node removeLast() {
Node removeNode = last;
if (last.previous == null) {
first = null;
last = null;
return null;
}
//尾元素指向旧尾元素之前的元素
last = last.previous;
//将新尾元素的下一个元素设为null
last.next = null;
return removeNode;
}
public Node remove(Object value) {
if (isEmpty()){
return null;
}
Node current = first;
while (current.data != value) {
if (current.next == null) {
return null;
}
current = current.next;
}
current.previous.next = current.next;
current.next.previous = current.previous;
return current;
}
public boolean isEmpty() {
return first == null;
}
public void display() {
Node current = first;//先从首节点开始
while (current != null) {
current.display();//节点不为空，则打印该节点信息
current = current.next;//获取当前节点的下个节点重新放入current中
}
System.out.println();
}
public static void main(String[] args) {
TwoWayLinkList linkList = new TwoWayLinkList();
linkList.addFirst("b");
linkList.addFirst("a");
linkList.display();
System.out.println("======");
while (!linkList.isEmpty()) {
linkList.removeFirst();
linkList.display();
}
System.out.println("======");
linkList.addLast("c");
linkList.addLast("d");
linkList.display();
System.out.println("======");
while (!linkList.isEmpty()) {
linkList.removeLast();
linkList.display();
}
System.out.println("======");
linkList.addFirst("e");
linkList.addLast("f");
linkList.addLast("g");
linkList.display();
System.out.println("======");
linkList.remove("f");
System.out.println("======");
linkList.display();
}
public class Node {
public Object data;//存放的数据
public Node previous;//指向前一个节点
public Node next;//指向下一个节点
public Node(Object value) {
this.data = value;
}
//展示节点数据
public void display() {
System.out.print(data + " ");
}
}
}
9、总结
链表是节点中通过变量指向前一个节点和下一个节点实现了相连，链表在移除节点、首尾添加节点有着优越的性能，时间复杂度O(1)。数组在做同等操作需要O(n)，但在访问元素上优于链表，空间复杂度也小于链表，应在不同的场景选用不同的结构。
当然这些数据结构也不需要我们去实现的，java语言中已经有对应的实现。