线性结构(一) - 数组、单链表和双链表

一、概要

       线性表是一种线性结构，它是具有相同类型的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实现

实现代码：

package com.struction;

/**
 * Java 实现的双向链表。 注：java自带的集合包中有实现双向链表，路径是:java.util.LinkedList
 * 
 * @author Anndy
 */
public class DoubleLink<T> {

	// 表头
	private DNode<T> mHead;
	// 节点个数
	private int mCount;

	// 双向链表“节点”对应的结构体
	private class DNode<T> {
		public DNode prev;
		public DNode next;
		public T value;

		public DNode(T value, DNode prev, DNode next) {
			this.value = value;
			this.prev = prev;
			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位置的节点
	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位置之前
	public void insert(int index, T t) {
		if (index == 0) {
			DNode<T> node = new DNode<T>(t, mHead, mHead.next);
			mHead.next.prev = node;
			mHead.next = node;
			mCount++;
			return;
		}

		DNode<T> inode = getNode(index);
		DNode<T> tnode = new DNode<T>(t, inode.prev, inode);
		inode.prev.next = tnode;
		inode.next = tnode;
		mCount++;
		return;
	}

	// 将节点插入第一个节点处。
	public void insertFirst(T t) {
		insert(0, t);
	}

	// 将节点追加到链表的末尾
	public void appendLast(T t) {
		DNode<T> node = new DNode<T>(t, mHead.prev, mHead);
		mHead.prev.next = node;
		mHead.prev = node;
		mCount++;
	}

	// 删除index位置的节点
	public void del(int index) {
		DNode<T> inode = getNode(index);
		inode.prev.next = inode.next;
		inode.next.prev = inode.prev;
		inode = null;
		mCount--;
	}

	// 删除第一个节点
	public void deleteFirst() {
		del(0);
	}

	// 删除最后一个节点
	public void deleteLast() {
		del(mCount - 1);
	}
}

测试代码：

package com.struction;

/**
 * Java 实现的双向链表。 注：java自带的集合包中有实现双向链表，路径是:java.util.LinkedList
 * 
 * @author Anndy
 */

public class DoubleLinkTest {

	// 双向链表操作int数据
	private static void int_test() {
		int[] arr = { 10, 20, 30, 40 };

		System.out.println("\n----int_test----");
		// 创建双向链表
		DoubleLink<Integer> doubleLink = new DoubleLink<Integer>();

		doubleLink.insert(0, 20); // 将 20 插入到第一个位置
		doubleLink.appendLast(10); // 将 10 追加到链表末尾
		doubleLink.insertFirst(30); // 将 30 插入到第一个位置

		// 双向链表是否为空
		System.out.printf("isEmpty()=%b\n", doubleLink.isEmpty());
		// 双向链表的大小
		System.out.printf("size()=%d\n", doubleLink.size());

		// 打印出全部的节点
		for (int i = 0; i < doubleLink.size(); i++)
			System.out.println("doubleLink(" + i + ")=" + doubleLink.get(i));
	}

	private static void string_test() {
		String[] sarr = { "ten", "twenty", "thirty", "forty" };

		System.out.println("\n----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个元素 插入到第一个位置

		// 双向链表是否为空
		System.out.printf("isEmpty()=%b\n", doubleLink.isEmpty());
		// 双向链表的大小
		System.out.printf("size()=%d\n", doubleLink.size());

		// 打印出全部的节点
		for (int i = 0; i < doubleLink.size(); i++)
			System.out.println("doubleLink(" + i + ")=" + doubleLink.get(i));
	}

	// 内部类
	private static 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 + "]";
		}
	}

	private static Student[] students = new Student[] { new Student(10, "sky"),
			new Student(20, "jody"), new Student(30, "vic"),
			new Student(40, "dan"), };

	private static void object_test() {
		System.out.println("\n----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.printf("isEmpty()=%b\n", doubleLink.isEmpty());
		// 双向链表的大小
		System.out.printf("size()=%d\n", 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()=3
doubleLink(0)=thirty
doubleLink(1)=twenty
doubleLink(2)=ten

----object_test----
isEmpty()=false
size()=3
doubleLink(0)=[30, vic]
doubleLink(1)=[20, jody]
doubleLink(2)=[10, sky]