java建立线性表的链式结构,数据结构学习----线性表的链式表示(Java实现)

线性表接口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)