Java 实现单向链表

Java 类库中其实是提供了链表的实现类的，但是如果自己来实现会不会很有成就感呢？

我们知道，Java 官方是没有指针的概念的，当然我们可以把对象的引用理解为指针，虽然与 C 或 C++ 中的指针概念不尽相同。想要自己实现链表，最重要的一步就是怎么表示一个链表中的结点。在 Java中，我们可以定义一个专门表示结点的类，最好是内部类，确保类的封装性与完整性。此结点类可定义如下：

class Node {
public Node(String name, int age) {
this.name = name;
this.age = age;
this.next = null;
}

private String name;
private int age;
private Node next;
}

此处结点的数据类型可以固定写在该类中，毕竟结点中存放的数据一般都是相同类型的。

确定了结点的表示方法，余下的关键问题就是链表的表示方法。我们可以定义一个头结点，初始化为null。然后对于链表增删改查操作都要在此基础上进行。

链表源代码如下：

/**
* 实现自己的链表类
*
* @author Wll
*
*/
public class LinkedListDemo {
public static void main(String[] args) {
LinkedListDemo list = new LinkedListDemo();

Node tom = new Node("Tom", 20);
Node jack = new Node("Jack", 21);
Node michael = new Node("Michael", 18);
Node lisa = new Node("Lisa", 20);
Node kitty = new Node("Kitty", 19);

list.add(tom);
list.add(jack);
list.add(michael);
list.add(lisa);
list.add(kitty);

System.out.println("+++++链表长度+++++");
System.out.println(list.size());

System.out.println("\n+++++遍历链表结果+++++");
list.traverse();

System.out.println("\n+++++删除第 5个结点+++++");
try {
System.out.println(list.delete(4));
list.traverse();
} catch (MyIndexOutOfBoundsException e) {
System.out.println(e.getMessage());
}

System.out.println("\n+++++修改第 3 个结点+++++");
try {
System.out.println(list.modify(2, "Modified", 100));
list.traverse();
} catch (MyIndexOutOfBoundsException e) {
System.out.println(e.getMessage());
}

System.out.println("\n+++++查找第 6 个结点+++++");
try {
System.out.println(list.indexOf(5));
} catch (MyIndexOutOfBoundsException e) {
System.out.println(e.getMessage());
}

System.out.println("\n+++++插入第 3 个结点+++++");
Node lucy = new Node("Lucy", 22);
try {
System.out.println(list.insertAt(2, lucy));
list.traverse();
} catch (MyIndexOutOfBoundsException e) {
System.out.println(e.getMessage());
}

System.out.println("\n+++++重置（清空）链表+++++");
System.out.println(list.reset());
list.traverse();
}

/**
* 在最后一个结点后面添加一个新结点
*
* @param node
*            待添加的新结点
* @return 若插入成功返回 true，否则 false
*/
public boolean add(Node newNode) {
Node p = head;

if (head == null) { // 添加到头部
head = newNode;
return true;
} else { // 添加到末尾结点后面
// 这里是 p.next，因为如果是 p， 则 while 循环结束后 p 必定为 null，p.next 就会空指针异常
while (p.next != null) {
p = p.next;
}
p.next = newNode;
return true;
}
}

/**
* 在任意位置插入一个新结点
*
* @param index
*            插入的位置
* @param newNode
*            插入的结点
* @return 若插入成功返回 true，否则 false
* @throws IndexOutOfBoundsException
*/
public boolean insertAt(int index, Node newNode) throws MyIndexOutOfBoundsException {
Node p = head;
int count = 1;

if (index < 0 || index > this.size()) {
throw new MyIndexOutOfBoundsException("插入异常，请检查下标范围！");
}

if (index == 0) {
newNode.next = head;
head = newNode;
return true;
} else {
while (p != null) {
if (count++ == index) {
newNode.next = p.next;
p.next = newNode;
return true;
}
p = p.next;
}
return false;
}
}

/**
* 删除一个已有结点
*
* @param index
*            该节点的索引，以 0 开始。第 2 个结点索引就是 1
* @return 若删除成功返回 true，否则返回 false
* @throws IndexOutOfBoundsException
*/
public boolean delete(int index) throws MyIndexOutOfBoundsException {
int count = 1;
Node p = head;

if (index < 0 || index > this.size() - 1) {
throw new MyIndexOutOfBoundsException("删除异常，请检查下标范围！");
}

if (index == 0) {
head = p.next;
return true;
} else {
while (p != null) {
if (count++ == index) {
p.next = p.next.next;
return true;
}
p = p.next;
}
return false;
}
}

/**
* 修改结点内容
*
* @param index
*            结点所在索引
* @param name
*            结点 name 属性
* @param age
*            结点 age 属性
* @return 若修改成功返回 true，否则返回 false
* @throws IndexOutOfBoundsException
*/
public boolean modify(int index, String name, int age) throws MyIndexOutOfBoundsException {
Node p = head;
int count = 0;

if (index < 0 || index > this.size() - 1) {
throw new MyIndexOutOfBoundsException("修改异常，请检查下标范围！");
}

while (p != null) {
if (count++ == index) {
p.name = name;
p.age = age;
return true;
}
p = p.next;
}

return false;
}

/**
* 查找指定索引处的结点
*
* @param index
*            结点索引
* @return 索引处结点
* @throws IndexOutOfBoundsException
*/
public Node indexOf(int index) throws MyIndexOutOfBoundsException {
Node p = head;
int count = 0;

if (index < 0 || index > this.size() - 1) {
throw new MyIndexOutOfBoundsException("查询异常，请检查下标范围！");
}

while (p != null) {
if (count++ == index) {
return p;
}
p = p.next;
}

return null;
}

/**
* 获得链表的大小
*
* @return 链表长度
*/
public int size() {
int count = 0;
Node p = head;

while (p != null) {
count++;
p = p.next;
}

return count;
}

/**
* 遍历链表
*/
public void traverse() {
Node p = head;
int count = 0;

while (p != null) {
System.out.println(p);
count++;
p = p.next;
}

if (count == 0) {
System.out.println("链表为空！");
}
}

/**
* 重置链表
*/
public boolean reset() {
head = null;
return true;
}

private Node head = null;

/**
* 内部结点类
*
* @author Wll
*
*/
private static class Node {
public Node(String name, int age) {
this.name = name;
this.age = age;
this.next = null;
}

@Override
public String toString() {
return this.getClass().getName() + "[Name=" + this.name + ", Age=" + this.age + "]";
}

private String name;
private int age;
private Node next;
}
}

class MyIndexOutOfBoundsException extends Exception {
private static final long serialVersionUID = 1L;

public MyIndexOutOfBoundsException(String msg) {
this.msg = msg;
}

@Override
public String getMessage() {
return this.msg;
}

private String msg;
}

虽然上边的代码可以实现链表的常用操作，但是可以想象当链表中的结点数太大时性能会有所下降。下面是对于提升上面代码执行效率的一点思考。

首先，每一次在末尾添加结点都会遍历整个链表。其次，对于链表长度的获取也需要遍历整个链表。这两个操作都会多耗费很多时间。所以更好的解决办法是定义一个变量记录链表长度，每次添加或删除结点的时候就将此变量加 1 或者减 1。除此之外，再定义一个指向末尾结点的引用，每次添加或删除结点时对应将此引用修改，这样在末尾添加结点时就可以节省遍历链表的时间。