双向链表(LinkedList)_linkelist的底层是双向链表吗

什么是链表？
链表是一系列结点组成，这些结点不必再内存中相连。每一个结点均含有表元素和到包含该元素后继元素的结点的链。我们称该链为next链，最后一个结点的next链为null
链表的结构如下图所示

链表的删除和插入
删除：

插入：

从上面的图可以看出，向链表中插入或者从链表中删除某一项元素，不需要移动很多项，只需要改变常数个结点的next链即可。
所以链表的删除和添加元素操作真正耗时的部分是：找到指定索引的结点。这需要我们从第一个结点开始遍历，find(i)的时间为O(i)

双向链表
如果我们在表的第一项处插入或者删除元素该操作花费的时间为常数，但是如果我们需要在最后一项插入或者删除元素这是一个花费时间为O(N)的操作。
我们可以用双向链表来解决这个问题。双向链表的每一个结点都有一条指向其后继结点的next链和一条指向其前结点的pre链。双向链表既可以从第一项开始遍历也可以从最后一项开始往前遍历，双向链表可以用下图表示


双向链表的插入和删除
插入：

删除：

下面给出双链表的具体实现代码

import java.util.Iterator;
 
public class MyLinkedList<T> implements Iterable<T>
{
	
	private int size;
	private Node<T> beginMarker;
	private Node<T> endMarker;
	
	private static class Node<T>
	{
		public T data;
		public Node<T> pre;
		public Node<T> next;
		
		public Node(T data,Node<T> pre,Node<T> next)
		{
			this.data=data;
			this.pre=pre;
			this.next=next;
		}
	}
	
	public MyLinkedList()
	{
		clear();
	}
	
	public void clear()
	{
		beginMarker=new Node<T>(null,null,null);
		endMarker=new Node<T>(null,beginMarker,null);
		beginMarker.next=endMarker;
		size=0;
	}
	
	public int size()
	{
		return size;
	}
	
	public boolean isEmpty()
	{
		return size==0;
	}
	
	public void add(T x)
	{
		add(size(), x);
	}
	
	public void add(int idx,T x)
	{
		addBefore(getNode(idx), x);
	}
	
	public void remove(int idx)
	{
		Node<T> p=getNode(idx);
		p.pre.next=p.next;
		p.next.pre=p.pre;
		size--;
	}
	
	public T get(int idx)
	{
		if(idx<0 || idx>=size())
		{
			throw new IndexOutOfBoundsException();
		}
		return getNode(idx).data;
	}
	
	public void set(int idx,T x)
	{
		getNode(idx).data=x;
	}
	
	private void addBefore(Node<T> p,T x)
	{
		Node<T> newNode=new Node<T>(x, p.pre, p);
		p.pre.next=newNode;
		p.pre=newNode;
		size++;
	}
	
	private Node<T> getNode(int idx)//耗时操作
	{
	
		Node<T> p;
		if(idx<0 || idx>size())
		{
			throw new IndexOutOfBoundsException();
		}
		
		if(idx<size/2)
		{
			p=beginMarker;
			for (int i = 0; i <= idx; i++)
			{
				p=p.next;
			}
			
		}
		else 
		{
			p=endMarker;
			for (int i = size(); i >idx; i--)
			{
				p=p.pre;
			}
		}
		
		return p;		
	}
//下面的代码是为了能够遍历该链表
	@Override
	public Iterator<T> iterator()
	{
		return new MyIterator();
	}
	private class MyIterator implements Iterator<T>{
 
		
		private Node<T> current=beginMarker.next;
		
		@Override
		public boolean hasNext()
		{
			return current!=endMarker;
		}
 
		@Override
		public T next()
		{
			T nextItem=current.data;
			current=current.next;
			return nextItem;
		}
 
		@Override
		public void remove()
		{
			//我这里只需要遍历功能，remove不需要重写
		}
	}
 
	
}

测试代码：

public class Test2
{
	public static void main(String[] args)
	{
		MyLinkedList<Integer> list=new MyLinkedList<Integer>();
		for (int i = 0; i < 10; i++)
		{
			list.add(i*i);
		}
		for(Integer data : list)
		{
			System.out.print(data+" ");
		}
		list.remove(6);
		System.out.println();
		for(Integer data : list)
		{
			System.out.print(data+" ");
		}
		list.set(7, 2015);
		System.out.println();
		for(Integer data : list)
		{
			System.out.print(data+" ");
		}
		System.out.println();
		System.out.println(list.get(6));
		
	}
 
}

输出：
0 1 4 9 16 25 36 49 64 81 
0 1 4 9 16 25 49 64 81 
0 1 4 9 16 25 49 2015 81 
49