最基础的动态数据结构：链表
Java中线性数据结构包括：数组、栈、队列【这三者底层都是基于动态数组实现的，实现动态的机制依靠resize()动态扩容】、链表【真正的动态数据结构】。
链表可以分为单向链表和双向链表。链表中的数据都存储在Node节点中，链表与链表之间的连接依靠next指针
Class Node{
//存放数据
E e;
//指向当前节点的下一个节点
Node next;
}为什么说链表是真正的动态数据结构呢？
链表不像数组，需要在初始化时候申明容量。链表中每一个节点都是一个Node对象，存放着数据和指向下一个Node的引用，在最后一个Node中，next为Null，链表不需要考虑和处理固定容量的问题，自然就不需要resize()了。
对于链表的特点，综合而言：
优点：真正的动态数据结构，不需要处理固定容量的问题
缺点：不像数组一样可以通过Index直接定位元素，丧失了随机访问的能力，从底层来说，数组开辟的空间在内存中是连续分布的，所以我们可以直接通过index的偏移直接计算出响应数据所存储的内存地址，直接通过O(1)即可取得元素。但是链表是通过next引用连接的，每一个Node所在的内存地址是不连续的，我们只能通过next来找到对应的元素。
下面我们来设计一个单向链表
使用了链表的虚拟头节点dummyHead，这样不需要对addFirst()进行特殊处理
package cn.itcats.linkedlist;
public class LinkedList<E> {
//创建内部类Node
private class Node{
public E e;
public Node next;
public Node(E e , Node next){
this.e = e ;
this.next = next;
}
public Node(E e){
this(e,null);
}
public Node(){
this(null,null);
}
@Override
public String toString(){
return e.toString();
}
}
//为链表设置虚拟头结点,则不需要对头结点进行特殊处理
private Node dummyHead;
private int size;
public LinkedList(){
dummyHead = new Node(null,null);
size = 0;
}
//获得链表中元素个数
public int getSize(){
return size;
}
//判断链表是否为空
public boolean isEmpty(){
return size == 0 ;
}
//在链表的index位置添加新元素e
public void add(int index ,E e){
//对index进行判断
if(index < 0 && index > size){
throw new IllegalArgumentException("index不合法");
}
Node prev = dummyHead;
//当遍历到插入索引的前一个索引
for(int i = 0 ;i < index ; i++){
//prev指向下一个元素(index)
prev = prev.next;
}
// Node node = new Node(e);
// node.next = prev.next;
// prev.next = node;
prev.next = new Node(e,prev.next);
size ++ ;
}
//获取链表中指定"索引"的元素,所谓索引,只不过是遍历位置的次数而已
public E get(int index){
if(index < 0 || index >= size){
throw new IllegalArgumentException("index不合法");
}
//从dummyHead的下一个节点遍历
Node cur = dummyHead.next;
for(int i = 0 ; i < index ; i++){
cur = cur.next;
}
return cur.e;
}
//获取链表中的第一个元素
public E getFirst(){
return get(0);
}
//获取链表中的最后一个元素
public E getLast(){
return get(size-1);
}
//修改链表中第index个位置的元素为e
public void set(int index, E e){
if(index < 0 || index >= size){
throw new IllegalArgumentException("index不合法");
}
//找到第index位置的元素
Node cur = dummyHead.next;
for(int i = 0 ; i < index ; i++){
cur = cur.next;
}
cur.e = e;
}
//查找链表中是否存在元素e
public boolean contains(E e){
Node cur = dummyHead.next;
while(cur != null){
if(cur.e.equals(e)){
return true;
}
cur = cur.next;
}
return false;
}
/**
* 在链表头部添加新的元素
*/
public void addFirst(E e){
add(0,e);
}
//在链表尾部添加元素
public void addLast(E e){
add(size,e);
}
//删除节点
public E remove(int index){
if(index < 0 || index >= size){
throw new IllegalArgumentException("index不合法");
}
Node prev = dummyHead;
for(int i = 0 ; i < index ;i++){
//prev此时指向的是被删除节点的前一个位置
prev = prev.next;
}
//需要被删除的节点
Node removeNode = prev.next;
prev.next = removeNode.next;
removeNode.next = null;
size --;
return removeNode.e;
}
//从链表中删除第一个元素,返回删除的元素
public E removeFirst(){
return remove(0);
}
//从链表中删除最后一个元素,返回删除的元素
public E removeLast(){
return remove(size -1);
}
//遍历链表
@Override
public String toString(){
StringBuilder sb = new StringBuilder();
for(Node cur = dummyHead.next ; cur != null ; cur = cur.next)
sb.append(cur+" -->");
sb.append("NULL");
return sb.toString();
}
}
测试方法
package cn.itcats.linkedlist;
public class Test {
public static void main(String[] args) {
LinkedList<Integer> linked = new LinkedList<>();
for(int i = 0 ; i < 5 ; i++){
linked.addFirst(i);
System.out.println(linked);
}
linked.add(2,111);
System.out.println(linked);
linked.remove(3);
System.out.println(linked);
}
}
链表的时间复杂度分析
添加操作：
addLast(e) O(n)
addFirst(e) O(1)
add(index,e) O(n)
删除操作：
removeLast(e) O(n)
removeFirst(e) O(1)
add(index,e) O(n)
修改操作 set(index,e) O(n)
查找操作
get(index) O(n)
contains(e) O(n)