Java实现带头结点的循环双链表

最近又回顾了一下数据结构链表的实现，就随便写了一个带头结点的循环双链表的实现，如果有不当的地方，希望大家多多指教。

话不多说，代码走起

1. 准备工作，建立结点对象

public class Node {
        
    private String data;
    public Node pre;
    public Node next;  
    public Node() {
        super();
    }
    public Node(String data) {
        super();
        this.data = data;
    }

    public Node(String data, Node next) {
        super();
        this.data = data;
        this.next = next;
    }
    public Node(String data, Node pre, Node next) {
        super();
        this.data = data;
        this.pre = pre;
        this.next = next;
    }
    public String getData() {
        return data;
    }
    public void setData(String data) {
        this.data = data;
    }
    public Node getNext() {
        return next;
    }
    public void setNext(Node next) {
        this.next = next;
    }

    public Node getPre() {
        return pre;
    }

    public void setPre(Node pre) {
        this.pre = pre;
    }

//    @Override
//    public String toString() {
//        return "Node [data=" + data + ", pre=" + pre + ", next=" + next + "]";
//    }
//    
}

注意，这里重写toString不要带pre和next指针，否则相互引用，在debug时会循环调用toString方法，导致栈内存溢出。

2. 执行代码与测试

import com.example.demo.beans.Node;

/**
 * 带一个头结点的循环双链表(这里不需要尾节点)
 * @author hql
 *
 */
public class CycleDLinkList {
        private Node head;
        private int size;
        public CycleDLinkList() {
            super();
        }
        public CycleDLinkList(String ...args) {
            head=new Node(null);
            Node temp=head;
            for (int i = 0; i < args.length; i++) {
                Node oneNode=new Node(args[i]);
                temp.next=oneNode;
                oneNode.pre=temp;
                temp=oneNode;
                size++;
            }
            temp.next=head;
            head.pre=temp;
        }
        
       void addNullHead() {
           if(null==head) {
               head=new Node(null);
               head.next=head;
               head.pre=head;
           }
       }
       
       /**
        * 只用头部空节点的情况下插入一个节点
        * @param data
        */
       boolean addHeadFrist(String data) {
           //空节点
           addNullHead();
           //只有头结点
           Node temp=head;
           if(head.next==head&&head.pre==head) {
               Node node=new Node(data);
               temp.next=node;
               node.pre=temp;
               node.next=head;
               head.pre=node;
               temp=node;
               size++;
               return true;
           }
           return false;
       }
       
       /**
        * 向链表头部添加一个节点
        * @param data
        */
       void addFrist(String data) {
           if(addHeadFrist(data))  return ;
           Node node=new Node(data);
           head.next.pre=node;
           node.next=head.next;
           node.pre=head;
           head.next=node;
           size++;
       }
       
       /**
        * 向链表尾部插入一个节点
        * @param data
        */
       void addLast(String data) {
           if(addHeadFrist(data)) return;
           Node node=new Node(data);
           Node temp=head.pre;
           temp.next=node;
           node.pre=temp;
           node.next=head;
           head.pre=node;
           size++;
       }
       
       /**
        * 根据下标找到对应的元素
        * 规则：1. head节点不计入
        *               2. head.next节点为 0节点
        *               3. head.pre节点为 size节点
        * @param index
        * @return
        */
       Node getNode(int index) {
           if(index<0||index>=size) {
               System.out.println("输入参数不合法");
               return null;
           }
           if(index<=(size-1>>1)) {
               Node temp=head.next;
               for (int i = 0; i <= (size-1>>1); i++) {
                if(i==index) {
                    return temp;
                }
                temp=temp.next;
            }
           } else {
               Node temp=head.pre;
               for (int j = size-1; j >(size-1>>1); j--) {
                if(j==index) {
                    return temp;
                }
                temp=temp.pre;
            }
           }
           return null;
       }
       
       /**
        * 在任意位置添加一个节点
        * @param data
        * @param index
        */
       void add(String data,int index) {
           if(index<0||index>size) {
               System.out.println("输入参数不合法");
               return;
           }
           if(index==0) {
               addFrist(data);
               return;
           }
           if(index==size) {
               addLast(data);
               return;
           }
           Node temp=getNode(index-1);
           Node oneNode=new Node(data);
           temp.next.pre=oneNode;
           oneNode.next=temp.next;
           temp.next=oneNode;
           oneNode.pre=temp;
           size++;
       }
       
       boolean removeNullHead() {
           if(head==null) {
               System.out.println("链表为空，直接返回");
               return true;
           }
           return false;
       }
       
       /**
        * 如果只有一个元素，移除时，直接将整个链表置空
        */
       boolean removeHeadFrist() {
           if(removeNullHead()) return true;
           if(head.next==head.pre&&head.next!=head) {
               head=null;
               System.out.println("链表中只有一个元素,直接将链表置空");
               size=0;
               return true;
           }
           return false;
       }
       
       /**
        * 移除链表的第一个元素
        */
       void removeFrist() {
           if(removeHeadFrist()) return;
           head.next.next.pre=head;
           head.next=head.next.next;
           size--;
       }
       
       /**
        * 移除链表最后一个元素
        */
       void removeLast() {
           if(removeHeadFrist()) return;
           Node lastNode=head.pre;
           lastNode.pre.next=head;
           head.pre=lastNode.pre;
           size--;
       }
       
       /**
        * 按下标移除
        * @param index
        */
       void remove(int index) {
           if(index<0||index>=size) {
               System.out.println("输入参数不合法");
               return;
           }
           if(index==0) {
               removeFrist();
               return;
           }
           if(index==size) {
               removeLast();
               return;
           }
           Node temp= getNode(index-1);
           temp.next.next.pre=temp;
           temp.next=temp.next.next;
           size--;
       }
       
       String getNodeValue(Node node) {
           return node.getData();
       }
        public static void main(String[] args) {
//            CycleDLinkList cycleDLinkList=new CycleDLinkList("0","1","2");
            CycleDLinkList cycleDLinkList=new CycleDLinkList();
            cycleDLinkList.addNullHead();
            cycleDLinkList.addHeadFrist("1");
            cycleDLinkList.addFrist("0");
            cycleDLinkList.addLast("2");
            cycleDLinkList.addLast("3");
            cycleDLinkList.addLast("4");
//            Node node= cycleDLinkList.getNode(2);
            cycleDLinkList.add("3.5", 4);
//            cycleDLinkList.removeFrist();
            cycleDLinkList.removeFrist();
//            cycleDLinkList.removeLast();
//            cycleDLinkList.remove(1);
            Node temp=cycleDLinkList.head.next;
            while(temp!=cycleDLinkList.head) {
                    System.out.println(cycleDLinkList.getNodeValue(temp));
                    temp=temp.next;
            }
            System.out.println(cycleDLinkList.size);
        }
}

3. 运行测试结果符合预期