（双向循环链表）通过判断插入位置是离头节点和尾节点谁更近，让遍历节点是顺序移动还是逆序移动，来更快到达目标位置。来提升一倍插入删除性能.（java演示）

package com.data_struct.table;

public class doubleCyclicLinkTable
{
    public static void main(String[] args)
    {
        doubleCycLinTa d=new doubleCycLinTa();
        d.isEmpty();
        //增加值
        d.addValue(1);
        d.addValue(2);
        d.addValue(3);
        d.addValue(4);
        d.addValue(5);
        d.addValue(6);
        //判断是否为空
        d.insertValue(1,7);
        d.insertValue(2,2);
        d.insertValue(4,2);
        d.insertValue(6,3);
        d.insertValue(6,7);
        d.insertValue(11,7);

    }
}

class node
{
    public node last;
    public int value;
    public node next;
    public node (node last ,int value,node next)
    {
        this.last=last;
        this.value=value;
        this.next=next;
    }
}
class doubleCycLinTa
{
    private node front=new node(null,0,null);
    private node rear=front;
    private int count=0;
    public doubleCycLinTa()
    {
        front.last=rear;
        front.value=0;
        front.next=front;
    }
    public void addValue(int value)
    {
        node node1=new node(rear,value,front);
        rear.next=node1;
        rear=rear.next;
        count+=1;
        traverse();
    }
    public boolean isEmpty()
    {
        if (count==0)
        {
            System.out.println("链表空");
            return true;
        }
        else return false;
    }
    public void traverse()
    {
        node trav=front;
        for (int i = 0; i < count; i++)
        {
            trav=trav.next;
            System.out.print(trav.value+",");
        }
        System.out.print("\n");
    }
    public void insertValue(int pos,int value)
            /*如果插入点是离头节点更近，则将遍历节点insert设置为头节点，即node insert=front ，
            并且insert=insert.next。直到到达目标位置，然后插入目标节点。
            如果离尾节点更近，则将遍历节点insert设置为尾节点，即node insert=rear.last,
            并且执行insert=insert.last。直到到达目标位置，然后插入目标节点。
            * */
    {
        System.out.println(count);
        node insert;
        if(pos<=(count+1)/2)//判断是离头节点更近，还是尾节点更近。
        {
            insert=front;
            for (int i = 0; i < pos-1; i++)
            {
                insert=insert.next;
            }

                node in_value=new node(insert,value,insert.next);
                insert.next.last=in_value;
                insert.next=in_value;
        }
        else
        {
            insert=rear;
            for (int i = 0; i < (count-pos); i++)
            {
                insert=insert.last;
            }
            node in_value=new node(insert.last,value,insert);
            insert.last.next=in_value;
            insert.last=in_value;
            System.out.println(in_value.last.value);
        }

        count+=1;
        traverse();
    }
}

如果插入点是离头节点更近，则将遍历节点insert设置为头节点，即node insert=front ， 并且insert=insert.next。直到到达目标位置，然后插入目标节点。 如果离尾节点更近，则将遍历节点insert设置为尾节点，即node insert=rear.last, 并且执行insert=insert.last。直到到达目标位置，然后插入目标节点。

这种算法举例如下：

一共100个数据。我们需要在第99位置插入数据，如果从头节点开始next移动，则需要移动98次，但是如果从尾节点开是逆序移动，则只需要1次。利用的就是双向循环链表的双向性。

这种算法理论上能提高一倍性能。