双向循环链表

public class Demo {
    public static void main(String[] args) {
        MyLinkList linkList = new MyLinkList();
        // 添加
        linkList.add("123");
        linkList.add("aaa");
        linkList.add("中国人");
        System.out.println("获取第0个元素：" + linkList.getNode(0));
        System.out.println("打印全部链表元素：" + linkList);
        // 添加到最前
        linkList.addFirst("ccc");
        System.out.println("在最前面添加ccc之后打印链表元素：" + linkList);
        // 添加到最后
        linkList.addLast("zzz");
        System.out.println("在最后面添加zzz之后打印链表元素：" + linkList);
        // 添加到指定位置
        linkList.add(4, "ggg");
        System.out.println("在第4个位置添加ggg之后打印链表元素：" + linkList);
        // 移除最前的
        linkList.removeFirst();
        System.out.println("移除最前面的元素之后打印链表元素：" + linkList);
        // 移除最后的
        linkList.removeLast();
        System.out.println("移除最后面的元素之后打印链表元素：" + linkList);
        // 移除指定位置上的
        linkList.remove(2);
        System.out.println("移除第二个位置上的元素之后打印链表元素：" + linkList);
        // 返回指定位置上的元素
        System.out.println("返回第一个位置上的元素：" + linkList.getNode(1));
        System.out.println("完成所有操作之后打印链表元素：" + linkList);
    }
}
class MyLinkList implements MyMethod {
    // 头节点
    private Node head = new Node(null);
    // 链表大小
    private int size;
    @Override
    public boolean add(int index, String data) {
        if (index < 0 || index >= getSize()) {
            throw new IndexOutOfBoundsException("数组下标越界！");
        } else {
            addBefore(new Node(data), getNode(index));
            return true;
        }
    }
    @Override
    public boolean add(String data) {
        return addLast(data);
    }
    @Override
    public boolean addFirst(String data) {
        addAfter(new Node(data), head);
        return true;
    }
    @Override
    public boolean addLast(String data) {
        addBefore(new Node(data), head);
        return true;
    }
    @Override
    public Node getNode(int index) {
        if (index < 0 || index >= size)
            throw new IndexOutOfBoundsException("数组下标越界！");
        Node node = head.next;
        for (int i = 0; i < index; i++)
            node = node.next;
        return node;
    }
    @Override
    public int getSize() {
        return size;
    }
    @Override
    public boolean remove(int index) {
        if (index < 0 || index >= size)
            throw new IndexOutOfBoundsException("数组下标越界！");
        removeNode(getNode(index));
        return true;
    }
    @Override
    public boolean removeFirst() {
        removeNode(head.next);
        return true;
    }
    @Override
    public boolean removeLast() {
        removeNode(head.prev);
        return false;
    }
    // 在指定节点的前一个节点进行插入
    private void addBefore(Node newNode, Node node) {
        // 要添加节点的下一个节点为指定节点
        newNode.next = node;
        // 要添加节点的前一个节点为指定节点的前一个
        newNode.prev = node.prev;
        // 要添加节点的下一个节点的前一个节点为要添加的节点
        newNode.next.prev = newNode;
        // 要添加节点的前一个节点的下一个节点为要添加的节点
        newNode.prev.next = newNode;
        // 长度自增
        size++;
    }
    // 在指定节点的后一个节点进行插入
    private void addAfter(Node newNode, Node node) {
        // 要添加节点的前一个节点为指定节点
        newNode.prev = node;
        // 要添加节点的下一个节点为指定节点的下一个
        newNode.next = node.next;
        // 要添加节点的下一个节点的前一个节点为要添加的节点
        newNode.next.prev = newNode;
        // 要添加节点的前一个节点的下一个节点为要添加的节点
        newNode.prev.next = newNode;
        // 长度自增
        size++;
    }
    // 删除节点
    private void removeNode(Node removeNode) {
        // 要删除节点的写一个节点的前一个节点为要删除节点的前一个节点
        removeNode.next.prev = removeNode.prev;
        // 要删除节点的前一个节点的下一个节点为要删除节点的下一个节点
        removeNode.prev.next = removeNode.next;
        // 要删除节点的下一个节点为null
        removeNode.next = null;
        // 要删除节点的前一个节点为null
        removeNode.prev = null;
        size--;
    }
    class Node {
        private String data;
        private Node prev = this;
        private Node next = this;
        public Node(String data) {
            this.data = data;
        }
        @Override
        public String toString() {
            return data;
        }
    }
    @Override
    public String toString() {
        StringBuffer sb = new StringBuffer();
        Node node = head;
        for (int i = 0; i < size; i++) {
            node = node.next;
            if (i > 0)
                sb.append(",");
            sb.append(node.data);
        }
        return sb.toString();
    }
}
interface MyMethod {
    // 添加元素
    public boolean add(String data);
    // 添加元素到最前面
    public boolean addFirst(String data);
    // 添加元素到最后面
    public boolean addLast(String data);
    // 在指定位置添加元素
    public boolean add(int index, String data);
    // 移除最前面的元素
    public boolean removeFirst();
    // 移除最后面的元素
    public boolean removeLast();
    // 移除指定位置上的元素
    public boolean remove(int index);
    // 获取指定位置上的元素
    public Node getNode(int index);
    // 获取链表的长度
    public int getSize();
}

　　执行结果：

获取第0个元素：123
打印全部链表元素：123,aaa,中国人
在最前面添加ccc之后打印链表元素：ccc,123,aaa,中国人
在最后面添加zzz之后打印链表元素：ccc,123,aaa,中国人,zzz
在第4个位置添加ggg之后打印链表元素：ccc,123,aaa,中国人,ggg,zzz
移除最前面的元素之后打印链表元素：123,aaa,中国人,ggg,zzz
移除最后面的元素之后打印链表元素：123,aaa,中国人,ggg
移除第二个位置上的元素之后打印链表元素：123,aaa,ggg
返回第一个位置上的元素：aaa
完成所有操作之后打印链表元素：123,aaa,ggg