Java简单双向链表实现 @version 1.0

package com.list;

/**
 * 数据结构和算法Java表示 双向链表
 * 
 * @version 1.0
 * @author 小明
 *
 */
public class MyDoublelinkedlist {
    private DoubleNode head;// 头结点
    private DoubleNode end;// 尾结点
    private int size;// 长度
    // 构造函数

    public MyDoublelinkedlist() {
        head = null;// 头结点
        end = null;// 尾结点
        size = 0;// 长度为0
    }

    // 重写toString方法
    @Override
    public String toString() {
        DoubleNode temp = head;// 将头结点赋值给temp变量
        String str = " ";
        for (; temp != null;) {
            str += temp.getElement() + " ";// 字符串拼接
            temp = temp.getNext();// temp结点后移
        }
        str = "[" + str + " ]";
        return str;
    }

    // 插入方法,默认插入在链表的尾端
    public void add(DoubleNode dn) {
        if (size == 0) {// 长度为0，表为空，插入在表首
            head = dn;// 头结点被赋值
            end = dn;// 尾结点被赋值
            size++;// 长度加一
        } else {// 长度不为0，表不为空时，插入至表的最后一位
            end.setNext(dn);// 表尾的后继为插入元素
            dn.setPrev(end);// 插入元素的前驱为head
            end = dn;// 重新赋值表尾
            size++;
        }
    }

    // 插入方法，插入到指定的位置
    public void add(int index, DoubleNode dn) throws IndexException {
        DoubleNode temp = head;
        if (index <= 0 || index > size + 1) {// 插入位置不合理
            throw new IndexException("插入索引位置不合理");
        } else {// 插入位置合理
            if (size == 0) {// 表为空时，调用add默认函数来实现插入首位
                add(dn);
                return;
            }
            if (index == 1) {// 表不为空时插入位置在头结点
                head.setPrev(dn);// 设置头结点的前驱
                dn.setNext(head);// 设置新的头结点的后继
                head = dn;// 设置新的头结点
                size++;// 长度加一
            } else {// 索引合理，插入位置不在头结点
                if (index == size + 1) {// 插入索引在尾结点
                    add(dn);// 使用默认add函数插入表尾
                    return;
                } else {// 索引合理，插入不在头结点也不再尾结点
                    for (int i = 1; i < index - 1; i++) {
                        temp = temp.getNext();// 移至目标位置的前一位
                    }
                    dn.setNext(temp.getNext());// 完成插入节点的后继
                    dn.setPrev(temp);// 完成插入节点的前驱
                    temp.getNext().setPrev(dn);// 设置插入节点的后继的前驱
                    temp.setNext(dn);// 完成插入节点的前驱的后继
                    size++;// 长度加一
                }
            }
        }
    }

    /*
     * 删除函数
     */
    public void remove(int index) throws IndexException {
        DoubleNode temp = head;
        if (index <= 0 || index > size) {// 移除位置不合理
            throw new IndexException("删除位置不合理");
        } else {// 删除位置合理
            if (size == 0) {
                throw new IndexException("表为空无法删除");
            } else {// 删除位置合理且表不位空
                if (index == 1) {// 删除位置为头节点
                    head.getNext().setPrev(null);// 设置新的节点为null
                    head = head.getNext();// 设置新的节点
                    size--;// 长度减一
                } else {// 删除位置合理且表不位空且删除位置不在头结点
                    if (size == index) {// 删除位置合理且表不位空且删除位置不在头结点在尾结点
                        for (; temp.getNext() != end;) {
                            temp = temp.getNext();// 后移至倒数第二个结点
                        }
                        temp.setNext(null);// 删除表尾
                        end = temp;// 新的表尾
                        size--;// 长度减一
                    } else {// 删除位置合理且表不位空且删除位置不在头结点也不再尾结点
                        for (int i = 1; i < index - 1; i++) {
                            temp = temp.getNext();
                        }
                        temp.setNext(temp.getNext().getNext());// 设置新的后继
                        temp.getNext().setPrev(temp);// 设置新的前驱
                        size--;// 长度减一
                    }
                }
            }

        }
    }

    public static void main(String[] args) throws IndexException {
        MyDoublelinkedlist dl = new MyDoublelinkedlist();
        dl.add(new DoubleNode(1));
        dl.add(new DoubleNode(2));
        dl.remove(1);
        System.out.println(dl);
    }
}

/*
 * 双向链表的结点 一个值域，两个指针域
 */
class DoubleNode<T> {
    private T element;// 值域
    private DoubleNode prev;// 前驱
    private DoubleNode next;// 后继
    // 构造函数

    public DoubleNode(T t) {
        element = t;
        prev = null;
        next = null;
    }

    public void setPrev(DoubleNode dn) {
        prev = dn;
    }

    public void setNext(DoubleNode dn) {
        next = dn;
    }

    public DoubleNode getPrev() {
        return prev;
    }

    public DoubleNode getNext() {
        return next;
    }

    public T getElement() {
        return element;
    }
}