java数据结构与算法之双链表设计与实现

版权声明：本文为博主原创文章，请尊重原创，未经博主允许禁止转载，保留追究权 https://blog.csdn.net/javazejian/article/details/53047590

转载请注明出处（万分感谢！）： 
http://blog.csdn.net/javazejian/article/details/53047590 
出自【zejian的博客】

关联文章:

java数据结构与算法之顺序表与链表设计与实现分析 
java数据结构与算法之双链表设计与实现 
java数据结构与算法之改良顺序表与双链表类似ArrayList和LinkedList（带Iterator迭代器与fast-fail机制） 
java数据结构与算法之栈（Stack）设计与实现 
java数据结构与算法之队列(Queue)设计与实现 
java数据结构与算法之递归思维(让我们更通俗地理解递归) 
java数据结构与算法之树基本概念及二叉树（BinaryTree）的设计与实现 
java数据结构与算法之平衡二叉查找树(AVL树)的设计与实现

  上一篇文章分析顺序表和单链表，本篇就接着上篇继续聊链表，在单链表分析中，我们可以知道每个结点只有一个指向后继结点的next域，倘若此时已知当前结点p，需要查找其前驱结点，那么就必须从head头指针遍历至p的前驱结点，操作的效率很低，因此如果p有一个指向前驱结点的next域，那效率就高多了，对于这种一个结点中分别包含了前驱结点域pre和后继结点域next的链表，称之为双链表。本篇我们将从以下结点来分析双链表

 

• 双链表的设计与实现
• 循环双链表的设计与实现
• 排序循环双链表的实现
• 双链表的执行效率分析
• 异或高效存储双链表的设计原理概要

 

双链表的设计与实现

  双链表的主要优点是对于任意给的结点，都可以很轻易的获取其前驱结点或者后继结点，而主要缺点是每个结点需要添加额外的next域，因此需要更多的空间开销，同时结点的插入与删除操作也将更加耗时，因为需要更多的指针指向操作。双链表的结构图如下： 

创建HeadDoubleILinkedList类并实现IlinekedList接口(和上篇博文的接口一样)

<span style="color:#333333"><span style="color:#000000"><code><span style="color:#880000">/**
 * Created by zejian on 2016/10/23.
 * 双链表的实现,带头结点(不带数据)的双链表,为了更高的效率该类包含指向尾部的指针tail
 */</span>
<span style="color:#000088">public</span> <span style="color:#000088">class</span> <span style="color:#4f4f4f">HeadDoubleILinkedList</span><<span style="color:#4f4f4f">T</span>> <span style="color:#000088">implements</span> <span style="color:#4f4f4f">ILinkedList</span><<span style="color:#4f4f4f">T</span>> {

    <span style="color:#000088">protected</span> DNode<T> head; <span style="color:#880000">//不带数据的头结点</span>
    <span style="color:#000088">protected</span> DNode<T> tail; <span style="color:#880000">//指向尾部的指针</span>

    <span style="color:#000088">public</span> HeadDoubleILinkedList(){
        <span style="color:#880000">//初始化头结点</span>
        <span style="color:#000088">this</span>.head =<span style="color:#000088">this</span>.tail= <span style="color:#000088">new</span> DNode<>();          
    }
    <span style="color:#880000">//先省略其他代码</span>
    ........
}</code></span></span>

结点类结构如下：

<span style="color:#333333"><span style="color:#000000"><code>package com.zejian.structures.LinkedList.doubleLinked;

<span style="color:#880000">/**
 * Created by zejian on 2016/10/23.
 * 双链表结点
 */</span>
<span style="color:#000088">public</span> <span style="color:#000088">class</span> DNode<T> {

    <span style="color:#000088">public</span> T data;
    <span style="color:#000088">public</span> DNode<T> prev, next;<span style="color:#880000">//前继指针和后继指针</span>
    <span style="color:#000088">public</span> <span style="color:#009900">DNode</span>(T data, DNode<T> prev, DNode<T> next)
    {
        <span style="color:#000088">this</span>.data = data;
        <span style="color:#000088">this</span>.prev = prev;
        <span style="color:#000088">this</span>.next = next;
    }

    <span style="color:#000088">public</span> <span style="color:#009900">DNode</span>(T data)
    {
        <span style="color:#000088">this</span>(data, <span style="color:#000088">null</span>, <span style="color:#000088">null</span>);
    }

    <span style="color:#000088">public</span> <span style="color:#009900">DNode</span>()
    {
        <span style="color:#000088">this</span>(<span style="color:#000088">null</span>, <span style="color:#000088">null</span>, <span style="color:#000088">null</span>);
    }

    <span style="color:#000088">public</span> String <span style="color:#009900">toString</span>()
    {
        <span style="color:#000088">return</span> <span style="color:#000088">this</span>.data.toString();
    }
}</code></span></span>

通过上篇的分析，我们对链表的插入、删除、查找、替换等操作也比较熟悉了，因此针对双链表的实现，主要分析其插入、删除、查找、替换等方法，其他没有分析的看实现源码即可（最后会给出双链表的实现代码）

• 双链表的插入操作分析与实现 
    我们先来看看双链表的插入，虽然有不带数据的头结点，但是由于是双向链表，所以在插入双链表时需分两种情况，一种是在插入空双链表和尾部插入，另一种是双链表的中间插入，如下图在空双链表插入值x： 
  
  从图可以看出（a）和（b）属于同种情况，需要注意front.next != null的情况，否则就会抛空指针，而（c）的情况属于中间插入无需无需理会front.next != null的条件，因为中间插入时无论如何其后继结点时不会为null的，插入方法的实现代码如下：

  <span style="color:#333333"><span style="color:#000000"><code><span style="color:#880000">/**
   * 插入结点
   *<span style="color:#4f4f4f"> @param</span> index
   *<span style="color:#4f4f4f"> @param</span> data
   *<span style="color:#4f4f4f"> @return</span>
   */</span>
  <span style="color:#9b859d">@Override</span>
  <span style="color:#000088">public</span> <span style="color:#000088">boolean</span> <span style="color:#009900">add</span>(<span style="color:#000088">int</span> index, T data) {
      <span style="color:#000088">if</span>(index<<span style="color:#006666">0</span>||data==<span style="color:#000088">null</span>)
          <span style="color:#000088">throw</span> <span style="color:#000088">new</span> NullPointerException(<span style="color:#009900">"index < 0 || data == null"</span>);
  
          <span style="color:#000088">int</span> j = <span style="color:#006666">0</span>;
          DNode<T> front = <span style="color:#000088">this</span>.head;
          <span style="color:#880000">//查找要插入结点位置的前一个结点</span>
          <span style="color:#000088">while</span> (front.next != <span style="color:#000088">null</span> && j < index) {
              j++;
              front = front.next;
          }
  
          <span style="color:#880000">//创建需要插入的结点,并让其前继指针指向front,后继指针指向front.next</span>
          DNode<T> q = <span style="color:#000088">new</span> DNode<T>(data, front, front.next);
  
          <span style="color:#880000">//空双链表插入和尾部插入，无需此操作</span>
          <span style="color:#000088">if</span>(front.next != <span style="color:#000088">null</span>) {
              <span style="color:#880000">//更改front.next的前继指针</span>
              front.next.prev = q;
          }
          <span style="color:#880000">//更改front的后继指针</span>
          front.next = q;
  
          <span style="color:#880000">//在尾部插入时需要注意更新tail指向</span>
          <span style="color:#000088">if</span>(front==<span style="color:#000088">this</span>.tail){
              <span style="color:#000088">this</span>.tail=q;
          }
          <span style="color:#000088">return</span> <span style="color:#000088">true</span>;
  }</code></span></span>

•  

• 双链表的查值操作分析与实现 
  双链表的查找值的操作与单链表并没有什么区别，只要找到需要查找的当前结点获取其值即可，如下： 
  
  代码实现如下：

  <span style="color:#333333"><span style="color:#000000"><code><span style="color:#9b859d">@Override</span>
  <span style="color:#000088">public</span> T <span style="color:#009900">get</span>(<span style="color:#000088">int</span> index) {
      <span style="color:#000088">if</span> (index>=<span style="color:#006666">0</span>)
      {
          <span style="color:#000088">int</span> j=<span style="color:#006666">0</span>;
          <span style="color:#880000">//注意起始结点为this.head.next</span>
          <span style="color:#880000">//如果起始点为this.head时，j的判断为j<=index，</span>
          <span style="color:#880000">//因为需要寻找的是当前结点而不是前一个结点。</span>
          DNode<T> pre=<span style="color:#000088">this</span>.head.next;
          <span style="color:#000088">while</span> (pre!=<span style="color:#000088">null</span> && j<index)
          {
              j++;
              pre=pre.next;
          }
          <span style="color:#000088">if</span> (pre!=<span style="color:#000088">null</span>)
              <span style="color:#000088">return</span> pre.data;
      }
      <span style="color:#000088">return</span> <span style="color:#000088">null</span>;
  }</code></span></span>

• 双链表的替换值操作分析与实现 
  双链表的替换值过程，需要先查找到需要替换的结点，这个过程跟获取值的过程是一样的，找到结点后直接替换值并返回旧值即可。比较简单直接上代码：

  <span style="color:#333333"><span style="color:#000000"><code><span style="color:#9b859d">@Override</span>
  <span style="color:#000088">public</span> T <span style="color:#009900">set</span>(<span style="color:#000088">int</span> index, T data) {
     T old=<span style="color:#000088">null</span>;
     <span style="color:#000088">if</span> (index><span style="color:#006666">0</span>&&data!=<span style="color:#000088">null</span>){
         <span style="color:#000088">int</span> j=<span style="color:#006666">0</span>;
         DNode<T> pre =<span style="color:#000088">this</span>.head.next;
         <span style="color:#880000">//查找需要替换的位置</span>
         <span style="color:#000088">while</span> (pre!=<span style="color:#000088">null</span>&&j<index){
             j++;
             pre=pre.next;
         }
         <span style="color:#000088">if</span> (pre!=<span style="color:#000088">null</span>){
             old=pre.data;
             <span style="color:#880000">//替换数据</span>
             pre.data=data;
         }
     }
     <span style="color:#000088">return</span> old;
  }</code></span></span>

ok~，到此双链表的主要操作实现已分析完，下面给出双链表的实现源码：

<span style="color:#333333"><span style="color:#000000"><code><span style="color:#000088">package</span> com.zejian.structures.LinkedList.doubleLinked;

<span style="color:#000088">import</span> com.zejian.structures.LinkedList.ILinkedList;

<span style="color:#880000">/**
* Created by zejian on 2016/10/23.
* 双链表的实现,带头结点(不带数据)的双链表,为了更高的效率该类包含指向尾部的指针tail
*/</span>
public <span style="color:#000088">class</span> <span style="color:#4f4f4f">HeadDoubleILinkedList</span><<span style="color:#4f4f4f">T</span>> <span style="color:#4f4f4f">implements</span> <span style="color:#4f4f4f">ILinkedList</span><<span style="color:#4f4f4f">T</span>> {

 <span style="color:#000088">protected</span> DNode<T> head; <span style="color:#880000">//不带数据的头结点</span>
 <span style="color:#000088">protected</span> DNode<T> tail; <span style="color:#880000">//指向尾部的指针</span>

 public HeadDoubleILinkedList(){
     <span style="color:#000088">this</span>.head =<span style="color:#000088">this</span>.tail= <span style="color:#000088">new</span> DNode<>();          <span style="color:#880000">//初始化头结点</span>
 }


 <span style="color:#880000">/**
  * 传入一个数组,转换成链表
  * <span style="color:#4f4f4f">@param</span> array
  */</span>
 public HeadDoubleILinkedList(T[] array)
 {
     <span style="color:#000088">this</span>();
     <span style="color:#000088">if</span> (array!=<span style="color:#000088">null</span> && array.length><span style="color:#006666">0</span>)
     {
         <span style="color:#000088">this</span>.head.next = <span style="color:#000088">new</span> DNode<T>(array[<span style="color:#006666">0</span>]);
         tail =<span style="color:#000088">this</span>.head.next;
         tail.prev=<span style="color:#000088">this</span>.head;
         int i=<span style="color:#006666">1</span>;
         <span style="color:#000088">while</span> (i<array.length)
         {
             tail.next=<span style="color:#000088">new</span> DNode<T>(array[i++]);
             tail.next.prev=tail;
             tail = tail.next;
         }
     }
 }

 <span style="color:#9b859d">@Override</span>
 public boolean isEmpty() {
     <span style="color:#000088">return</span> head.next==<span style="color:#000088">null</span>;
 }


 <span style="color:#9b859d">@Override</span>
 public int length() {
     int length=<span style="color:#006666">0</span>;
     DNode<T> pre=head.next;
     <span style="color:#000088">while</span> (pre!=<span style="color:#000088">null</span>){
         length++;
         pre=pre.next;
     }
     <span style="color:#000088">return</span> length;
 }


 <span style="color:#9b859d">@Override</span>
 public T get(int index) {
     <span style="color:#000088">if</span> (index>=<span style="color:#006666">0</span>)
     {
         int j=<span style="color:#006666">0</span>;
         DNode<T> pre=<span style="color:#000088">this</span>.head.next;
         <span style="color:#000088">while</span> (pre!=<span style="color:#000088">null</span> && j<index)
         {
             j++;
             pre=pre.next;
         }
         <span style="color:#000088">if</span> (pre!=<span style="color:#000088">null</span>)
             <span style="color:#000088">return</span> pre.data;
     }
     <span style="color:#000088">return</span> <span style="color:#000088">null</span>;
 }


 <span style="color:#9b859d">@Override</span>
 public T set(int index, T data) {
     T old=<span style="color:#000088">null</span>;
     <span style="color:#000088">if</span> (index><span style="color:#006666">0</span>&&data!=<span style="color:#000088">null</span>){
         int j=<span style="color:#006666">0</span>;
         DNode<T> pre =<span style="color:#000088">this</span>.head.next;
         <span style="color:#880000">//查找需要替换的位置</span>
         <span style="color:#000088">while</span> (pre!=<span style="color:#000088">null</span>&&j<index){
             j++;
             pre=pre.next;
         }
         <span style="color:#000088">if</span> (pre!=<span style="color:#000088">null</span>){
             old=pre.data;
             <span style="color:#880000">//替换数据</span>
             pre.data=data;
         }
     }
     <span style="color:#000088">return</span> old;
 }

 <span style="color:#880000">/**
  * 插入结点
  * <span style="color:#4f4f4f">@param</span> index
  * <span style="color:#4f4f4f">@param</span> data
  * <span style="color:#4f4f4f">@return</span>
  */</span>
 <span style="color:#9b859d">@Override</span>
 public boolean add(int index, T data) {
     <span style="color:#000088">if</span>(index<<span style="color:#006666">0</span>||data==<span style="color:#000088">null</span>)
         <span style="color:#000088">throw</span> <span style="color:#000088">new</span> NullPointerException(<span style="color:#009900">"index < 0 || data == null"</span>);

         int j = <span style="color:#006666">0</span>;
         DNode<T> front = <span style="color:#000088">this</span>.head;
         <span style="color:#880000">//查找要插入结点位置的前一个结点</span>
         <span style="color:#000088">while</span> (front.next != <span style="color:#000088">null</span> && j < index) {
             j++;
             front = front.next;
         }

         <span style="color:#880000">//创建需要插入的结点,并让其前继指针指向front,后继指针指向front.next</span>
         DNode<T> q = <span style="color:#000088">new</span> DNode<T>(data, front, front.next);

         <span style="color:#880000">//空双链表插入,需要确保front.next不为空</span>
         <span style="color:#000088">if</span>(front.next != <span style="color:#000088">null</span>) {
             <span style="color:#880000">//更改front.next的前继指针</span>
             front.next.prev = q;
         }
         <span style="color:#880000">//更改front的后继指针</span>
         front.next = q;

         <span style="color:#880000">//在尾部插入时需要注意更新tail指向</span>
         <span style="color:#000088">if</span>(front==<span style="color:#000088">this</span>.tail){
             <span style="color:#000088">this</span>.tail=q;
         }

         <span style="color:#000088">return</span> <span style="color:#000088">true</span>;
 }

 <span style="color:#880000">/**
  * 尾部添加
  * <span style="color:#4f4f4f">@param</span> data
  * <span style="color:#4f4f4f">@return</span>
  */</span>
 <span style="color:#9b859d">@Override</span>
 public boolean add(T data) {
     <span style="color:#000088">if</span> (data==<span style="color:#000088">null</span>)
         <span style="color:#000088">return</span> <span style="color:#000088">false</span>;
     <span style="color:#880000">//创建新结点,并把其前继指针指向tail</span>
     DNode<T> q = <span style="color:#000088">new</span> DNode<T>(data, tail, <span style="color:#000088">null</span>);
     tail.next=q;
     <span style="color:#880000">//更新尾部结点</span>
     <span style="color:#000088">this</span>.tail=q;
     <span style="color:#000088">return</span> <span style="color:#000088">true</span>;
 }

 <span style="color:#880000">/**
  * 根据下标删除结点
  * 1.头删除
  * 2.中间删除
  * 3.尾部删除,更新tail指向
  * <span style="color:#4f4f4f">@param</span> index 下标起始值为0
  * <span style="color:#4f4f4f">@return</span>
  */</span>
 <span style="color:#9b859d">@Override</span>
 public T remove(int index) {

     int size=length();
     T temp=<span style="color:#000088">null</span>;

     <span style="color:#000088">if</span>(index<<span style="color:#006666">0</span>||index>=size||isEmpty()){
         <span style="color:#000088">return</span> temp;
     }

     DNode<T> p=<span style="color:#000088">this</span>.head;
     int j=<span style="color:#006666">0</span>;
     <span style="color:#880000">//头删除/尾删除/中间删除,查找需要删除的结点(要删除的当前结点因此i<=index)</span>
     <span style="color:#000088">while</span> (p!=<span style="color:#000088">null</span>&&j<=index){
         p=p.next;
         j++;
     }
     <span style="color:#880000">//当链表只要一个结点时,无需此步</span>
     <span style="color:#000088">if</span>(p.next!=<span style="color:#000088">null</span>){
         p.next.prev=p.prev;
     }
     p.prev.next=p.next;
     <span style="color:#880000">//如果是尾结点</span>
     <span style="color:#000088">if</span> (p==<span style="color:#000088">this</span>.tail) {
         <span style="color:#000088">this</span>.tail = p.prev;<span style="color:#880000">//更新未结点的指向</span>
     }
     temp=p.data;

     <span style="color:#000088">return</span> temp;
 }

 <span style="color:#880000">/**
  * 根据data删除结点,无需像单向链表那样去存储要删除结点的前一个结点
  * 1.头删除
  * 2.中间删除
  * 3.尾部删除,更新tail指向
  * <span style="color:#4f4f4f">@param</span> data
  * <span style="color:#4f4f4f">@return</span>
  */</span>
 <span style="color:#9b859d">@Override</span>
 public boolean removeAll(T data) {

     boolean isRemove=<span style="color:#000088">false</span>;

     <span style="color:#000088">if</span>(data==<span style="color:#000088">null</span>||isEmpty())
         <span style="color:#000088">return</span> isRemove;

     <span style="color:#880000">//注意这里的起点,如果起点为this.head,那么情况区别如同前面的根据index的删除实现</span>
     DNode<T> p=<span style="color:#000088">this</span>.head.next;

     <span style="color:#880000">//头删除/尾删除/中间删除(size>1),查找所有需要删除的结点</span>
     <span style="color:#000088">while</span> (p!=<span style="color:#000088">null</span>){

         <span style="color:#000088">if</span>(data.equals(p.data)){
             <span style="color:#000088">if</span> (p==<span style="color:#000088">this</span>.tail){
                 <span style="color:#880000">//如果是尾结点</span>
                 <span style="color:#000088">this</span>.tail=p.prev;<span style="color:#880000">//更新未结点的指向</span>
                 p.prev=<span style="color:#000088">null</span>;
                 <span style="color:#000088">this</span>.tail.next=<span style="color:#000088">null</span>;
             }<span style="color:#000088">else</span> {
                 <span style="color:#880000">//如果是在中间删除,更新前继和后继指针指向</span>
                 p.prev.next=p.next;
                 p.next.prev=p.prev;
             }
             isRemove=<span style="color:#000088">true</span>;
             p=p.next;<span style="color:#880000">//继续查找</span>
         }<span style="color:#000088">else</span> {
             p=p.next;
         }

     }
     <span style="color:#000088">return</span> isRemove;
 }

 <span style="color:#880000">/**
  * 清空链表
  */</span>
 <span style="color:#9b859d">@Override</span>
 public void clear() {
     <span style="color:#000088">this</span>.head.next=<span style="color:#000088">null</span>;
     <span style="color:#000088">this</span>.tail=<span style="color:#000088">this</span>.head;
 }


 <span style="color:#9b859d">@Override</span>
 public boolean contains(T data) {

     <span style="color:#000088">if</span>(data==<span style="color:#000088">null</span>){
         <span style="color:#000088">return</span> <span style="color:#000088">false</span>;
     }

     DNode<T> p=<span style="color:#000088">this</span>.head.next;
     <span style="color:#000088">while</span> (p!=<span style="color:#000088">null</span>){
         <span style="color:#000088">if</span> (data.equals(p.data)){
             <span style="color:#000088">return</span> <span style="color:#000088">true</span>;
         }<span style="color:#000088">else</span> {
             p=p.next;
         }
     }

     <span style="color:#000088">return</span> <span style="color:#000088">false</span>;
 }

 <span style="color:#9b859d">@Override</span>
 public String toString() {
     String str=<span style="color:#009900">"("</span>;
     DNode<T> pre = <span style="color:#000088">this</span>.head.next;
     <span style="color:#000088">while</span> (pre!=<span style="color:#000088">null</span>)
     {
         str += pre.data;
         pre = pre.next;
         <span style="color:#000088">if</span> (pre!=<span style="color:#000088">null</span>)
             str += <span style="color:#009900">", "</span>;
     }
     <span style="color:#000088">return</span> str+<span style="color:#009900">")"</span>;
 }

 public static void main(String[] args){

     String[] letters={<span style="color:#009900">"A"</span>,<span style="color:#009900">"B"</span>,<span style="color:#009900">"C"</span>,<span style="color:#009900">"D"</span>,<span style="color:#009900">"Z"</span>,<span style="color:#009900">"E"</span>,<span style="color:#009900">"F"</span>};
<span style="color:#880000">//        String[] letters={"A"};</span>
     HeadDoubleILinkedList<String> list=<span style="color:#000088">new</span> HeadDoubleILinkedList<>(letters);

     System.out.println(<span style="color:#009900">"list.get(3)->"</span>+list.get(<span style="color:#006666">3</span>));
     System.out.println(<span style="color:#009900">"list:"</span>+list.toString());

     System.out.println(<span style="color:#009900">"list.add(4,Y)—>"</span>+list.add(<span style="color:#006666">0</span>,<span style="color:#009900">"Y"</span>));
     System.out.println(<span style="color:#009900">"list:"</span>+list.toString());
     System.out.println(<span style="color:#009900">"list.add(Z)—>"</span>+list.add(<span style="color:#009900">"Z"</span>));
     System.out.println(<span style="color:#009900">"list:"</span>+list.toString());


     System.out.println(<span style="color:#009900">"list.contains(Z)->"</span>+list.contains(<span style="color:#009900">"Z"</span>));
     System.out.println(<span style="color:#009900">"list.set(4,P)-->"</span>+list.set(<span style="color:#006666">4</span>,<span style="color:#009900">"P"</span>));
     System.out.println(<span style="color:#009900">"list:"</span>+list.toString());


     System.out.println(<span style="color:#009900">"list.remove(6)-->"</span>+list.remove(<span style="color:#006666">6</span>));
<span style="color:#880000">//        System.out.println("list.remove(Z)->"+list.removeAll("Z"));</span>
     System.out.println(<span style="color:#009900">"list:"</span>+list.toString());
 }
}</code></span></span>

循环双链表的设计与实现

  如果双链表的最后一个结点的next指针域指向头结点，而头结点的prev指针指向头最后一个结点，则构成了双链表（Circular Doubly LinkedList），其结构如下图示： 

在循环双链表中我们不再需要尾指向结点，因为整个链表已构成循环，在头结点head的位置也可以轻松获取到尾部结点的位置。对于循环双链表的插入、删除操作也无需区分位置操作的情况，这是由于循环双链表的本身的特殊性，使p.next.pre永远不可能为null，因此我们在插入和删除时代码实现相对简单些。下面我们先分析一下循环双链表的插入操作，图示如下： 

我们可以看出（a）（b）（c）三种情况都无需关系位置插入的区别，其代码实现如下：

<span style="color:#333333"><span style="color:#000000"><code><span style="color:#880000">/**
 * 根据index插入
 * 循环链表中无论是prev还是next都不存在空的情况,因此添加时
 * 无论是头部还是尾部还是中,都视为一种情况对待
 *<span style="color:#4f4f4f"> @param</span> index
 *<span style="color:#4f4f4f"> @param</span> data
 *<span style="color:#4f4f4f"> @return</span>
 */</span>
<span style="color:#9b859d">@Override</span>
<span style="color:#000088">public</span> <span style="color:#000088">boolean</span> <span style="color:#009900">add</span>(<span style="color:#000088">int</span> index, T data) {
    <span style="color:#000088">int</span> size=length();
    <span style="color:#000088">if</span>(data==<span style="color:#000088">null</span>||index<<span style="color:#006666">0</span>||index>=size)
        <span style="color:#000088">return</span> <span style="color:#000088">false</span>;

    <span style="color:#000088">int</span> j=<span style="color:#006666">0</span>;
    DNode<T> p=<span style="color:#000088">this</span>.head;
    <span style="color:#880000">//寻找插入点的位置</span>
    <span style="color:#000088">while</span> (p.next!=head&&j<index){
        p=p.next;
        j++;
    }

    <span style="color:#880000">//创建新结点,如果index=3,那么插入的位置就是第4个位置</span>
    DNode<T> q=<span style="color:#000088">new</span> DNode<>(data,p,p.next);
    p.next=q;
    p.next.prev=q;

    <span style="color:#000088">return</span> <span style="color:#000088">true</span>;
}</code></span></span>

循环双链表的删除操作图示如下：

同样地，从图中我们也可以发现由于循环双链表的特性，（a）（b）（c）三种情况都无需区分操作位置，其代码实现如下：

<span style="color:#333333"><span style="color:#000000"><code><span style="color:#4f4f4f">@Override</span>
public T remove(<span style="color:#000088">int</span> <span style="color:#000088">index</span>) {
    T old = null;
    <span style="color:#000088">int</span> size=<span style="color:#000088">length</span>();

    <span style="color:#000088">if</span> (<span style="color:#000088">index</span><<span style="color:#006666">0</span>||<span style="color:#000088">index</span>>=size)
        <span style="color:#000088">return</span> old;

    <span style="color:#000088">int</span> j=<span style="color:#006666">0</span>;
    DNode<T> p=this.head.<span style="color:#000088">next</span>;

    <span style="color:#000088">while</span> (p!=head && j<<span style="color:#000088">index</span>)
    {
        j++;
        p = p.<span style="color:#000088">next</span>;
    }

    <span style="color:#000088">if</span> (p!=head)
    {
        old = p.data;
        p.prev.<span style="color:#000088">next</span> = p.<span style="color:#000088">next</span>;
        p.<span style="color:#000088">next</span>.prev = p.prev;
    }
    <span style="color:#000088">return</span> old;
}</code></span></span>

至于循环双链表的查找值、替换值等操作与双链表并没有多大的区别，但是需要特别注意的是在遍历循环双链表时，结束标志不再是尾部结点是否为空，而是尾结点的next指针是否指向头结点head。好~，下面我们给出循环双链表的实现代码：

<span style="color:#333333"><span style="color:#000000"><code>package com.zejian.structures.LinkedList.doubleLinked;

import com.zejian.structures.LinkedList.ILinkedList;

<span style="color:#880000">/**
* Created by zejian on 2016/10/24.
* 循环双链表,带空头结点(不含数据),循环链表可以不需要尾部指针
*/</span>
<span style="color:#000088">public</span> <span style="color:#000088">class</span> LoopHeadDILinkedList<T> implements ILinkedList<T> {

 <span style="color:#000088">protected</span> DNode<T> head; <span style="color:#880000">//不带数据的头结点</span>
<span style="color:#880000">//   protected DNode<T> tail; //指向尾部的指针</span>

 <span style="color:#000088">public</span> <span style="color:#009900">LoopHeadDILinkedList</span>(){
     <span style="color:#000088">this</span>.head = <span style="color:#000088">new</span> DNode<>();<span style="color:#880000">//初始化头结点</span>
     <span style="color:#000088">this</span>.head.next=head;
     <span style="color:#000088">this</span>.head.prev=head;

 }


 <span style="color:#880000">/**
  * 传入一个数组,转换成链表
  * @param array
  */</span>
 <span style="color:#000088">public</span> <span style="color:#009900">LoopHeadDILinkedList</span>(T[] array)
 {
     <span style="color:#000088">this</span>();
     <span style="color:#000088">if</span> (array!=<span style="color:#000088">null</span> && array.length><span style="color:#006666">0</span>)
     {
         DNode<T> p= <span style="color:#000088">new</span> DNode<>(array[<span style="color:#006666">0</span>]);
         head.next=p;
         head.prev=p;
         p.prev=head;
         p.next=head;

         <span style="color:#000088">int</span> i=<span style="color:#006666">1</span>;
         <span style="color:#000088">while</span> (i<array.length)
         {
             p.next=<span style="color:#000088">new</span> DNode<>(array[i++],p,head);
             head.prev=p.next;
             p=p.next;
         }
     }
 }



 @Override
 <span style="color:#000088">public</span> boolean <span style="color:#009900">isEmpty</span>() {
     <span style="color:#000088">return</span> <span style="color:#000088">this</span>.head.next==head;<span style="color:#880000">//循环双链表的后继指针指向自己说明是空链表</span>
 }

 @Override
 <span style="color:#000088">public</span> <span style="color:#000088">int</span> <span style="color:#009900">length</span>() {

     <span style="color:#000088">int</span> length=<span style="color:#006666">0</span>;
     DNode<T> p=<span style="color:#000088">this</span>.head.next;
     <span style="color:#000088">while</span> (p!=<span style="color:#000088">this</span>.head){
         length++;
         p=p.next;
     }
     <span style="color:#000088">return</span> length;
 }

 @Override
 <span style="color:#000088">public</span> T <span style="color:#009900">get</span>(<span style="color:#000088">int</span> index) {

     <span style="color:#000088">if</span> (index>=<span style="color:#006666">0</span>)
     {
         <span style="color:#000088">int</span> j=<span style="color:#006666">0</span>;
         DNode<T> p=<span style="color:#000088">this</span>.head.next;
         <span style="color:#000088">while</span> (p!=head && j<index)
         {
             j++;
             p=p.next;
         }
         <span style="color:#000088">if</span> (p!=head)
             <span style="color:#000088">return</span> p.data;
     }
     <span style="color:#000088">return</span> <span style="color:#000088">null</span>;
 }

 <span style="color:#880000">/**
  * 根据index修改data
  * @param index
  * @param data
  * @return 返回被替换的data
  */</span>
 @Override
 <span style="color:#000088">public</span> T <span style="color:#009900">set</span>(<span style="color:#000088">int</span> index, T data) {

     <span style="color:#000088">if</span> (data==<span style="color:#000088">null</span>){
         <span style="color:#000088">return</span> <span style="color:#000088">null</span>;
     }

     <span style="color:#000088">if</span>(index>=<span style="color:#006666">0</span>){
         <span style="color:#000088">int</span> j=<span style="color:#006666">0</span>;
         DNode<T> p=<span style="color:#000088">this</span>.head.next;

         <span style="color:#000088">while</span> (p!=head&&j<index){
             j++;
             p=p.next;
         }

         <span style="color:#880000">//如果不是头结点</span>
         <span style="color:#000088">if</span>(p!=head){
             T old = p.data;
             p.data=data;

             <span style="color:#000088">return</span> old;
         }
     }

     <span style="color:#000088">return</span> <span style="color:#000088">null</span>;
 }

 <span style="color:#880000">/**
  * 根据index添加
  * 循环链表中无论是prev还是next都不存在空的情况,因此添加时
  * 无论是头部还是尾部还是中,都视为一种情况对待
  * @param index
  * @param data
  * @return
  */</span>
 @Override
 <span style="color:#000088">public</span> boolean <span style="color:#009900">add</span>(<span style="color:#000088">int</span> index, T data) {
     <span style="color:#000088">int</span> size=length();
     <span style="color:#000088">if</span>(data==<span style="color:#000088">null</span>||index<<span style="color:#006666">0</span>||index>=size)
         <span style="color:#000088">return</span> <span style="color:#000088">false</span>;

     <span style="color:#000088">int</span> j=<span style="color:#006666">0</span>;
     DNode<T> p=<span style="color:#000088">this</span>.head;
     <span style="color:#880000">//寻找插入点的位置</span>
     <span style="color:#000088">while</span> (p.next!=head&&j<index){
         p=p.next;
         j++;
     }

     <span style="color:#880000">//创建新结点,如果index=3,那么插入的位置就是第4个位置</span>
     DNode<T> q=<span style="color:#000088">new</span> DNode<>(data,p,p.next);
     p.next=q;
     p.next.prev=q;

     <span style="color:#000088">return</span> <span style="color:#000088">true</span>;
 }

 <span style="color:#880000">/**
  * 尾部添加
  * @param data
  * @return
  */</span>
 @Override
 <span style="color:#000088">public</span> boolean <span style="color:#009900">add</span>(T data) {

     <span style="color:#000088">if</span>(data==<span style="color:#000088">null</span>)
         <span style="color:#000088">return</span> <span style="color:#000088">false</span>;
     <span style="color:#880000">//创建新结点,让前继指针指向head.pre,后继指针指向head</span>
     DNode<T> p=<span style="color:#000088">new</span> DNode<>(data,head.prev,head);
     <span style="color:#880000">//更新tail后继指针的指向</span>
     <span style="color:#000088">this</span>.head.prev.next=p;
     <span style="color:#000088">this</span>.head.prev=p;

     <span style="color:#000088">return</span> <span style="color:#000088">true</span>;
 }

 @Override
 <span style="color:#000088">public</span> T <span style="color:#009900">remove</span>(<span style="color:#000088">int</span> index) {
     T old = <span style="color:#000088">null</span>;
     <span style="color:#000088">int</span> size=length();

     <span style="color:#000088">if</span> (index<<span style="color:#006666">0</span>||index>=size)
         <span style="color:#000088">return</span> old;

     <span style="color:#000088">int</span> j=<span style="color:#006666">0</span>;
     DNode<T> p=<span style="color:#000088">this</span>.head.next;

     <span style="color:#000088">while</span> (p!=head && j<index)
     {
         j++;
         p = p.next;
     }

     <span style="color:#000088">if</span> (p!=head)
     {
         old = p.data;
         p.prev.next = p.next;
         p.next.prev = p.prev;
     }

     <span style="color:#000088">return</span> old;
 }

 @Override
 <span style="color:#000088">public</span> boolean <span style="color:#009900">removeAll</span>(T data) {
     boolean isRemove=<span style="color:#000088">false</span>;

     <span style="color:#000088">if</span>(data==<span style="color:#000088">null</span>){
         <span style="color:#000088">return</span> isRemove;
     }

     DNode<T> p=<span style="color:#000088">this</span>.head.next;
     <span style="color:#000088">while</span> (p!=head){
         <span style="color:#000088">if</span>(data.equals(p.data)){
             p.prev.next=p.next;
             p.next.prev=p.prev;
             isRemove=<span style="color:#000088">true</span>;
         }
         p=p.next;
     }

     <span style="color:#000088">return</span> isRemove;
 }

 @Override
 <span style="color:#000088">public</span> <span style="color:#000088">void</span> <span style="color:#009900">clear</span>() {
     <span style="color:#000088">this</span>.head.prev = head;
     <span style="color:#000088">this</span>.head.next = head;
 }

 @Override
 <span style="color:#000088">public</span> boolean <span style="color:#009900">contains</span>(T data) {

     <span style="color:#000088">if</span> (data==<span style="color:#000088">null</span>){
        <span style="color:#000088">return</span> <span style="color:#000088">false</span>;
     }

     DNode<T> p=<span style="color:#000088">this</span>.head.next;

     <span style="color:#000088">while</span> (p!=head){
         <span style="color:#000088">if</span>(data.equals(p.data)){
             <span style="color:#000088">return</span> <span style="color:#000088">false</span>;
         }

         p=p.next;
     }

     <span style="color:#000088">return</span> <span style="color:#000088">false</span>;
 }

 @Override
 <span style="color:#000088">public</span> String <span style="color:#009900">toString</span>()
 {
     String str=<span style="color:#009900">"("</span>;
     DNode<T> p = <span style="color:#000088">this</span>.head.next;
     <span style="color:#000088">while</span> (p!=head)
     {
         str += p.data.toString();
         p = p.next;
         <span style="color:#000088">if</span> (p!=head)
             str += <span style="color:#009900">", "</span>;
     }
     <span style="color:#000088">return</span> str+<span style="color:#009900">")"</span>;
 }
 <span style="color:#000088">public</span> <span style="color:#000088">static</span> <span style="color:#000088">void</span> <span style="color:#009900">main</span>(String[] args){

     String[] letters={<span style="color:#009900">"A"</span>,<span style="color:#009900">"B"</span>,<span style="color:#009900">"C"</span>,<span style="color:#009900">"D"</span>,<span style="color:#009900">"Z"</span>,<span style="color:#009900">"E"</span>,<span style="color:#009900">"F"</span>};
     LoopHeadDILinkedList<String> list=<span style="color:#000088">new</span> LoopHeadDILinkedList<>(letters);

     System.<span style="color:#000088">out</span>.println(<span style="color:#009900">"init list-->"</span>+list.toString());

     System.<span style="color:#000088">out</span>.println(<span style="color:#009900">"list.get(3)->"</span>+list.<span style="color:#000088">get</span>(<span style="color:#006666">3</span>));
     System.<span style="color:#000088">out</span>.println(<span style="color:#009900">"list:"</span>+list.toString());

     System.<span style="color:#000088">out</span>.println(<span style="color:#009900">"list.add(4,Y)—>"</span>+list.add(<span style="color:#006666">4</span>,<span style="color:#009900">"Y"</span>));
     System.<span style="color:#000088">out</span>.println(<span style="color:#009900">"list:"</span>+list.toString());
     System.<span style="color:#000088">out</span>.println(<span style="color:#009900">"list.add(Z)—>"</span>+list.add(<span style="color:#009900">"Z"</span>));
     System.<span style="color:#000088">out</span>.println(<span style="color:#009900">"list:"</span>+list.toString());


     System.<span style="color:#000088">out</span>.println(<span style="color:#009900">"list.contains(Z)->"</span>+list.contains(<span style="color:#009900">"Z"</span>));
     System.<span style="color:#000088">out</span>.println(<span style="color:#009900">"list.set(4,P)-->"</span>+list.<span style="color:#000088">set</span>(<span style="color:#006666">4</span>,<span style="color:#009900">"P"</span>));
     System.<span style="color:#000088">out</span>.println(<span style="color:#009900">"list:"</span>+list.toString());


     System.<span style="color:#000088">out</span>.println(<span style="color:#009900">"list.remove(3)-->"</span>+list.remove(<span style="color:#006666">3</span>));
     System.<span style="color:#000088">out</span>.println(<span style="color:#009900">"list.remove(Z)->"</span>+list.removeAll(<span style="color:#009900">"Z"</span>));
     System.<span style="color:#000088">out</span>.println(<span style="color:#009900">"list:"</span>+list.toString());
 }
}</code></span></span>

排序循环双链表的实现

  所谓的排序循环双链表指的是在插入元素时，不再根据index标志，而是根据值的大小寻找插入位置，但是有个插入值data必须是T或者T的父类而且实现了Comoarable接口。排序循环双链表的实现比较简单，我们只需继承前面的循环双链表并重写add方法即可，主要代码实现如下：

<span style="color:#333333"><span style="color:#000000"><code><span style="color:#000088">package</span> com.zejian.structures.LinkedList.doubleLinked;

<span style="color:#880000">/**
* Created by zejian on 2016/11/6.
* 升序排序链表，继承LoopHeadDILinkedList
*/</span>
public <span style="color:#000088">class</span> <span style="color:#4f4f4f">SortLoopHeadDIlinkedList</span><<span style="color:#4f4f4f">T</span> <span style="color:#000088">extends</span> <span style="color:#4f4f4f">Comparable</span><? <span style="color:#000088">extends</span> <span style="color:#4f4f4f">T</span>>> <span style="color:#000088">extends</span> <span style="color:#4f4f4f">LoopHeadDILinkedList</span><<span style="color:#4f4f4f">T</span>> {
  <span style="color:#880000">/**
   * 顺序插入
   * <span style="color:#4f4f4f">@param</span> data
   * <span style="color:#4f4f4f">@return</span>
   */</span>
  <span style="color:#9b859d">@Override</span>
  public boolean add(T data) {

      <span style="color:#000088">if</span>(data==<span style="color:#000088">null</span>||!(data instanceof Comparable))
          <span style="color:#000088">throw</span> <span style="color:#000088">new</span> NullPointerException(<span style="color:#009900">"data can\'t be null or data instanceof Comparable must be true"</span>);

      Comparable cmp =data;<span style="color:#880000">//这里需要转一下类型,否则idea编辑器上检验不通过.</span>

      <span style="color:#880000">//如果data值比最后一个结点大,那么直接调用父类方法,在尾部添加.</span>
      <span style="color:#000088">if</span>(<span style="color:#000088">this</span>.isEmpty() || cmp.compareTo(<span style="color:#000088">this</span>.head.prev.data) > <span style="color:#006666">0</span>){
          <span style="color:#000088">return</span> <span style="color:#000088">super</span>.add(data);
      }

      DNode<T> p=<span style="color:#000088">this</span>.head.next;
      <span style="color:#880000">//查找插入点</span>
      <span style="color:#000088">while</span> (p!=head&&cmp.compareTo(p.data)><span style="color:#006666">0</span>)
          p=p.next;

      DNode<T> q=<span style="color:#000088">new</span> DNode<>(data,p.prev,p);
      p.prev.next=q;
      p.prev=q;

      <span style="color:#000088">return</span> <span style="color:#000088">true</span>;
  }

  public static void main(String[] args){
      SortLoopHeadDIlinkedList<Integer> list=<span style="color:#000088">new</span> SortLoopHeadDIlinkedList<>();
      list.add(<span style="color:#006666">50</span>);
      list.add(<span style="color:#006666">40</span>);
      list.add(<span style="color:#006666">80</span>);
      list.add(<span style="color:#006666">20</span>);
      System.out.println(<span style="color:#009900">"init list-->"</span>+list.toString());
  }
}</code></span></span>

双链表的执行效率分析

  其实上一篇已分析得差不多了，这里再简单说明一下，链表在插入和删除元素时执行效率比较高，从插入操作来看，我们假设front指向的是双向链表中的一个结点，此时插入front的后继结点或者是前驱结点所消耗的时间为常数时间O(1),这点在插入front的前驱结点的效率比单链表有所改善，无需从头结点开始遍历，但是上述都是从已知双向链表中front结点的情况下讨论的。如果从实现代码的操作上看，无论是插入还是删除，都需要查找插入结点或删除结点，而这个过程访问结点所花费的时间的是O(n)，因此双链表的插入或删除操作或是查值操作，其时间复杂度都为O(n),至于为什么说链表更适合插入删除，这点上一篇我们已讨论过，这里就不重复了。最后给出一张关于链表、数组、动态数组的比较表：

传递参数	链表	动态数组
索引	O(n)	O(1)
在最前端插入或删除	O(1)	O(n)
在最末端插入	O(n)	O(1),如果数组空间没有被填满;O(n),如果数组空间已填满
在最末端删除	O(n)	O(1)
在中间插入	O(n)	O(n)
在中间删除	O(n)	O(n)
空间浪费	O(n)	O(n)

异或高效存储双链表的设计原理概要

  在上述分析的双链表的实现中，都是需要一个指向后继结点的正向指针和一个指向前驱结点的反向指针，出于此点的考虑，我们需要在构造一个结点类时需要一个数据域data、一个指向后继结点的指针next以及一个指向前驱结点的指针prev。但为了设计更高效节省存储空间，一种基于指针差运算存储高效的双向链表就诞生了。这种链表的每个结点仍然与单链表一样仅使用一个指针域来设计双向链表，新的双向链表结点类结构如下：

<span style="color:#333333"><span style="color:#000000"><code>package com.zejian.structures.LinkedList.XORLinked;

<span style="color:#880000">/**
 * Created by zejian on 2016/11/6.
 * 异或结点
 */</span>
<span style="color:#000088">public</span> <span style="color:#000088">class</span> XORNode<T> {
    <span style="color:#000088">public</span> T data;
    <span style="color:#000088">public</span> XORNode<T> ptrdiff;<span style="color:#880000">//异或指针</span>

    <span style="color:#000088">public</span> <span style="color:#009900">XORNode</span>() {
    }

    <span style="color:#000088">public</span> <span style="color:#009900">XORNode</span>(T data, XORNode<T> ptrdiff) {
        <span style="color:#000088">this</span>.data = data;
        <span style="color:#000088">this</span>.ptrdiff = ptrdiff;
    }
}</code></span></span>

其中的ptrdiff字段存储了后继结点与前驱结点的地址差，指针的差通过异或运行（对异或不熟悉的可以看博主的另一篇文章：java运算符）来实现的，我们这里使用⊕表示异或操作，则有如下计算：

pridiff=后继结点的地址⊕前驱结点的地址

如上图，我们采用异或差值来计算各个结点的位置：

A的next域为head⊕B 
B的next域为A⊕C 
C的next域为B⊕D 
D的next域为C⊕NULL

那么为什么可以这么计算呢？我们先来了解一下异或的特性：

• X⊕X=0
• X⊕0=X
• X⊕Y=Y⊕X
• (X⊕Y)⊕Z=X⊕(Y⊕Z)

  所以我们可以很容易利用上述的异或特性找到结点的对象，比如指向P想从结点C移动到结点B，已知C的ptrdiff值为B⊕D,那么就需要将结点C的ptrdiff的值与结点D的地址执行异或运算，这时就可以得到B的地址了，计算过程如下：

(B ⊕ D) ⊕ D = B ⊕(D ⊕ D) = B ⊕ 0 =B

如果想从C结点移动到D结点，那么此时的计算如下：

(B ⊕ D) ⊕ B = D ⊕(B ⊕ B) =B ⊕ 0 = D

  因此在确实可以通过一个next的指针域来实现双向链表的移动，而且这种存储高效的双向链表还可以节省空间开销。实际上，存储高效的双链表介绍来自《数据结构与算法经典问题分析》一书，不过博主发现，这种存储高效的链表，使用C语言比较容易实现，因为C语言可以通过指针(地址)获取到对象直接操作，但在java语言中，博主并没有想到如何实现这种存储高效的链表，至少目前还没想到可行的方案，google了一把实现语言都是C，没找到java的实现，不过博主想来想去都感觉这种存储高效的链表不太适合java来实现（仅个人观点），若有实现方案的还望留言告知，感谢呢。不过这样算法设计思想方式还是蛮有不错的。ok~，关于双向链表，我们暂且聊到这里，下面丢出github的地址：

GITHUB博文源码下载地址

关联文章:

java数据结构与算法之顺序表与链表设计与实现分析 
java数据结构与算法之双链表设计与实现 
java数据结构与算法之改良顺序表与双链表类似ArrayList和LinkedList（带Iterator迭代器与fast-fail机制）

 

https://blog.csdn.net/javazejian/article/details/53047590