线性表的基本特征：
- 第一个数据元素没有前驱元素；
- 最后一个数据元素没有后继元素；
- 其余每个数据元素只有一个前驱元素和一个后继元素。
线性表按物理存储结构的不同可分为顺序表（顺序存储）和链表（链式存储）：
- 顺序表（存储结构连续，数组实现）
- 链表（存储结构上不连续，逻辑上连续）
顺序表是在计算机内存中以数组的形式保存的线性表，是指用一组地址连续的存储单元依次存储数据元素的线性结构。线性表采用顺序存储的方式存储就称之为顺序表。
插入删除操作如图：
抽象数据类型（ADT）是指一个数学模型及定义在该模型上的一组操作。于Java语言中的抽象类和接口设计理念是想通的。
abstract class SequenceListAbst{ //顺序表
private static final int DEFAULT_CAPACITY=10;
private int size;
private Object[] elements; //Object数组
public SequenceListAbst(){
size=0;
elements=new Object[DEFAULT_CAPACITY];
}
//顺序表大小
public abstract int size();
//判断是否是空
public abstract boolean isEmpty();
//清空顺序表
public abstract void clear();
//在index处添加元素
public abstract void add(int index, Object element);
//删除指定索引的元素
public abstract boolean delete(int index);
//获取指定索引的元素
public abstract Object get(int index);
//遍历链表
public abstract void iterator();
}
具体的代码省略...
顺序表效率分析：
- 顺序表插入和删除一个元素，最好情况下其时间复杂度（这个元素在最后一个位置）为O(1)，最坏情况下其时间复杂度为O(n)。
- 顺序表支持随机访问，读取一个元素的时间复杂度为O(1)。
顺序表的优缺点：
- 优点：支持随机访问
- 缺点：插入和删除操作需要移动大量的元素，造成存储空间的碎片。
顺序表适合元素个数变化不大，且更多是读取数据的场合。
扩展：
Java中AarrayList是系统实现的顺序表，它是一个动态数组。添加时会有扩容，删除时会有缩容。
扩容：通过无参构造的话，初始数组容量根据JDK版本不同策略不同，每次通过copeOf的方式扩容后容量为原来的1.5倍。
缩容：ArrayList不会自动缩小容积，有一个方法 trimToSize 可以缩小容积。
其他描述：
ArrayList是基于数组实现的，是一个动态数组，其容量能自动增长。
ArrayList不是线程安全的，只能用在单线程环境下。
实现了Serializable接口，因此它支持序列化，能够通过序列化传输；
实现了RandomAccess接口，支持快速随机访问，实际上就是通过下标序号进行快速访问；
实现了Cloneable接口，能被克隆。链表（LinkedList）通常由一连串节点组成，每个节点包含任意的实例数据（data fields）和一或两个用来指向上一个/或下一个节点的位置的链接（"links"）
链表是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存放指向下一个节点的指针(Pointer)，Java中称之为引用。
使用链表结构可以克服数组链表需要预先知道数据大小的缺点，链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。但是链表失去了数组随机读取的优点，同时链表由于增加了结点的指针域，空间开销比较大。
（1）单链表是链表中结构最简单的。一个单链表的节点(Node)分为两个部分，第一个部分(data)保存或者显示关于节点的信息，另一个部分存储下一个节点的地址。最后一个节点存储地址的部分指向空值。
单链表有带头结点和不带头结点两种结构，其结构如下
由于带头结点的链表更容易操作，这里仅实现带头结点的单链表
带头结点的链表插入与删除示意图：
抽象数据类型（ADT）是指一个数学模型及定义在该模型上的一组操作。于Java语言中的抽象类和接口设计理念是想通的。
abstract class SingleLinkedListAbst{ //单链表
protected int size; //链表节点的个数
protected Node head; //头节点
//链表的每个节点类
protected class Node{ //内部类
protected Object data; //每个节点的数据
protected Node next; //每个节点指向下一个节点的引用
public Node(Object data){
this.data=data;
}
}
//单链表的大小
public abstract int size();
//判断链表是否为空
public abstract boolean isEmpty();
//在链表index处添加元素
public abstract void add(int index, Object element);
//删除指定索引的元素
public abstract boolean delete(int index);
//判断元素是否存在
public abstract boolean exist(Object obj);
//查找元素，根据索引index返回节点Node
public abstract Node get(int index);
//遍历链表
public abstract void print();
}
具体的代码：
class SingleLinkedList extends SingleLinkedListAbst{ //实现单链表
public SingleLinkedList(){ //构造方法初始化一个头结点
head=new Node("head");
head.next=null;
size=0;
}
@Override
public int size() {
return size;
}
@Override
public boolean isEmpty() {
return size==0;
}
@Override
public void add(int index, Object element) {
if(index<0 || index>size){
throw new IndexOutOfBoundsException("参数输入错误："+index);
}
//找到索引index结点之前的结点
Node before=head;
int temp=index;
while(temp-->0){
before=before.next;
}
//构造新的待插入结点
Node newNode=new Node(element);
//若索引index处的结点不存在，就在最后插入
if(index==(size+1)){
before=newNode;
newNode.next=null;
size++;
return;
}
//插入结点（断开旧引用，构造新的引用）
Node after=before.next;
before.next=newNode;
newNode.next=after;
size++;
}
@Override
public boolean delete(int index) {
// TODO Auto-generated method stub
return false;
}
@Override
public boolean exist(Object obj) {
// TODO Auto-generated method stub
return false;
}
@Override
public Node get(int index) {
// TODO Auto-generated method stub
return null;
}
@Override
public void print() {
Node currentNode=head.next;
if(currentNode==null){
return;
}
int temp=size;
while(temp--!=0){ //循环
System.out.println((String)currentNode.data);
currentNode=currentNode.next;
}
}
}
此处由于时间原因作者只写了一部分，如是想提升能力的读者必然是全部写完。
单链表效率分析：
在单链表上插入和删除数据时，首先需要找出插入或删除元素的位置。对于单链表其查找操作的时间复杂度为 O(n)，所以
-
链表插入和删除操作的时间复杂度均为 O(n)
-
链表读取操作的时间复杂度为 O(n)
单链表优缺点：
- 优点：不需要预先给出数据元素的最大个数，单链表插入和删除操作不需要移动数据元素
- 缺点：不支持随机读取，读取操作的时间复杂度为 O(n)
（2）单向循环链表
将单链表中终端结点的指针指向头结点，使整个单链表形成一个环，这种头尾相接的单链表称为单循环链表，简称循环链表。
对于循环链表，为了使空链表与非空链表处理一致，通常设一个头结点。如图：
循环链表和单链表的主要差异在于链表结束的判断条件不同，单链表为current.next是否为空，而循环链表为current.next不等于头结点。对于循环链表的增删改查操作与单链表基本相同，仅仅需要将链表结束的条件变成current.next != head即可。
（3）双向链表
双向链表是在单链表的每个结点中，再设置一个指向其前驱结点的指针域。使得两个指针域一个指向其前驱结点，一个指向其后继结点。
对于双向链表，其空和非空结构如下图：
双向链表是单链表扩展出来的结构，它可以反向遍历、查找元素，它的很多操作和单链表相同，比如求长度size()、查找元素get()。这些操作只涉及一个方向的指针即可。插入和删除操作时，需要更改两个指针变量。
插入操作：注意操作顺序
双向链表相对于单链表来说占用了更多的空间，但由于其良好的对称性，使得能够方便的访问某个结点的前后结点，提高了算法的时间性能。是用空间换时间的一个典型应用。
很多代码的实现没有写完，如是想提升能力的读者必然是全部写完（附：对于数据结构初学者（已熟练驾驭编程语言本身），链表的编写必然是熬三天三夜才能搞清楚脉络的）。
温馨提示：看的懂和能写出来绝对是两回事！