双向链表

单链表的缺点

• 查找的方向只能是一个方向。
• 节点不能自我删除。

双向链表与单链表比较

• 每个节点包含数据域, 指向下一个节点的 next(地址/引用)和多了一个上一个节点的 pre(地址/引用)。
• 单向链表是只能单方向查找节点, 而双向链表可以向前或向后查找节点。
• 单向链表不能自我删除, 而双向链表, 则可以自我删除节点。

双向链表的增删改查思路

• 遍历方法和单链表一样，只是可以向前，也可以向后查找。
• 添加（以添加到双向链表的最后为例）。

（1）先找到双向链表的最后节点。
（2）temp.next=新节点。
（3）新节点.pre = temp。

• 修改的思路和单项链表一样。
• 删除

（1）因为是双向链表，因此我们可以实现自我删除某个节点。
（2）直接找到要删除的这个节点，比如temp。
（3）temp.pre.next=temp.next。
（4）temp.next.pre = temp.pre。

代码示例

/** 定义链表节点类*/
class DataNode {
    /** 节点编号*/
    public int no;
    /** 节点标题*/
    public String title;
    /** 指向下一个节点, 如果是 null, 则当前节点为尾节点*/
    public DataNode next;
    /** 指向上一个节点, 如果是 null, 则当前节点为头节点*/
    public DataNode pre;

    public DataNode() {}

    public DataNode(int no, String title) {
        this.no = no;
        this.title = title;
    }

    @Override
    public String toString() {
        return "DataNode [no=" + no + ", title=" + title + "]";
    }
}

/** 定义双向链表类*/
class DoubleLinkedList {
    /** 初始化头节点, 此节点不设定数据*/
    private DataNode head = new DataNode();

    /**
     * 添加新节点:
     * 给尾部节点的 next指向新的节点引用
     * */
    public void add(DataNode dataNode) {
        /** 为了从头节点开始往后遍历找出尾部节点*/
        DataNode temp = head;
        /** 遍历找出尾部节点*/
        while(true) {
            /** 当前节点为尾部节点便停止循环*/
            if(temp.next == null) {
                break;
            }
            /** 如果当前节点不为尾部节点, 则再往后移*/
            temp = temp.next;
        }
        /** 将新的节点引用加到, 当前(尾部)节点的 next变量中, 同时当前节点引用加到新节点的 pre变量中*/
        temp.next = dataNode;
        dataNode.pre = temp;
    }

    /** 遍历所有节点*/
    public void print() {
        if(head.next == null) {
            System.out.println("链表为空!");
            return;
        }
        /** 头节点不能被覆盖, 所有先使用辅助变量转移第一个(有效)节点*/
        DataNode temp = head.next;
        while(true) {
            /** 到了链表尾部时停止遍历*/
            if(temp == null) {
                break;
            }
            /** 输出当前节点的信息*/
            System.out.println(temp);
            /** 往后移一个节点, 继续遍历*/
            temp = temp.next;
        }
    }

    /** 排序添加(添加时根据编号排序)*/
    public void addByOrder(DataNode dataNode) {
        DataNode temp = head;
        /** 标记: 是否重复*/
        boolean bRepeat = false;
        while(true) {
            /** 到了链表尾部时停止遍历*/
            if(temp.next == null) {
                break;
            }
            /** 找到了, 排序位*/
            if(temp.next.no > dataNode.no) {
                break;
            } else if (temp.next.no == dataNode.no) {
                /** 编号重复*/
                bRepeat = true;
                break;
            }
            /** 往后移一个节点, 继续遍历*/
            temp = temp.next;
        }
        /** 判断编号是否重复*/
        if(bRepeat) {
            System.out.printf("重复节点 %d, 不能添加\n", dataNode.no);
        } else {
            dataNode.next = temp.next;
            if (temp.next != null) temp.next.pre = dataNode;
            temp.next = dataNode;
            dataNode.pre = temp;
        }
    }

    /** 链表删除*/
    public void del(int no) {
        if(head.next == null) {
            System.out.println("链表为空!");
            return;
        }
        DataNode temp = head.next;
        boolean flag = false;
        while (true) {
            if (temp == null) {
                break;
            }
            if(temp.no == no) {
                flag=true;
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            temp.pre.next = temp.next;
            if (temp.next != null) temp.next.pre = temp.pre;
        }else {
            System.out.printf("要删除的编号 %d 节点不存在", no);
        }
    }

}

public class DoubleLinkedListApp {
    public static void main(String[] args) {
//        /** 创建链表实例*/
//        DoubleLinkedList list = new DoubleLinkedList();
//        /** 添加节点*/
//        list.add(new DataNode(4, "节点4"));
//        list.add(new DataNode(2, "节点2"));
//        list.add(new DataNode(1, "节点1"));
//        list.add(new DataNode(3, "节点3"));
//        /** 输出所有节点*/
//        list.print();

        /** 创建链表实例*/
        DoubleLinkedList list = new DoubleLinkedList();
        list.addByOrder(new DataNode(4, "节点4"));
        list.addByOrder(new DataNode(2, "节点2"));
        list.addByOrder(new DataNode(1, "节点1"));
        list.addByOrder(new DataNode(3, "节点3"));
        System.out.println("原链表:");
        list.print();

        list.del(2);
        System.out.println("删除后的链表:");
        list.print();
    }
}

输出:
> 原链表:
> DataNode [no=1, title=节点1]
> DataNode [no=2, title=节点2]
> DataNode [no=3, title=节点3]
> DataNode [no=4, title=节点4]
> 删除后的链表:
> DataNode [no=1, title=节点1]
> DataNode [no=3, title=节点3]
> DataNode [no=4, title=节点4]