JAVA数据结构及算法--LinkedList分析

1、之前有写个一个c的双向循环列表，有兴趣的可以参考《c中的双向链表实现》。当时不太明白JAVA的指向问题，所以一直没有写java的双链表实现。C中'->'跟JAVA中‘.’其实是一样的。JAVA中通过赋值的方式来实现指向的问题。下面先看看LinkedList的使用及JAVA类似C中指针的问题。

2、双向循环列表的数据结构如下：

3、从源码LinkedList中提取代码，实现简化版的SimpleLinkedList类，以方便分析。

public class SimpleLinkedList<E> {
	Node<E> first;//指向第一个节点
	Node<E> last;//指向最后一个节点
	int size = 0;//节点的个数，初始化值为0

	private static class Node<E> {
        E item;//主要保存数据
        Node<E> next;//指向下一个节点
        Node<E> prev;//指向上一个节点

        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }
	/**
	 * 从链表的最后一个节点添加新的节点
	 * @param e 要增加的数据
	 * @return 无返回值
	 */
	 public boolean add(E e) {
        linkLast(e);
        return true;
	 }
	 
	 /**
	  * 从指定位置添加一个新的节点
	  * @param index 要插入数据的位置
	  * @param element 需要插入的数据
	  */
	 public void add(int index, E element) {
        checkPositionIndex(index);

        if (index == size)//从尾部插入
            linkLast(element);
        else
            linkBefore(element, node(index));
     }
	 
	 /**
	 * 删除index下标对应的节点
	 * @param index
	 */
	public void remove(int index){
		Node<E> target = node(index);
		unlink(target);
	}
	 /**
	  * 获取下标为index的节点数据 
	  * @param index
	  * @return
	  */
	 public E get(int index) {
        this.checkElementIndex(index);
        return this.node(index).item;
	 }
	
	 /**
	  * 将下标为index节点数据设置成element
	  * @param index 要设置数据的节点下标
	  * @param element 要设置的数据
	  * @return
	  */
	 public E set(int index, E element) {
        checkElementIndex(index);
        Node<E> x = node(index);
        E oldVal = x.item;
        x.item = element;
        return oldVal;
	 }
	    
	public void unlink(Node<E> x) {
	    // assert x != null;
	    final Node<E> next = x.next;
	    final Node<E> prev = x.prev;
	
	    if (prev == null) {//说明链表中没有节点
	        first = next;
	    } else {
	        prev.next = next;
	        x.prev = null;
	    }
	
	    if (next == null) {//说明链表中没有节点
	        last = prev;
	    } else {
	        next.prev = prev;
	        x.next = null;
	    }
	
	    x.item = null;//数据清空
	    size--;
	}
	 
	 /**
	  * 从链表头进行插入节点
	  * @param e 需要插入的数据
	  * @param next 从该节点位置进入插入新的节点
	  */
	 void linkBefore(E e, Node<E> next) {
	        // assert succ != null;
	        final Node<E> pred = next.prev;//这里可以有效解决2个节点间断开链接时指针指向的先后顺序问题
	        final Node<E> newNode = new Node<>(pred, e, next);
	        next.prev = newNode;
	        if (pred == null)//说明链表当前没有节点
	            first = newNode;
	        else
	            pred.next = newNode;
	        
	        size++;
	    }
	 
	 
	 /**
	  * 从链表的最后一个节点添加新的节点
	  * @param e
	  */
	 void linkLast(E e) {
        final Node<E> l = last;
        final Node<E> newNode = new Node<>(l, e, null);
        last = newNode;
        if (l == null)//说明是一个空链表
            first = newNode;
        else
            l.next = newNode;
        size++;
	 }
	 /**
	  * 获取链表节点个数
	  * @return
	  */
	 public int size() {
        return size;
	 }
	 
	
	 
	 /**
	  * 检查下标值的边界
	  * @param index
	  * @return
	  */
	 private boolean isElementIndex(int index) {
        return index >= 0 && index < this.size;
     }
	 /**
	  * 检查index下标边界问题，越界会报异常
	  * @param index
	  */
	 private void checkElementIndex(int index) {
        if(!this.isElementIndex(index)) {
            throw new IndexOutOfBoundsException("index : " + index + " ,size : " + size);
        }
    }
	 /**
	  * 保证index下标在边界之内
	  * @param index
	  * @return
	  */
	 private boolean isPositionIndex(int index) {
        return index >= 0 && index <= size;
     }
	 
	 private void checkPositionIndex(int index) {
        if (!isPositionIndex(index))
            throw new IndexOutOfBoundsException("index : " + index + " ,size : " + size);
    }
	 
	 /**
	  * 找到index对应的节点
	  * @param index 要查找节点的下标
	  * @return 返回index对应的节点
	  */
	 Node<E> node(int index) {

        if (index < (size >> 1)) {//链表的前半部分，size >> 1相当于size/2
            Node<E> x = first;
            for (int i = 0; i < index; i++)//从链表头开始查找
                x = x.next;
            return x;
        } else {//链表的后半部分
            Node<E> x = last;
            for (int i = size - 1; i > index; i--)//从链表尾开始查找
                x = x.prev;
            return x;
        }
    }
}

从代码中的注释可以看出，主要实现了增、删、改的方法。下面添加测试方法：

4、测试代码及测试结果如下：