2018年10月25日
由于数组需要一块连续的内存空间，所以插入和删除时会使部分元素挪动，其时间复杂度为 
，为了避免这种开销，可以使用链表这种不连续内存的数据结构。数组和链表的内存分布：
1，单链表
链表是由一系列的节点组成，对于单链表而言，每个节点除了存储元素外，还要存储指向下一个节点的地址，称之为next；最后一个节点的next指向NULL：
向链表中插入元素，如向 
与
之间插入节点X，首先将的next指向X，然后将X指向：
删除链表中的元素，如删除，那么就将的next指向
：
由此可见，链表的插入和删除操作，只需考虑相邻节点指针的改变，因此其时间复杂度均为
。但是，在链表中随机访问某个位置的元素就不如数组高效了，只能从头开始遍历，直至找到所需的节点，因此其随机访问的时间复杂度为。
2，双向链表
prev，
prev指向前一个节点，
next指向后一个节点。
向链表中插入元素，如在A节点与B节点之间插入节点X，首先将A节点的next指向X节点，X节点的prev指向A节点；然后将X节点的next指向B节点，B节点的prev指向X：
删除链表中的元素，如删除元素B，那么首先将A节点的next指向B节点的下一个节点即C节点，再将C节点的prev指向A节点：
3，容器
JAVA中的LinkedList容器就是使用双向链表实现的，其结构如下：
Queue和
Deque接口，因此可以把其当做队列或双端队列来使用，同时也可以将其当做栈来使用。
使用LinkedList时，需要注意的是，当需要删除某些特定元素时，使用迭代器中的remove方法会更节省时间；例如，删除集合中的偶数，常规操作如下：
int i = 0;
while (i < list.size()) {
if (list.get(i) % 2 == 0) {
list.remove(i);
} else {
i++;
}
}
复制代码因为get和remove都需要遍历集合，因此时间复杂度为，而while循环也需要N次，因此总的时间复杂度为
。
使用迭代器中的remove：
Iterator<Integer> iterator = list.iterator();
while (iterator.hasNext()) {
if (iterator.next() % 2 == 0) {
iterator.remove();
}
}
复制代码因为要删除的元素正好是迭代器所指向的前一个元素，由于链表的特性将其直接删除只需花费时间，while循环需要N次，那么总的时间复杂度为。
，验证一下：
class TestLinkedList {
public static void main(String[] args) {
System.out.printf("输入规模 \t自带remove方法 \t迭代器中remove方法 \n");
for (int n = 100; n <= 1000000; n *= 10) {
System.out.print(String.format("N=%7d", n));
for (int alg = 0; alg <= 1; alg++) {
getTimingInfo(n, alg);
}
System.out.println();
}
}
private static void getTimingInfo(int n, int alg) {
LinkedList<Integer> list;
Random random=new Random();
long startTime = System.currentTimeMillis();
long totalTime = 0;
int k;
for (k = 0; totalTime < 4000; k++) {
list = new LinkedList<>();
for (int j = 0; j <n; j++) {
list.add(random.nextInt(n));
}
if (alg == 0) {
int i = 0;
while (i < list.size()) {
if (list.get(i) % 2 == 0) {
list.remove(i);
} else {
i++;
}
}
} else if (alg == 1) {
Iterator<Integer> iterator = list.iterator();
while (iterator.hasNext()) {
if (iterator.next() % 2 == 0) {
iterator.remove();
}
}
}
totalTime = System.currentTimeMillis() - startTime;
}
System.out.print(String.format("\t%12.6f", (totalTime * 1000 / k) / (double) 1000000));
}
}
复制代码remove方法所消耗的时间确实是以平方级增长的，而迭代器中的
remove方法则是以线性增长的。
还需注意的是，在使用迭代器时，不能使用集合中的方法来进行添加和删除的操作，否则会有ConcurrentModificationException异常，看看LinkedList中迭代器部分源码：
private class ListItr implements ListIterator<E> {
private Node<E> lastReturned;
private Node<E> next;
private int nextIndex;
private int expectedModCount = modCount;
public boolean hasNext() {
return nextIndex < size;
}
public E next() {
checkForComodification();
if (!hasNext())
throw new NoSuchElementException();
lastReturned = next;
next = next.next;
nextIndex++;
return lastReturned.item;
}
public void remove() {
checkForComodification();
if (lastReturned == null)
throw new IllegalStateException();
Node<E> lastNext = lastReturned.next;
unlink(lastReturned);
if (next == lastReturned)
next = lastNext;
else
nextIndex--;
lastReturned = null;
expectedModCount++;
}
复制代码假设集合中有三个元素a,b,c，现在使用迭代器遍历完元素a，那么此时next应返回元素a，其中nextIndex=1，而size=3：
若此时在元素b之前插入元素x，那么此时size=4，但是nextIndex依然为1：
b之后
nextIndex=2，遍历完
c后，应该终止遍历了，但是
nextIndex=3，此时
nextIndex<size，
hasNext进行判断时依然有效，显然，此时调用
next将会返回
NULL，会造成空指针异常。
若此时删除元素a，那么此时size=2，nextIndex=1：
b后，
nextIndex=2与
size相等，此时调用
hasNext会返回
false，但是集合中还有元素
c没有被遍历到。
而迭代器中添加和删除操作会对nextIndex以及其他属性进行调整，因此，在使用迭代器时，应使用迭代器中的方法进行添加或删除操作。
4，LinkedList的简单实现
public class MyLinkedList<AnyType> implements Iterable<AnyType> {
private int theSize;
private int modCount = 0;
private Node<AnyType> beginMarker;
private Node<AnyType> endMarker;
private static class Node<AnyType> {
public AnyType data;
public Node<AnyType> prev;
public Node<AnyType> next;
public Node(AnyType data, Node<AnyType> prev, Node<AnyType> next) {
this.data = data;
this.prev = prev;
this.next = next;
}
}
public MyLinkedList() {
doClear();
}
public void clear() {
doClear();
}
private void doClear() {
beginMarker = new Node<>(null, null, null);
endMarker = new Node<>(null, beginMarker, null);
beginMarker.next = endMarker;
theSize = 0;
modCount++;
}
public int size() {
return theSize;
}
public boolean isEmpty() {
return size() == 0;
}
public boolean add(AnyType element) {
add(size(), element);
return true;
}
public void add(int index, AnyType element) {
addBefore(getNode(index, 0, size()), element);
}
private void addBefore(Node<AnyType> p, AnyType element) {
Node<AnyType> newNode = new Node<>(element, p.prev, p);
newNode.prev.next = newNode;
p.prev = newNode;
theSize++;
modCount++;
}
public AnyType get(int index) {
return getNode(index).data;
}
public AnyType set(int index, AnyType newVal) {
Node<AnyType> p = getNode(index);
AnyType oldVal = p.data;
p.data = newVal;
return oldVal;
}
private Node<AnyType> getNode(int index) {
return getNode(index, 0, size() - 1);
}
private Node<AnyType> getNode(int index, int lower, int upper) {
Node<AnyType> p;
if (index < lower || index > upper) {
throw new IndexOutOfBoundsException("getNode index: " + index + "; size: " + size());
}
if (index < size() / 2) {
p = beginMarker.next;
for (int i = 0; i < index; i++) {
p = p.next;
}
} else {
p = endMarker;
for (int i = size(); i > index; i--) {
p = p.prev;
}
}
return p;
}
public AnyType remove(int index) {
return remove(getNode(index));
}
private AnyType remove(Node<AnyType> p) {
p.next.prev = p.prev;
p.prev.next = p.next;
theSize--;
modCount++;
return p.data;
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder("[ ");
for (AnyType element : this) {
sb.append(element + " ");
}
sb.append("]");
return sb.toString();
}
@Override
public Iterator<AnyType> iterator() {
return new LinkedListIterator();
}
private class LinkedListIterator implements Iterator<AnyType> {
private Node<AnyType> current = beginMarker.next;
private int expectedModCount = modCount;
private boolean okToRemove = false;
@Override
public boolean hasNext() {
return current != endMarker;
}
@Override
public AnyType next() {
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
if (!hasNext()) {
throw new NoSuchElementException();
}
AnyType nextElement = current.data;
current = current.next;
okToRemove = true;
return nextElement;
}
@Override
public void remove() {
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
if (!okToRemove) {
throw new IllegalStateException();
}
MyLinkedList.this.remove(current.prev);
expectedModCount++;
okToRemove = false;
}
}
}
复制代码5，比较
| 时间复杂度 | 数组 | 链表 |
|---|---|---|
| 插入删除 | | |
| 随机访问 | | |
数组使用连续空间，因此可以很容易计算其中某个元素的地址，实现常数级的随机访问，这也是数组的一个缺点，使用连续空间那么其大小要是固定的，并且一经申明就不可以更改，若申明过大，一是系统可能没有足够的连续内存，二是若用不了这么多空间，会造成浪费；即使ArrayList支持动态扩容，若此时已经存储了1GB的数据，而且没有多余的空间了，就要扩容至1.5GB，并把之前的1GB数据拷贝过来，会非常的耗时。
但是，如果对内存的使用比较苛刻，那么久适合使用数组，因为链表中每个节点都需要消耗额外的空间去存储next和prev。对链表进行频繁的插入和删除时，会频繁的造成内存的申请和释放，容易造成内存碎片，在JAVA中，还会造成频繁的GC。
扫一扫
5897
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
