线性表（2）——单链表

概念：单链表是由一个个结点链接而成的，而结点是存储一个数据元素的存储单元。一个结点至少包括以下两个部分：结点（数据域，地址域），其中数据域用于存储数据元素，地址域存储前驱或者后续元素的地址。

以下定义单链表结点类和单链表类描述单链表。

结构设计：

首先声明单链表结点类Node的泛型类如下，成员变量data表示结点的数据域，存储数据元素，数据类型是T；next表示结点的地址域，存储后继结点的引用信息。

package dataStructure;

public class Node<T> {
	public T data;//数据域，存储数据元素
	public Node<T> next; //地址域，引用后继结点
	public Node(T data,Node<T> next) {
		this.data=data;
		this.next=next;
	}
	public Node() {
		this(null, null);
	}
	public String toString() { //返回结点数据域的描述字符串
		return this.data.toString();
	}

}

接着声明一个带头结点的单链表描述类，单链表的存储结构通常的都是带头结点的，在单链表最前面增加一个头结点。加入头结点有两个好处，它可让我们对单链表的插入、删除操作不需要区分操作位置，而且头指针head非空，能实现共享单链表。

声明单链表类SinglyList如下，其中成员变量head表示头指针，引用单链表结点。

package dataStructure;

public class SinglyList<T> 	extends Object {
	public Node<T> head;//头指针，指向单链表的头结点
	//(1)构造方法
	public SinglyList() {  //构造空单链表
		this.head=new Node<T>();//构建头结点，data和next都为null
	}
	public SinglyList(T[] values) {//构造单链表，由values数组提供元素
		this();//构建空单链表，只有一个头结点
		Node<T>rear=this.head;//rear指向单链表的最后一个结点
		for(int i=0;i<values.length;i++)
		{
			rear.next=new Node<T>(values[i],null);
			rear=rear.next;
		}
	}
	public boolean isEmpty() {//判断单链表是否为空
		return this.head.next==null;
	}
	//(2)存取
	public T get(int i)
	{
		Node<T> p=this.head.next;
		for(int j=0;p!=null&&j<i;j++)
			p=p.next;
		return(i>=00&&p!=null)?p.data:null;
	}
	public String toString() {
		String str=this.getClass().getName()+"(";  //返回类名
		for(Node<T> p=this.head.next;p!=null;p=p.next) {//p遍历单链表
			str+=p.data.toString();
			if(p.next!=null)
				str+=",";
		}
		return str+")";
	}
	//(3)插入，插入x作为第i个元素，并对序号做容错处理
	public Node<T> insert(int i,T x){
		if(x==null)
			throw new NullPointerException("x==null");
		Node<T> front=this.head;
		for(int j=0;j<i&&front.next!=null;j++)
			front=front.next;
		front.next=new Node<T>(x,front.next);
		return front.next;
	}
	public Node<T> insert(T x){ //在单链表最后添加x对象，o（n）
		//调用insert(i,x),用整数最大值指定插入在最后，遍历一次，i必须容错
		return insert(Integer.MAX_VALUE,x);
	}
	//(4)删除
	public T remove(int i) {
		Node<T> front=this.head;
		for(int j=0;front.next!=null&&j<i;j++)
			front=front.next;
		if(i>=0&&front.next!=null) {
			T old=front.next.data;
			front.next=front.next.next;
			return old;
		}
		return null;
	}
	public void clear() { //删除单链表所有元素
		this.head.next=null;
	}
	public SinglyList(SinglyList<T> list) {//浅拷贝，两个头指针指向同一个结点
		this.head=list.head;
	}
}

效率分析：
isEmpty（）方法复杂度是O（1）：toString（）、size（）、get（i）、insert（i，x）、remove（i）等成员方法都要遍历单链表，所以时间复杂度都是O（n）。

（1）单链表不是随机存取结构

虽然访问单链表第0个结点的时间是O（1）；但要访问第i个结点，必须从head开始沿着链的方向寻找，遍历部分单链表，进行进行i此p=p.next操作，平均n/2次。因此，get（i）方法的时间复杂度为O（n），即单链表不是随机存取结构。

（2）插入或者删除的时间花在查找

insert(i,x)、remove(i,x)等方法，都要先遍历寻找操作位置，由front指向，时间复杂度为O（n）；再修改front的next域，插入或者删除front后继结点。