java：不带头结点的双向循环链表

• 概述：

先来分析一下，单链表大致分这几种（单链表，双向链表，循环链表，双向循环链表）

单链表：链表中的元素只能指向下一个结点，只能从头开始遍历，元素之间不能相互指向。

双向链表：链表中元素的next域指向下一个结点，prior域指向前一个结点，元素之间可以相互指向。

循环链表：它的特点是表中最后一个结点的next域指向头结点，整个链表形成一个环。

双向循环链表：特点是即像双向链表一样有next域和prior域，也像循环链表一样整个链表形成一个环。

 

个人觉得，双向循环链表由于这个“环”，使得它在要在头部/尾部访问结点时，可以避免过多顺序访问，也像双向链表一样，可以访问一个结点的前一个/后一个结点。

 

代码实现过程如下（无头结点的双向循环链表）

//封装双向循环链表的结点属性和操作

class CEntry<T>{
    private T value;//数据域
    private CEntry<T> next;//next域
    private CEntry<T>prior;//prior域

    public CEntry(T value){ this.value=value; }
    public  CEntry(){/*申请头结点*/}

    public T getValue() { return value; }
    public void setValue(T value) { this.value = value; }

    public CEntry<T> getNext() { return next; }
    public void setNext(CEntry<T> next) { this.next = next; }

    public CEntry<T>getPrior(){return prior;}
    public void setPrior(CEntry<T>prior){this.prior=prior;}
}

//封装双向循环链表属性和操作
 class DoulCirLNode  <E extends Comparable<E>>{
    private  CEntry<E>Cnode;

    public DoulCirLNode(){
        Cnode=new CEntry<>();
    }
    public DoulCirLNode(CEntry Cnode){
        this.Cnode=Cnode;
    }

    public void addTail(E value){
        if(Cnode.getValue()==null){
            /*当前只有建立时的那个结点，所以前驱和后继都是自己*/
            Cnode.setValue(value);
            Cnode.setNext(Cnode);
            Cnode.setPrior(Cnode);
        }else if(Cnode.getNext()==Cnode){
            CEntry<E> p = new CEntry<>();
            p = Cnode;//设置一个新节点，将此节点指向插入前链表的最后一个结点
            if(Cnode.getNext().getNext()==Cnode) {
                //当有一个结点，即初始结点时，这时的前驱和后继都是自己，所以直接在后面加入一个新结点
                CEntry newCEetry = new CEntry(value);
                Cnode.setPrior(newCEetry);
                newCEetry.setPrior(p);
                newCEetry.setNext(Cnode);
                p.setNext(newCEetry);

            }
            }else{
                 CEntry<E>p=new CEntry<>();
                 p=Cnode;//设置一个新节点，将此节点指向插入前链表的最后一个结点
            while(p!=null&&p.getNext()!=Cnode){
//这块用的还是从第一个结点遍历到最后结点，然后增加，没体现出避免频繁移动的优势
下面的删除会用到
             p=p.getNext();
            }
            CEntry newCEetry =new CEntry(value);
            newCEetry.setPrior(p);
            newCEetry.setNext(Cnode);
            Cnode.setPrior(newCEetry);
            p.setNext(newCEetry);

        }
        }

    /*从尾部删除  Cnode前驱结点指的就是待删除结点，则将此节点删除即可，不用移动大量元素。*/
    public void deleteTail(){
        if(Cnode.getNext()==Cnode) {
            Cnode.setValue(null);
        }else {
            CEntry<E>p=new CEntry<>();
            p=Cnode;
            p.getPrior().getPrior().setNext(p);
            p.setPrior(p.getPrior().getPrior());

        }
    }
    /*查找这块，还是得遍历，要么prior向前遍历，要么next向后*/
    public boolean searchCnode(E value){
        CEntry<E>p=new CEntry<>();
        p=Cnode.getPrior();
        if(p.getPrior()==Cnode){//只有一个结点的情况下
            if(p.getValue()==value)
                return true;
        }else {
            while(p.getPrior()!=Cnode){//这样则略过第一个结点，
                if(p.getValue()==value)
                    return true;
                p=p.getPrior();
            }
            if(p.getValue()==value)//加上第一个结点的判断(“头”结点之后的第一个结点)
                return true;
            p=p.getPrior();
            if(p.getValue()==value)//加上"头"结点的判断
                return true;
        }
        return false;
    }


     public void show(){
        CEntry<E>p=new CEntry<>();
         p=Cnode;
         if(p.getNext()==p){
             System.out.println(p.getValue());
         }else{
             while(p.getNext()!=Cnode){//当p.next！=Cnode时输出，最后一个结点.next==Cnode所以不能输出
                 System.out.println(p.getValue());
                 p=p.getNext();

             }
             System.out.println(p.getValue());//前面每输出一次，p=p.next，所以现在p指向最后一个结点，输出的就是最后一个结点
         }

     }

 }


//测试类
class  TestDemo{
    public static void main(String[] args) {
        DoulCirLNode<Integer>my=new DoulCirLNode<>();
        my.addTail(1);
        my.addTail(2);
        my.addTail(3);
        my.addTail(4);
        my.addTail(5);
        my.show();

        /*修改其实和查找一样，就是把查找成功的值替换而已，就不写了*/


        /*System.out.println("删除后链表为");
        my.deleteTail();
        my.show();*/
        System.out.println("查找值为?"+my.searchCnode(6));


    }
}

这个实现的是无头结点的双向循环链表，只能在尾部进行插入/删除操作