java手动实现双向链表LinkedList

一、LinkedList原理介绍

LinkedList是java中重要的List集合，其内部是一个双向链的数据结构。插入和删除的效率比ArrayList高,之前手动实现的ArrayList，因为插入和删除没有数组的复制工作，如果想在下标为index位置插入元素则通过从头部或者尾部开始查找，找到index原始位置的元素，则修改原始位置index元素的Node中的上一个元素，以及元素index元素前一个元素Node的下一个元素。只需要修改两个元素就可以实现元素的插入。(List元素越大则LinkedList插入/删除的效率相比ArrayList)会更好。

二、LinkedList实现代码

package list;

import java.util.NoSuchElementException;

/**
* 实现一个双向链表
* @author ocean
*
*/
public class MyLinkedList<E> {
private int size;

private Node<E> firstNode;

private Node<E> lastNode;

private class Node<E>{
private E item;
private Node<E> preNode;
private Node<E> nextNode;
public Node(E item, Node<E> preNode, Node<E> nextNode) {
this.item = item;
this.preNode = preNode;
this.nextNode = nextNode;
}
}

/**
* 根据下标获取元素
* @param index
* @return
*/
public E get(int index) {
//数组越界
if(!checkElementIndex(index)) {
throw new IndexOutOfBoundsException();
}
return getNode(index).item;
}

/**
* 尾部追加一个元素
* @param e
* @return
*/
public boolean add(E e) {
linkedLast(e);
return true;
}
/**
* 头部插入一个元素
* @param e
* @return
*/
public boolean addFirst(E e) {
linedFirst(e);
return true;
}

/**
* 向下标index插入元素
* @param index
* @param e
* @return
*/
public boolean add(int index,E e) {
if(index==size) {
linkedLast(e);
}else {
addBefore(index, e);
}
return true;
}

/**
* 根据下标删除元素
* @param index
* @return
*/
public E remove(int index) {
return unlink(getNode(index));
}

/**
* 删除第一个元素
* @return
*/
public E removeFirst() {
return unlinkFirst();
}

public E removeLast() {
return unlinkLast();
}

E unlinkLast() {
Node<E> l = lastNode;
if(l == null) {
throw new NoSuchElementException();
}
E element = l.item;
Node<E> pre = l.preNode;
l.item = null;//help gc
l.preNode = null;//help gc
if(pre == null) {
firstNode = null;
}else {
lastNode = pre;
}
size --;
return element;
}

E unlinkFirst() {
Node<E> f = firstNode;
if(f == null) {
throw new NoSuchElementException();
}
E element = f.item;
Node<E> next = f.nextNode;
f.item = null;
f.nextNode = null;
if(next == null) {
lastNode = null;
}
firstNode = next;
size --;
return element;
}

/**
* 向链表尾部插入元素
* @param e
*/
void linkedLast(E e) {
Node<E> x = lastNode;
Node<E> newNode = new Node<>(e, x, null);
lastNode = newNode;
if(x ==null) {
firstNode = newNode;
}else {
x.nextNode = newNode;
}
size ++;
}

/**
* 向链表头部插入元素
* @param e
*/
void linedFirst(E e) {
Node<E> x = firstNode;
Node<E> newNode = new Node<>(e, null, x);
if(x ==null) {
firstNode = newNode;
}else {
firstNode.preNode = newNode;
}
size ++;
}

/**
* 向下标index插入元素
* @param index
* @param e
*/
void addBefore(int index, E e) {
if(!checkElementIndex(index)) {
throw new IndexOutOfBoundsException();
}
Node<E> oldNode = getNode(index);
Node<E> preNode = oldNode.preNode;
Node<E> newNode = new Node<>(e, preNode, oldNode);
if(preNode ==null) {
firstNode = newNode;
}else {
preNode.nextNode = newNode;
}
size ++;
}

private Node<E> getNode(int index) {
if(index > (size>>1)) {//从尾部开始查询(二分查找思想)
Node<E> result = lastNode;
for(int i=size-1;i>index;i--) {
result = result.preNode;
}
return result;
}else {//从首部开始查询
Node<E> result = firstNode;
for(int i=0;i<index;i++) {
result = result.nextNode;
}
return result;
}
}

private E unlink(Node<E> e) {
E element = e.item;
Node<E> preNode = e.preNode;
Node<E> nextNode = e.nextNode;
if(preNode ==null) {
firstNode = nextNode;
}else {
preNode.nextNode = nextNode;
e.preNode = null;
}

if(nextNode==null) {
lastNode = preNode;
}else {
nextNode.preNode = preNode;
e.nextNode = null;
}
e.item = null;
size --;
return element;
}

private boolean checkElementIndex(int index) {
if(index <0 || index >=size) {
return false;
}
return true;
}

public static void main(String[] args) {
MyLinkedList<String> myList = new MyLinkedList<String>();
myList.add("String1");
myList.add("String2");
myList.add("String3");
myList.add("String4");
myList.add("String5");
myList.add("String6");
myList.add("String7");
myList.add(3, "2222222222222");
for(int i=0;i<myList.size;i++) {
System.out.println(myList.get(i));
}
System.out.println("===========开始删除下标为3的元素===========");
myList.remove(3);
for(int i=0;i<myList.size;i++) {
System.out.println(myList.get(i));
}
System.out.println("============删除头部元素==========");
myList.removeFirst();
for(int i=0;i<myList.size;i++) {
System.out.println(myList.get(i));
}
System.out.println("==========删除尾部元素============");
myList.removeLast();
for(int i=0;i<myList.size;i++) {
System.out.println(myList.get(i));
}
}
}


三、运行结果
String1

String2

String3

2222222222222

String4

String5

String6

String7

===========开始删除下标为3的元素===========

String1

String2

String3

String4

String5

String6

String7

============删除头部元素==========

String2

String3

String4

String5

String6

String7

==========删除尾部元素============

String2

String3

String4

String5

String6