双向链表

public class Demo {
    public static void main(String[] args) {
        MyLinkedList linkedList = new MyLinkedList();
        // 添加
        linkedList.add("123");
        linkedList.add("aaa");
        linkedList.add("中国人");
        System.out.println("获取长度为：" + linkedList.getSize());
        System.out.println("获取第0个元素：" + linkedList.getNode(0));
        System.out.println("打印全部链表元素：" + linkedList);
        // 添加到最前
        linkedList.addFirst("ccc");
        System.out.println("在最前面添加ccc之后打印链表元素：" + linkedList);
        // 添加到最后
        linkedList.addLast("zzz");
        System.out.println("在最后面添加zzz之后打印链表元素：" + linkedList);
        // 添加到指定位置
        linkedList.add(4, "ggg");
        System.out.println("在第4个位置添加ggg之后打印链表元素：" + linkedList);
        // 移除最前的
        linkedList.removeFirst();
        System.out.println("移除最前面的元素之后打印链表元素：" + linkedList);
        // 移除最后的
        linkedList.removeLast();
        System.out.println("移除最后面的元素之后打印链表元素：" + linkedList);
        // 移除指定位置上的
        linkedList.remove(2);
        System.out.println("移除第二个位置上的元素之后打印链表元素：" + linkedList);
        // 返回指定位置上的元素
        System.out.println("返回第一个位置上的元素：" + linkedList.getNode(1));
        System.out.println("完成所有操作之后打印链表元素：" + linkedList);
    }
}
class MyLinkedList implements MyMethods {
    private Node head = new Node(null);
    private int size;
    @Override
    public boolean add(String data) {
        addLast(data);
        return true;
    }
    @Override
    public boolean add(int index, String data) {
        if (index < 0 || index >= getSize())
            throw new NullPointerException("操作失败！");
        firstAdd(new Node(data), getNode(index));
        return true;
    }
    private void firstAdd(Node node, Node temp) {
        node.next = temp;
        node.prev = temp.prev;
        node.prev.next = node;
        node.next.prev = node;
        size++;
    }
    @Override
    public boolean addFirst(String data) {
        firstAdd(new Node(data), getNode(0));
        return true;
    }
    @Override
    public boolean addLast(String data) {
        lastAdd(data);
        return true;
    }
    private void lastAdd(String data) {
        if (getSize() == 0) {
            Node newNode = new Node(data);
            newNode.prev = head;
            newNode.prev.next = newNode;
            size++;
        } else {
            Node temp = getNode(getSize() - 1);
            Node node = new Node(data);
            node.prev = temp;
            node.prev.next = node;
            size++;
        }
    }
    @Override
    public int getSize() {
        return size;
    }
    @Override
    public boolean remove(int index) {
        if (index < 0 || index >= getSize())
            throw new NullPointerException("操作失败！");
        removeNodeFirst(getNode(index));
        return true;
    }
    @Override
    public boolean removeFirst() {
        removeNodeFirst(head.next);
        return true;
    }
    private void removeNodeFirst(Node node) {
        node.prev.next = node.next;
        node.next.prev = head;
        node.next = null;
        node.prev = null;
        size--;
    }
    @Override
    public boolean removeLast() {
        removeNodeLast(getNode(getSize() - 1));
        return true;
    }
    private void removeNodeLast(Node node) {
        node.prev.next = null;
        node.prev = null;
        size--;
    }
    @Override
    public Node getNode(int index) {
        Node node = head;
        if (index < 0 || index >= getSize())
            throw new NullPointerException("操作失败！");
        for (int i = -1; i < index; i++) {
            node = node.next;
        }
        return node;
    }
    class Node {
        private String data;
        private Node prev;
        private Node next;
        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 MyMethods {
    // 添加元素
    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();
}

　　执行结果：

获取长度为：3
获取第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