数据结构中的链表

链表 Linked List

1. 链表是一种真正的动态数据结构
2. 最简单的动态数据结构
3. 更深入的理解引用
4. 更深入的理解递归
5. 辅助组成其他数据结构
6. 数据存储在结点中
7. 结点对象包括元素e和数据引用next

• 链表结构
  
  实现真正的动态，不需要处理固定容量的问题，但丧失了随机访问的能力。

链表和数组的对比

数据结构	适用范围	优点
链表	不适合用于索引有语意的情况	动态
数组	最好用于索引有语意的情况	支持快速查询

添加元素

• 头部添加元素
  
• 中间添加元素
  

找到待添加节点的前一个结点

• 代码实现

public class LinkedList<E> {
		//初始化元素结点类
    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);
        }
    }
    private Node head;//创建头结点
    private int size;
    public LinkedList(){
        head = null;//初始化头结点
        size = 0;
    }
    // 在链表头添加新的元素e
    public void addFirst(E e){
       Node node = new Node(e);//创建一个结点
       node.next = head;//将头指向新的结点
       head = node;//并将新的节点标记为头结点
       size++;//增加链表长度
    }
    //在链表中添加元素
     public void add(int index, E e){
        if(index < 0 || index > size)
            throw new IllegalArgumentException("Add failed. Illegal index.");
        if(index == 0)//若是头部添加则调用前面方法
            addFirst(e);
        else{
            Node prev = head;
            for(int i = 0 ; i < index - 1 ; i ++)
                prev = prev.next;//循环遍历，找到要插入元素前一个位置的元素结点
           Node node = new Node(e);//创建要插入元素结点
           node.next = prev.next;
           prev.next = node;
           size ++;
        }
    }
}

获取更新元素

• 代码实现

public E get(int index){
        Node cur = dummyHead.next;
        for(int i = 0 ; i < index ; i ++)
            cur = cur.next;//查找对应结点
        return cur.e;//返回结点元素
    }
 //更新类似

删除元素

• 代码实现

 public E remove(int index){
        Node prev = dummyHead;
        for(int i = 0 ; i < index ; i ++)
            prev = prev.next;
        Node retNode = prev.next;
        prev.next = retNode.next;
        retNode.next = null;
        size --;
        return retNode.e;
    }

链表的时间复杂度分析

操作	时间复杂度
addLast(e)	O(n)
addFirst(e)	O(1)
add(index,e)	O(n/2)=O(n)
removeLast(e)	O(n)
removeFirst(e)	O(1)
removeElement(index,e)	O(n/2)=O(n)
set(index,e)	O(n)
get(index)	O(n)
增	O(n)
删	O(n)
改	O(n)
查	O(n)