java数据结构--循环双向链表的实现

package com.zjp.structures;

public class LoopDoubleLinkedList<T> {

    LDNode head;//不带数据的头结点

    public LoopDoubleLinkedList() {
        this.head = new LDNode();
        this.head.next = head;
        this.head.prev = head;
    }

    /**
     * 传入一个数组,转换成循环双链表
     *
     * @param arr
     */
    public LoopDoubleLinkedList(T[] arr) {
        this();
        if (arr != null && arr.length > 0) {
            LDNode p = new LDNode(arr[0]);
            head.next = p;
            head.prev = p;
            p.prev = head;
            p.next = head;
            int i = 1;
            while (i < arr.length) {
                p.next = new LDNode(arr[i++], p, head);
                head.prev = p.next;
                p = p.next;
            }
        }
    }

    /**
     * 判断循环双链表是否为空
     *
     * @return
     */
    public boolean isEmpty() {
        return head.next == head;//循环双链表的后继节点指向自己说明是空链表
    }

    /**
     * 循环双向链表的长度
     *
     * @return
     */
    public int length() {
        int length = 0;
        LDNode p = head.next;
        while (p != head) {
            length++;
            p = p.next;
        }
        return length;
    }

    /**
     * 根据下标获取元素值
     *
     * @param index
     * @return
     */
    public T get(int index) {
        if (index >= 0) {
            int j = 0;
            LDNode p = head.next;
            //寻找索引所在的节点
            while (p != head && j < index) {
                j++;
                p = p.next;
            }
            if (p != head) {
                return p.data;
            }
        }
        return null;
    }

    /**
     * 根据index修改data
     *
     * @param index
     * @param data
     * @return
     */
    public T set(int index, T data) {
        if (data == null) {
            return null;
        }
        if (index >= 0) {
            //寻找索引所在的节点
            int j = 0;
            LDNode p = head.next;
            while (p != head && j < index) {
                j++;
                p = p.next;
            }
            if (p != head) {
                T old = p.data;
                p.data = data;
                return old;
            }
        }
        return null;
    }

    /**
     * 根据index添加
     *
     * @param index
     * @param data
     * @return
     */
    public boolean add(int index, T data) {
        int size = length();
        if (data == null || index >= size) {
            return false;
        }
        //寻找插入节点的位置
        int j = 0;
        LDNode p = head.next;
        while (j < index && p.next != head) {
            j++;
            p = p.next;
        }
        //插入节点,若果index==3,则插入位置是4
        LDNode q = new LDNode(data, p, p.next);
        p.next.prev = q;
        p.next = q;
        return true;
    }

    /**
     * 尾部添加
     *
     * @param data
     * @return
     */
    public boolean add(T data) {
        //校验数据
        if (data == null) {
            return false;
        }
        LDNode p = new LDNode(data, head.prev, head);
        head.prev.next = p;
        head.prev = p;
        return true;
    }

    /**
     * 根据索引删除节点
     *
     * @param index
     * @return
     */
    public T remove(int index) {
        T old = null;
        //校验数据
        int size = length();
        if (index < 0 || index >= size) {
            return old;
        }
        //寻找要删除的节点
        int j = 0;
        LDNode p = head.next;
        while (j < index && p != head) {
            j++;
            p = p.next;
        }
        //删除节点
        if (p != head) {
            old = p.data;
            p.prev.next = p.next;
            p.next.prev = p.prev;
        }
        return old;
    }

    /**
     * 删除指定data的所有节点
     *
     * @param data
     * @return
     */
    public boolean removeAll(T data) {
        boolean isRemove = false;
        //校验数据
        if (data == null) {
            return isRemove;
        }
        //遍历删除
        LDNode p = head.next;
        while (p != head) {
            if (p.data.equals(data)) {
                p.prev.next = p.next;
                p.next.prev = p.prev;
                isRemove = true;
            }
            p = p.next;
        }
        return isRemove;
    }

    public void clear() {
        head.next = head;
        head.prev = head;
    }

    /**
     * 判断循环双链表中是否含有data
     * @param data
     * @return
     */
    public boolean contains(T data){
        if (data == null) {
            return false;
        }
        //遍历查找data
        LDNode p = head.next;
        while (p != head) {
            if (p.data.equals(data)) {
                return true;
            }
            p = p.next;
        }
        return false;
    }

    @Override
    public String toString() {
        String s = "{";
        LDNode p = head.next;
        while (p != head) {
            s += p.data;
            p = p.next;
            if (p != head) {
                s += ",";
            }
        }
        return s + "}";
    }

    public static void main(String[] args) {
        String[] arr = {"A", "B", "C", "D", "E", "F"};
        LoopDoubleLinkedList<String> loopDoubleLinkedList = new LoopDoubleLinkedList<String>(arr);
        System.out.println(loopDoubleLinkedList.length());
        System.out.println(loopDoubleLinkedList.get(3));
        System.out.println(loopDoubleLinkedList.contains("C"));
        System.out.println(loopDoubleLinkedList.contains("G"));
        System.out.println(loopDoubleLinkedList.isEmpty());
        System.out.println(loopDoubleLinkedList.toString());
        loopDoubleLinkedList.add(3, "H");
        System.out.println(loopDoubleLinkedList.toString());
        loopDoubleLinkedList.remove(4);
        System.out.println(loopDoubleLinkedList.toString());
        loopDoubleLinkedList.add("H");
        System.out.println(loopDoubleLinkedList.toString());
        loopDoubleLinkedList.removeAll("E");
        System.out.println(loopDoubleLinkedList.toString());
        loopDoubleLinkedList.set(2, "XXOO");
        System.out.println(loopDoubleLinkedList.toString());
    }

    class LDNode {
        //节点值
        T data;
        //前驱节点
        LDNode prev;
        //后继节点
        LDNode next;

        public LDNode(T data, LDNode prev, LDNode next) {
            this.data = data;
            this.prev = prev;
            this.next = next;
        }

        public LDNode() {
            this(null, null, null);
        }

        public LDNode(T data) {
            this(data, null, null);
        }

        @Override
        public String toString() {
            return data.toString();
        }
    }
}