Java容器-LinkedList

LinkedList简介

　　LinkedList是基于双向链表实现的。链表是一种递归的数据结构，它或者为空(null)，或者指向一个节点(node)的引用，该节点含有一个泛型的元素和一个指向另一条链表的引用，而双向链表的节点内含有两个指向另一条链表的引用。

用嵌套类定义节点

 1  private class Node<E>{
 2         E item;
 3         Node<E> next;
 4         Node<E> prev;
 5         Node( Node<E> prev,E item,Node<E> next){
 6             this.prev = prev;
 7             this.item = item;
 8             this.next = next;
 9         }
10 
11     }

LinkedList的构造函数

　　LinkedList有两个构造函数，一个是无参数的构造函数，另一个是Collection类型的构造函数。

对双向链表的基本操作

　　在头，尾添加元素。

 1 private void linkFirst(E e) {
 2         final Node<E> f = first;
 3         final Node<E> newNode = new Node<>(null, e, f);
 4         first = newNode;
 5         if (f == null)
 6             last = newNode;
 7         else
 8             f.prev = newNode;
 9         size++;
10     }
11 
12     void linkLast(E e) {
13         final Node<E> l = last;
14         final Node<E> newNode = new Node<>(l, e, null);
15         last = newNode;
16         if (l == null)
17             first = newNode;
18         else
19             l.next = newNode;
20         size++;
21     }

　　在头，尾删除元素。

 1  private E unlinkFirst(Node<E> f) {
 2         final E element = f.item;
 3         final Node<E> next = f.next;
 4         f.item = null;
 5         f.next = null; 
 6         first = next;
 7         if (next == null)
 8             last = null;
 9         else
10             next.prev = null;
11         size--;
12         return element;
13     }
14 
15     private E unlinkLast(Node<E> l) {
16         final E element = l.item;
17         final Node<E> prev = l.prev;
18         l.item = null;
19         l.prev = null; 
20         last = prev;
21         if (prev == null)
22             first = null;
23         else
24             prev.next = null;
25         size--;
26         return element;
27     }

　　删除任意位置元素。

 1  E unlink(Node<E> x) {
 2         final E element = x.item;
 3         final Node<E> next = x.next;
 4         final Node<E> prev = x.prev;
 5 
 6         if (prev == null) {
 7             first = next;
 8         } else {
 9             prev.next = next;
10             x.prev = null;
11         }
12 
13         if (next == null) {
14             last = prev;
15         } else {
16             next.prev = prev;
17             x.next = null;
18         }
19 
20         x.item = null;
21         size--;
22         return element;
23     }

　　查找指定位置元素。

 1  Node<E> node(int index) {
 2         if (index < (size >> 1)) {
 3             Node<E> x = first;
 4             for (int i = 0; i < index; i++)
 5                 x = x.next;
 6             return x;
 7         } else {
 8             Node<E> x = last;
 9             for (int i = size - 1; i > index; i--)
10                 x = x.prev;
11             return x;
12         }
13     }

　　由以上基本操作可以写出我们常用的方法，就不在这里多说。如果有不明白的推荐一本书《算法》第4版。书中第一章1.33小节详细讲述了链表。

　　如有不对之处，欢迎留言指正！

 

转载于:https://www.cnblogs.com/tryinglove/p/7862483.html