线性表接口LList：
package com.clarck.datastructure.linked;
/**
* 线性表接口LList，描述线性表抽象数据类型，泛型参数T表示数据元素的数据类型
*
* @author clarck
*
*/
public interface LList {
/**
* 判断线性表是否空
* @return
*/
boolean isEmpty();
/**
* 返回线性表长度
* @return
*/
int length();
/**
* 返回第i(i≥0)个元素
* @param i
* @return
*/
T get(int i);
/**
* 设置第i个元素值为x
* @param i
* @param x
*/
void set(int i, T x);
/**
* 插入x作为第i个元素
* @param i
* @param x
*/
void insert(int i, T x);
/**
* 在线性表最后插入x元素
* @param x
*/
void append(T x);
/**
* 删除第i个元素并返回被删除对象
* @param i
* @return
*/
T remove(int i);
/**
* 删除线性表所有元素
*/
void removeAll();
/**
* 查找，返回首次出现的关键字为key元素
* @param key
* @return
*/
T search(T key);
}
单链表结点类：
package com.clarck.datastructure.linked;
/**
* 单链表结点类，T指定结点的元素类型
*
* @author clarck
*
* @param
*/
public class Node {
/**
* 数据域，保存数据元素
*/
public T data;
/**
* 地址域，引用后继结点
*/
public Node next;
/**
* 构造结点，data指定数据元素，next指定后继结点
*
* @param data
* @param next
*/
public Node(T data, Node next) {
this.data = data;
this.next = next;
}
/**
* 构造节点
*/
public Node() {
this(null, null);
}
/**
* 返回结点元素值对应的字符串
*/
@Override
public String toString() {
return this.data.toString();
}
/**
* 比较两个结点值是否相等，覆盖Object类的equals(obj)方法
*/
@SuppressWarnings("unchecked")
@Override
public boolean equals(Object obj) {
return obj == this || obj instanceof Node && this.data.equals(((Node)obj).data);
}
}
线性表的链式表示和实现：
package com.clarck.datastructure.linked;
/**
* 线性表的链式表示和实现 带头结点的单链表类，实现线性表接口
*
* @author clarck
*
* @param
*/
public class SinglyLinkedList implements LList {
/**
* 头指针，指向单链表的头结点
*/
public Node head;
/**
* 默认构造方法，构造空单链表
*/
public SinglyLinkedList() {
// 创建头结点，data和next值均为null
this.head = new Node();
}
/**
* 由指定数组中的多个对象构造单链表。采用尾插入构造单链表
* 若element==null，Java将抛出空对象异常；若element.length==0，构造空链表
*
* @param element
*/
public SinglyLinkedList(T[] element) {
// 创建空单链表，只有头结点
this();
// rear指向单链表最后一个结点
Node rear = this.head;
for (int i = 0; i < element.length; i++) {
rear.next = new Node(element[i], null);
rear = rear.next;
}
}
/**
* 判断单链表是否空，O(1)
*/
@Override
public boolean isEmpty() {
return this.head.next == null;
}
/**
* 返回单链表长度，O(n), 基于单链表遍历算法
*/
@Override
public int length() {
int i = 0;
// p从单链表第一个结点开始
Node p = this.head.next;
// 若单链表未结束
while (p != null) {
i++;
// p到达后继结点
p = p.next;
}
return i;
}
/**
* 返回第i(≥0)个元素，若i<0或大于表长则返回null，O(n)
*/
@Override
public T get(int i) {
if (i >= 0) {
Node p = this.head.next;
for (int j = 0; p != null && j < i; j++) {
p = p.next;
}
// p指向第i个结点
if (p != null) {
return p.data;
}
}
return null;
}
/**
* 设置第i(≥0)个元素值为x。若i<0或大于表长则抛出序号越界异常；若x==null，不操作。O(n)
*/
@Override
public void set(int i, T x) {
if (x == null)
return;
Node p = this.head.next;
for (int j = 0; p != null && j < i; j++) {
p = p.next;
}
if (i >= 0 && p != null) {
p.data = x;
} else {
throw new IndexOutOfBoundsException(i + "");
}
}
/**
* 插入第i(≥0)个元素值为x。若x==null，不插入。 若i<0，插入x作为第0个元素；若i大于表长，插入x作为最后一个元素。O(n)
*/
@Override
public void insert(int i, T x) {
// 不能插入空对象
if (x == null) {
return;
}
// p指向头结点
Node p = this.head;
// 寻找插入位置
for (int j = 0; p.next != null && j < i; j++) {
// 循环停止时，p指向第i-1结点或最后一个结点
p = p.next;
}
// 插入x作为p结点的后继结点，包括头插入(i<=0)、中间/尾插入(i>0)
p.next = new Node(x, p.next);
}
/**
* 在单链表最后添加x对象，O(n)
*/
@Override
public void append(T x) {
insert(Integer.MAX_VALUE, x);
}
/**
* 删除第i(≥0)个元素，返回被删除对象。若i<0或i大于表长，不删除，返回null。O(n)
*/
@Override
public T remove(int i) {
if (i >= 0) {
Node p = this.head;
for (int j = 0; p.next != null && j < i; j++) {
p = p.next;
}
if (p != null) {
// 获得原对象
T old = p.next.data;
// 删除p的后继结点
p.next = p.next.next;
return old;
}
}
return null;
}
/**
* 删除单链表所有元素 Java将自动收回各结点所占用的内存空间
*/
@Override
public void removeAll() {
this.head.next = null;
}
/**
* 顺序查找关键字为key元素，返回首次出现的元素，若查找不成功返回null
* key可以只包含关键字数据项，由T类的equals()方法提供比较对象相等的依据
*/
@Override
public T search(T key) {
if (key == null)
return null;
for (Node p = this.head.next; p != null; p = p.next)
if (p.data.equals(key))
return p.data;
return null;
}
/**
* 返回单链表所有元素的描述字符串，形式为“(,)”，覆盖Object类的toString()方法，O(n)
*/
@Override
public String toString() {
String str = "(";
for (Node p = this.head.next; p != null; p = p.next) {
str += p.data.toString();
if (p.next != null)
str += ","; // 不是最后一个结点时后加分隔符
}
return str + ")"; // 空表返回()
}
/**
* 比较两条单链表是否相等
*/
@SuppressWarnings("unchecked")
@Override
public boolean equals(Object obj) {
if (obj == this)
return true;
if (obj instanceof SinglyLinkedList) {
SinglyLinkedList list = (SinglyLinkedList) obj;
return equals(this.head.next, list.head.next);
}
return false;
}
/**
* 比较两条单链表是否相等，递归方法
*
* @param p
* @param q
* @return
*/
private boolean equals(Node p, Node q) {
return p == null && q == null || p != null && q != null
&& p.data.equals(q.data) && equals(p.next, q.next);
}
}
测试类：
package com.clarck.datastructure.linked;
/**
* 单链表的测试
*
* @author clarck
*
*/
public class SinglyLinkedList_test {
public static void main(String args[]) {
SinglyLinkedList lista = new SinglyLinkedList();
for (int i = 0; i <= 5; i++)
lista.insert(i, new String((char) ('A' + i) + ""));
System.out.println("lista: " + lista.toString() + "，length()="
+ lista.length());
lista.set(3, new String((char) (lista.get(0).charAt(0) + 32) + ""));
lista.remove(0);
lista.remove(3);
System.out.println("lista: " + lista.toString());
}
}
测试结果：
lista: (A,B,C,D,E,F)，length()=6lista: (B,C,a,F)
