LinkList(双向链表实现)

linkedlist是用链表结构存储数据的，比较适合数据的动态插入和删除，随机访问和遍历速度比较慢，还提供了list接口i中没有定义的方法，专门用于操作表头和表尾的元素，所以可以当作堆栈、队列和双向队列来使用。linkedlist持有头节点和尾节点的引用，有两个构造器，一个是无参构造器，另一个是传入外部集合构造器，它没有像arraylist一样的初始大小的构造器。

  1 //集合元素个数
  2 
  3 transient int size = 0;
  4 
  5  
  6 
  7 //头结点引用
  8 
  9 transient node<e> first;
 10 
 11  
 12 
 13 //尾节点引用
 14 transient node<e> last;
 15 
 16 //无参构造器
 17 public linkedlist() {} 
 18 
 19 //传入外部集合的构造器
 20 public linkedlist(collection<? extends e> c) {
 21     this();
 22     addall(c);
 23 }
 24 
 25 //增(添加)
 26 public boolean add(e e) {
 27   
 28      //在链表尾部添加
 29     linklast(e);
 30     return true;
 31 }
 32 
 33  
 34 //增(插入)
 35 public void add(int index, e element) {
 36 
 37     checkpositionindex(index);
 38 
 39     if (index == size) {
 40         //在链表尾部添加
 41         linklast(element);
 42     } else {
 43         //在链表中部插入
 44         linkbefore(element, node(index));
 45     }
 46 }
 47 
 48  
 49 
 50 //删(给定下标)
 51 public e remove(int index) {
 52 
 53     //检查下标是否合法
 54     checkelementindex(index);
 55     return unlink(node(index));
 56 }
 57 
 58 //删(给定元素)
 59 public boolean remove(object o) {
 60     if (o == null) {
 61         for (node<e> x = first; x != null; x = x.next) {
 62             if (x.item == null) {
 63                 unlink(x);
 64                 return true;
 65             }
 66         }
 67     } else {
 68         //遍历链表
 69         for (node<e> x = first; x != null; x = x.next) {
 70             if (o.equals(x.item)) {
 71                 //找到了就删除
 72                 unlink(x);
 73                 return true;
 74             }
 75         }
 76     }
 77     return false;
 78 }
 79 
 80  
 81 
 82 //改
 83 public e set(int index, e element) {
 84 
 85     //检查下标是否合法
 86     checkelementindex(index);
 87 
 88     //获取指定下标的结点引用
 89     node<e> x = node(index);
 90 
 91     //获取指定下标结点的值
 92 
 93     e oldval = x.item;
 94 
 95     //将结点元素设置为新的值
 96 
 97     x.item = element;
 98 
 99     //返回之前的值
100 
101     return oldval;
102 
103 }
104 
105 
106 //查
107 public e get(int index) {
108 
109     //检查下标是否合法
110     checkelementindex(index);
111 
112     //返回指定下标的结点的值
113     return node(index).item;
114 }

 

linkedlist的添加元素的方法主要是调用linklast和linkbefore两个方法，linklast方法是在链表后面链接一个元素，linkbefore方法是在链表中间插入一个元素。linkedlist的删除方法通过调用unlink方法将某个元素从链表中移除。下面是链表的插入和删除操作的核心代码。

 1 //链接到指定结点之前
 2 void linkbefore(e e, node<e> succ) {
 3 
 4     //获取给定结点的上一个结点引用
 5     final node<e> pred = succ.prev;
 6 
 7     //创建新结点, 新结点的上一个结点引用指向给定结点的上一个结点
 8     //新结点的下一个结点的引用指向给定的结点
 9     final node<e> newnode = new node<>(pred, e, succ);
10 
11     //将给定结点的上一个结点引用指向新结点
12     succ.prev = newnode;
13 
14     //如果给定结点的上一个结点为空, 表明给定结点为头结点
15     if (pred == null) {
16 
17         //将头结点引用指向新结点
18         first = newnode;
19     } else {
20         //否则, 将给定结点的上一个结点的下一个结点引用指向新结点
21         pred.next = newnode;
22     }
23 
24     //集合元素个数加一
25     size++;
26 
27     //修改次数加一
28     modcount++;
29 
30 }
31 
32  
33 
34 //卸载指定结点
35 e unlink(node<e> x) {
36 
37     //获取给定结点的元素
38     final e element = x.item;
39 
40     //获取给定结点的下一个结点的引用
41     final node<e> next = x.next;
42 
43     //获取给定结点的上一个结点的引用
44     final node<e> prev = x.prev;
45 
46     //如果给定结点的上一个结点为空, 说明给定结点为头结点
47     if (prev == null) {
48 
49         //将头结点引用指向给定结点的下一个结点
50         first = next;
51     } else {
52         //将上一个结点的后继结点引用指向给定结点的后继结点
53         prev.next = next;
54         //将给定结点的上一个结点置空
55         x.prev = null;
56 
57     }
58 
59     //如果给定结点的下一个结点为空, 说明给定结点为尾结点
60     if (next == null) {
61 
62         //将尾结点引用指向给定结点的上一个结点
63         last = prev;
64     } else {
65 
66         //将下一个结点的前继结点引用指向给定结点的前继结点
67         next.prev = prev;
68         x.next = null;
69 
70     }
71 
72     //将给定结点的元素置空
73     x.item = null;
74 
75     //集合元素个数减一
76     size--;
77     //修改次数加一
78     modcount++;
79     return element;
80 
81 }

通过源码的分析，对链表的插入和删除的时间复杂度都是o(1)，而对链表的查找和修改操作都需要遍历链表进行元素的定位，这两个操作都是调用的node(int index) 方法定位元素，如下代码演示根据下标来定位元素。

 1 //根据指定位置获取结点
 2 node<e> node(int index) {
 3     //如果下标在链表前半部分, 就从头开始查起
 4     if (index < (size >> 1)) {
 5         node<e> x = first;
 6         for (int i = 0; i < index; i++) {
 7             x = x.next;
 8         }
 9         return x;
10     } else {
11         //如果下标在链表后半部分, 就从尾开始查起
12         node<e> x = last;
13         for (int i = size - 1; i > index; i--) {
14             x = x.prev;
15         }
16         return x;
17     }
18 }

通过下标定位时先判断是在链表的上半部还是下半部

上半部：从头开始找；

下半部：从尾开始找；

因此通过下标的查找和修改操作的时间复杂度是o(n/2)，通过对双向链表的操作还可以实现单项队列，双向队列和栈的功能。

单向队列的操作的代码：

 1 //获取头结点
 2 public e peek() {
 3     final node<e> f = first;
 4     return (f == null) ? null : f.item;
 5 }
 6  
 7 //获取头结点
 8 public e element() {
 9     return getfirst();
10 }
11  
12 //弹出头结点
13 public e poll() {
14     final node<e> f = first;
15     return (f == null) ? null : unlinkfirst(f);
16 }
17  
18 //移除头结点
19 public e remove() {
20     return removefirst();
21 }
22  
23 //在队列尾部添加结点
24 public boolean offer(e e) {
25     return add(e);
26 }

双向队列的操作：

 1 //在头部添加
 2 public boolean offerfirst(e e) {
 3     addfirst(e);
 4     return true;
 5 }
 6  
 7 //在尾部添加
 8 public boolean offerlast(e e) {
 9     addlast(e);
10     return true;
11 }
12  
13 //获取头结点
14 public e peekfirst() {
15     final node<e> f = first;
16     return (f == null) ? null : f.item;
17  }
18  
19 //获取尾结点
20 public e peeklast() {
21     final node<e> l = last;
22     return (l == null) ? null : l.item;
23 }

栈操作：

1 //入栈
2 public void push(e e) {
3     addfirst(e);
4 }
5  
6 //出栈
7 public e pop() {
8     return removefirst();
9 }

对lindedlist，有：

1. linkedlist是基于双向链表实现的，不论是增删改查方法还是队列和栈的实现，都可通过操作结点实现

2. linkedlist无需提前指定容量，因为基于链表操作，集合的容量随着元素的加入自动增加

3. linkedlist删除元素后集合占用的内存自动缩小，无需像arraylist一样调用trimtosize()方法

4. linkedlist的所有方法没有进行同步，因此它也不是线程安全的，应该避免在多线程环境下使用

5. 以上分析基于jdk1.7，其他版本会有些出入，因此不能一概而论

以上内容部分借鉴于：https://blog.csdn.net/iteen/article/details/83109717