JAVA实现双向循环排序链表添加和删除操作

前奏

双向循环链表特点：一个节点分为3部分，上节点(preNode)、下节点(nextNode) nodeData(当前节点数据)

节点代码

//创建一个节点类
class MyNode{
    public Object obj;              //当前节点的节点元素
    public MyNode nextNode;         //当前节点的下一个节点
    public MyNode preNode;          //当前节点的上一个节点

    //使用构造方法初始化对应的参数
    public MyNode(Object obj){
        this.obj=obj;
    }
    public MyNode(){}
    @Override
    public String toString() {
        return ("当前节点内容："+obj+"下一个节点:"+(nextNode==null?"空":""+nextNode.obj)+"上一个节点"+(preNode==null?"空":""+preNode.obj));
    }
}

双向链表思路图解：

添加思路：

1：由于是循环链表判断什么时候为链表的最后一个节点,提示当更新完最后一个节点信息进行一个判断currNode.next==headNode.nextNode break; 即可
2：判断链表一开始为空怎么处理新节点
3：判断当前新节点在链表第一个位置怎么处理 提示：要更新尾节点、原第一个节点、头节点指向
4：判断当前新节点在链表最后一个位置怎么处理 提示：要更新链表第一个节点、最后一个节点
5：判断当前新节点在链表中间位置怎么处理

删除思路：

1：删除的节点是链表的第一个节点怎么处理 注意：获取尾节点对节点的nextNode更新及preNode更新(preNode节点如果刚好是链表第一个节点的时候 需要更新 其余无需更新) 要更新头节点的指向位置
2：当删除一个节点的时候该节点刚好是链表唯一节点 这时候怎么处理 提示：将headNode.nextNode=null;即可
3：当删除节点为链表的末尾位置怎么处理
4：当删除节点为链表的中间位置怎么处理

JAVA代码：

package com.king2.dataStructer.linked;


//双向链表演示
public class BothWayLinkedDemo {

    public static void main(String[] args) {
        MyBothWayLinked linked=new MyBothWayLinked();
        linked.addLoopNodeOrderBy(2);
        linked.addLoopNodeOrderBy(1);
        linked.addLoopNodeOrderBy(3);
        linked.addLoopNodeOrderBy(4);
        linked.deleteLoopNode(1);
        linked.deleteLoopNode(2);
        linked.deleteLoopNode(4);
        linked.showNode();

    }
}

//创建一个双向链表类
class MyBothWayLinked{

    //创建一个头结点
    private MyNode headNode=new MyNode();


    //创建双向链表添加方法
    public void addNode(Object obj){

        //创建一个新节点封装添加的信息
        MyNode newNode=new MyNode(obj);

        //获取头节点 用于牵引整个链表的开始节点
        MyNode currHeadNode=headNode;

        //遍历整个链表
        while(currHeadNode.nextNode!=null){
            //更新当前节点新 直到最后一个节点为止
            currHeadNode=currHeadNode.nextNode;
        }
        //更新新节点信息
        newNode.preNode=currHeadNode;
        //更新currHeadNode节点信息
        currHeadNode.nextNode=newNode;
    }


    //创建双向链表添加方法(排序)
    public void addNodeOrderBy(Object obj){
        //创建一个新节点封装添加的信息
        MyNode newNode=new MyNode(obj);

        //获取头节点信息
        MyNode currHeadNode=headNode;

        //创建一个辅助节点 用于做比较用
        MyNode currNextNode=null;

        while(currHeadNode.nextNode!=null){
            //获取当前节点的下一个相依节点
            currNextNode=currHeadNode.nextNode;

            if(Integer.parseInt(currNextNode.obj.toString())>Integer.parseInt(obj.toString())){
                break;
            }
            //更新节点信息
            currHeadNode=currNextNode;
        }

        //更新新节点的向上下相依节点信息
        newNode.preNode=currHeadNode;
        newNode.nextNode=currHeadNode.nextNode;

        //判断当前节点的向下相依节点是否为空
        if(currHeadNode.nextNode!=null) currHeadNode.nextNode.preNode=newNode;

        //更新当前节点信息
        currHeadNode.nextNode=newNode;
    }

    //创建双向循环链表添加方法
    public void addLoopNode(Object obj){

        //创建一个新节点封装新的信息
        MyNode newNode=new MyNode(obj);

        //获取头节点信息
        MyNode currHeadNode=headNode;

        //遍历链表
        while(currHeadNode.nextNode!=null){

            //更新当前节点信息
            currHeadNode=currHeadNode.nextNode;

            //判断当前节点的下一个相依节点是否是头结点的第一个节点 相同的话代表当前节点是最后一个几点
            if(currHeadNode.nextNode==headNode.nextNode){
                break;
            }
        }

        //当前链表开始为空
        if(currHeadNode==headNode){

            //更新当前新节点的向上下相依节点
            newNode.preNode=newNode;
            newNode.nextNode=newNode;
        }else{
            //更新当前新节点的向上下相依节点
            newNode.preNode=currHeadNode;
            newNode.nextNode=currHeadNode.nextNode;

            //更新的链表第一个节点的向上相依节点信息
            headNode.nextNode.preNode=newNode;
        }
        //更新当前节点信息
        currHeadNode.nextNode=newNode;
    }

    //创建双向循环链表添加方法(排序)
    public void addLoopNodeOrderBy(Object obj){

        //创建一个新节点 封装新信息
        MyNode newNode=new MyNode(obj);

        //获取头结点
        MyNode currHeadNode=headNode;

        //创建一个辅助节点
        MyNode currNextNode=null;

        //循环整个链表
        while(currHeadNode.nextNode!=null){

            //获取当前节点的向下相依节点信息
            currNextNode=currHeadNode.nextNode;

            //判断currNextNode节点信息与obj信息做比较
            if(Integer.parseInt(currNextNode.obj.toString())>Integer.parseInt(obj.toString())){
                break;
            }
            //更新当前节点信息
            currHeadNode=currNextNode;

            //判断当前节点是否是最后一个节点
            if(currHeadNode.nextNode==headNode.nextNode){
                break;
            }
        }

        //当整个链表为空的情况下怎么处理
        if(currHeadNode.nextNode==null){

            //更新新节点的向上下相依节点信息
            newNode.preNode=newNode;
            newNode.nextNode=newNode;

            //更新当前节点的向下相依节点
            currHeadNode.nextNode=newNode;
        }

        //当前新节点作为第一个节点怎么处理
        else if(currHeadNode==headNode){

            //获取尾节点新
            MyNode currNode=headNode;
            while(currNode.nextNode!=null){
                currNode=currNode.nextNode;
                //判断是否是最后一个
                if(currNode.nextNode==headNode.nextNode)break;
            }
            //更新尾节点的向下相依节点信息
            currNode.nextNode=newNode;

            //更新当前新节点信息
            newNode.preNode=currNode;
            newNode.nextNode=currHeadNode.nextNode;

            //更新当前节点的向下相依节点的向上相依节点
            currHeadNode.nextNode.preNode=newNode;

            //更新当前节点的向下相依节点
            currHeadNode.nextNode=newNode;
        }
        //当新节点在整个链表的最后怎么处理
        else if(currHeadNode.nextNode==headNode.nextNode){
            //更新新节点信息
            newNode.preNode=currHeadNode;
            newNode.nextNode=currHeadNode.nextNode;

            //更新当前节点信息
            currHeadNode.nextNode=newNode;

            //更新第一个节点的向上相依节点信息
            headNode.nextNode.preNode=newNode;
        }
        //当新节点在整个链表的中间怎么处理
        else{
            //更新当前新节点信息
            newNode.preNode=currHeadNode;
            newNode.nextNode=currHeadNode.nextNode;

            //更新当前节点的向下相依节点的向上相依节点信息
            currHeadNode.nextNode.preNode=newNode;

            //更新当前节点信息
            currHeadNode.nextNode=newNode;
        }
    }

    //创建双向链表删除方法
    public boolean deleteNode(Object obj){
        //获取头节点信息
        MyNode currHeadNode=headNode;

        //创建一个辅助变量
        MyNode currNextNode=null;

        //遍历整个链表
        while(currHeadNode.nextNode!=null){

            //获取当前节点下的相依节点信息
            currNextNode=currHeadNode.nextNode;

            //判断currNextNode内容是否一致
            if(currNextNode.obj.equals(obj)){
                //判断当前currNextNode向下的节点是否为空
                if(currNextNode.nextNode!=null){
                    currHeadNode.nextNode.preNode=currHeadNode;
                }
                currHeadNode.nextNode=null;

                return true;
            }
        }
        return false;
    }

    //创建双向循环链表删除方法
    public boolean deleteLoopNode(Object obj){
        //获取头节点信息
        MyNode currHeadNode=headNode;

        //创建一个辅助节点
        MyNode currNextNode=null;

        //遍历整个链表
        while(currHeadNode.nextNode!=null){

            //获取当前节点的向下相依节点信息
            currNextNode=currHeadNode.nextNode;

            //判断当前currNextNode的内容与obj是否一致
            if(currNextNode.obj.equals(obj)){

                //判断currNextNode是否是第一个节点
                if(currNextNode==headNode.nextNode){

                    //获取尾节点信息
                    MyNode currNode=headNode;
                    while(currNode.nextNode!=null){
                        //更新当前节点
                        currNode=currNode.nextNode;

                        //判断当前节点是否是最后一个
                        if(currNode.nextNode==headNode.nextNode){
                            break;
                        }
                    }
                    //判断有效节点是否是一个
                    if(currNextNode.nextNode==currNextNode){
                        currHeadNode.nextNode=null;
                    }else{
                        //更新尾节点的向上下相依节点信息
                        if(currNode.preNode==currNextNode){
                            currNode.preNode=currNode;
                        }
                        currNode.nextNode=currNextNode.nextNode;

                        //更新当前节点信息
                        currHeadNode.nextNode= currNextNode.nextNode;

                        //更新当前节点的下一个节点的上一个节点新
                        currNextNode.nextNode.preNode=currNode;

                    }
                }
                //判断currNextNode是否是最后一个
                else if(currNextNode.nextNode==headNode.nextNode){
                    //更新当前节点的向下相依节点信息
                    currHeadNode.nextNode=currNextNode.nextNode;

                    //更新链表的第一个节点的向上节点
                    headNode.nextNode.preNode=currHeadNode;
                }
                //在中间
                else{
                    //更新当前节点的向下相依节点信息
                    currHeadNode.nextNode=currNextNode.nextNode;

                    currNextNode.nextNode.preNode=currHeadNode;
                }
                return true;
            }
            currHeadNode=currNextNode;
            if(currHeadNode.nextNode==headNode.nextNode)break;
        }
        return false;
    }

    //创建显示节点信息
    public void showNode(){

        //获取头节点
        MyNode currHeadNode=headNode;
        while(currHeadNode.nextNode!=null){
            System.out.println(currHeadNode.nextNode);

            currHeadNode=currHeadNode.nextNode;
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }

    }

}

结果