一、概要
线性表是一种线性结构，它是具有相同类型的n(n≥0)个数据元素组成的有限序列。本文章介绍线性表的几个基本组成部分：数组、单向链表、双向链表以及双向链表的实现。
二、数组
数组有上界和下界，数组的元素在上下界内是连续的。
存储10,20,30,40,50的数组的示意图如下：
数组的特点是：数据是连续的；随机访问速度快。
数组中稍微复杂一点的是多维数组和动态数组。对于C语言而言，多维数组本质上也是通过一维数组实现的。至于动态数组，是指数组的容量能动态增长的数组；对于C语言而言，若要提供动态数组，需要手动实现；而对于C++而言，STL提供了Vector；对于Java而言，Collection集合中提供了ArrayList和Vector。
三、单项链表
单向链表(单链表)是链表的一种，它由节点组成，每个节点都包含下一个节点的指针。
单链表的示意图如下：
表头为空，表头的后继节点是"节点10"(数据为10的节点)，"节点10"的后继节点是"节点20"(数据为10的节点)，...
单链表删除节点
删除"节点30"。
删除之前："节点20" 的后继节点为"节点30"，而"节点30" 的后继节点为"节点40"。
删除之后："节点20" 的后继节点为"节点40"。
单链表添加节点
在"节点10"与"节点20"之间添加"节点15"。
添加之前："节点10" 的后继节点为"节点20"。
添加之后："节点10" 的后继节点为"节点15"，而"节点15" 的后继节点为"节点20"。
单链表的特点是：节点的链接方向是单向的；相对于数组来说，单链表的的随机访问速度较慢，但是单链表删除/添加数据的效率很高。
四、双向链表
双向链表(双链表)是链表的一种。和单链表一样，双链表也是由节点组成，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。
双链表的示意图如下：
表头为空，表头的后继节点为"节点10"(数据为10的节点)；"节点10"的后继节点是"节点20"(数据为10的节点)，"节点20"的前继节点是"节点10"；"节点20"的后继节点是"节点30"，"节点30"的前继节点是"节点20"；...；末尾节点的后继节点是表头。
双链表删除节点
删除"节点30"。
删除之前："节点20"的后继节点为"节点30"，"节点30" 的前继节点为"节点20"。"节点30"的后继节点为"节点40"，"节点40" 的前继节点为"节点30"。
删除之后："节点20"的后继节点为"节点40"，"节点40" 的前继节点为"节点20"。
双链表添加节点
在"节点10"与"节点20"之间添加"节点15"。
添加之前："节点10"的后继节点为"节点20"，"节点20" 的前继节点为"节点10"。
添加之后："节点10"的后继节点为"节点15"，"节点15" 的前继节点为"节点10"。"节点15"的后继节点为"节点20"，"节点20" 的前继节点为"节点15"。
下面介绍双链表的Java实现：
五、双向链表Java实现
实现代码：
/**
* Java 实现的双向链表。 注：java自带的集合包中有实现双向链表，路径是:java.util.LinkedList
*
* @author Jack
*/
public class DoubleLink<T> {
// 表头
private DNode<T> mHead;
// 节点个数
private int mCount;
// 双向链表“节点”对应的结构体
@SuppressWarnings({ "rawtypes", "hiding" })
private class DNode<T> {
public DNode prev;
public DNode next;
public T value;
public DNode(DNode prev,T value,DNode next) {
this.prev = prev;
this.value = value;
this.next = next;
}
}
// 构造函数
public DoubleLink() {
// 创建“表头”。注意：表头没有存储数据！
mHead = new DNode<T>(null, null, null);
mHead.prev = mHead.next = mHead;
// 初始化“节点个数”为0
mCount = 0;
}
// 返回节点数目
public int size() {
return mCount;
}
// 返回链表是否为空
public boolean isEmpty() {
return mCount == 0;
}
// 获取第index位置的节点
@SuppressWarnings("unchecked")
private DNode<T> getNode(int index) {
if (index < 0 || index >= mCount) {
throw new IndexOutOfBoundsException();
}
// 正向查找
if (index <= mCount / 2) {
DNode<T> node = mHead.next;
for (int i = 0; i < index; i++){
node = node.next;
}
return node;
}
// 反向查找
DNode<T> rnode = mHead.prev;
int rindex = mCount - index - 1;
for (int j = 0; j < rindex; j++) {
rnode = rnode.prev;
}
return rnode;
}
// 获取第index位置的节点的值
public T get(int index) {
return getNode(index).value;
}
// 获取第1个节点的值
public T getFirst() {
return getNode(0).value;
}
// 获取最后一个节点的值
public T getLast() {
return getNode(mCount - 1).value;
}
// 将节点插入到第index位置之前
@SuppressWarnings("unchecked")
public void insert(int index, T t) {
if (index == 0) {
DNode<T> newNode = new DNode<T>(mHead,t,mHead.next);
mHead.next.prev = newNode;
mHead.next = newNode;
mCount++;
return;
}
DNode<T> oldNode = getNode(index);
DNode<T> newNode = new DNode<T>(oldNode.prev,t,oldNode);
oldNode.prev.next = newNode;
oldNode.prev = newNode;
mCount++;
return;
}
// 将节点插入第一个节点处。
public void insertFirst(T t) {
insert(0, t);
}
// 将节点追加到链表的末尾
@SuppressWarnings("unchecked")
public void appendLast(T t) {
DNode<T> newNode = new DNode<T>(mHead.prev,t,mHead);
mHead.prev.next = newNode;
mHead.prev = newNode;
mCount++;
}
// 删除index位置的节点
@SuppressWarnings("unchecked")
public void del(int index) {
DNode<T> oldNnode = getNode(index);
oldNnode.prev.next = oldNnode.next;
oldNnode.next.prev = oldNnode.prev;
oldNnode = null;
mCount--;
}
// 删除第一个节点
public void deleteFirst() {
del(0);
}
// 删除最后一个节点
public void deleteLast() {
del(mCount - 1);
}
} 测试代码：
public class Student {
private int id;
private String name;
public Student(int id, String name) {
this.id = id;
this.name = name;
}
@Override
public String toString() {
return "[" + id + ", " + name + "]";
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
/**
* Java 实现的双向链表。 注：java自带的集合包中有实现双向链表，路径是:java.util.LinkedList
*
* @author Jack
*/
public class DoubleLinkTest {
// 双向链表操作int数据
public static void int_test() {
System.out.println("----int_test----");
// 创建双向链表
DoubleLink<Integer> doubleLink = new DoubleLink<Integer>();
doubleLink.insert(0, 20); // 将 20 插入到第一个位置
doubleLink.appendLast(10); // 将 10 追加到链表末尾
doubleLink.insertFirst(30); // 将 30 插入到第一个位置
// 双向链表是否为空
System.out.println("isEmpty()-------->"+doubleLink.isEmpty());
// 双向链表的大小
System.out.println("size()----------->"+doubleLink.size());
// 打印出全部的节点
for (int i = 0; i < doubleLink.size(); i++) {
System.out.println("doubleLink(" + i + ")=" + doubleLink.get(i));
}
}
//双向链表操作“字符串数据”
public static void string_test() {
String[] sarr = { "ten", "twenty", "thirty", "forty" };
System.out.println("----string_test----");
// 创建双向链表
DoubleLink<String> doubleLink = new DoubleLink<String>();
doubleLink.insert(0, sarr[1]); // 将 sarr中第2个元素 插入到第一个位置
doubleLink.appendLast(sarr[0]); // 将 sarr中第1个元素 追加到链表末尾
doubleLink.insertFirst(sarr[2]); // 将 sarr中第3个元素 插入到第一个位置
doubleLink.insert(2, sarr[3]);
// 双向链表是否为空
System.out.println("isEmpty()----->"+doubleLink.isEmpty());
// 双向链表的大小
System.out.println("size()-------->"+doubleLink.size());
// 打印出全部的节点
for (int i = 0; i < doubleLink.size(); i++) {
System.out.println("doubleLink(" + i + ")=" + doubleLink.get(i));
}
}
//双向链表操作“对象”
public static void object_test() {
Student[] students = new Student[] {
new Student(10, "sky"),
new Student(20, "jody"),
new Student(30, "vic"),
new Student(40, "dan"),
};
System.out.println("----object_test----");
// 创建双向链表
DoubleLink<Student> doubleLink = new DoubleLink<Student>();
doubleLink.insert(0, students[1]); // 将 students中第2个元素 插入到第一个位置
doubleLink.appendLast(students[0]); // 将 students中第1个元素 追加到链表末尾
doubleLink.insertFirst(students[2]); // 将 students中第3个元素 插入到第一个位置
// 双向链表是否为空
System.out.println("isEmpty()------------->"+doubleLink.isEmpty());
// 双向链表的大小
System.out.println("size()----------------->"+doubleLink.size());
// 打印出全部的节点
for (int i = 0; i < doubleLink.size(); i++) {
System.out.println("doubleLink(" + i + ")=" + doubleLink.get(i));
}
System.out.println("-----------------------------");
doubleLink.del(1);
// 双向链表的大小
System.out.println("size()----------------->"+doubleLink.size());
for (int i = 0; i < doubleLink.size(); i++) {
System.out.println("doubleLink(" + i + ")=" + doubleLink.get(i));
}
}
public static void main(String[] args) {
int_test(); // 演示向双向链表操作“int数据”。
string_test(); // 演示向双向链表操作“字符串数据”。
object_test(); // 演示向双向链表操作“对象”。
}
} 输出结果：
----int_test----
isEmpty()-------->false
size()----------->3
doubleLink(0)=30
doubleLink(1)=20
doubleLink(2)=10
----string_test----
isEmpty()----->false
size()-------->4
doubleLink(0)=thirty
doubleLink(1)=twenty
doubleLink(2)=forty
doubleLink(3)=ten
----object_test----
isEmpty()------------->false
size()----------------->3
doubleLink(0)=[30, vic]
doubleLink(1)=[20, jody]
doubleLink(2)=[10, sky]
-----------------------------
size()----------------->2
doubleLink(0)=[30, vic]
doubleLink(1)=[10, sky]本文转载自：http://blog.csdn.net/leicool_518/article/details/42400025
1256
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
