双向链表的实现（java）

对于单链表，如果要插入某一个节点或者是删除某一个节点，需要用到一个辅助指针来找到待删除节点的前一个节点，改变它的next域的指向，从而实现删除操作；

对于双向链表，好处即使，双向链表可以实现从后往前的遍历（单链表也可以实现，但是可能会稍微麻烦一点），而且双向链表在删除节点的时候，与单链表的不同之处就在于，它是直接让辅助指针指向待删除的节点，对这个节点的pre域和next域进行修改，从而实现删除操作；

具体实现代码如下：（包含：遍历、在末尾添加、按顺序添加、删除操作）

package com.Link;

public class DoubleLinkedList {
    public static void main(String[] args) {

        //双向链表的测试
        System.out.println("双向链表的测试");
        //先创建节点
        HeroNode2 hero1 = new HeroNode2(1,"宋江","及时雨");
        HeroNode2 hero2 = new HeroNode2(2,"卢俊义","玉麒麟");
        HeroNode2 hero3 = new HeroNode2(3,"吴用","智多星");
        HeroNode2 hero4 = new HeroNode2(4,"林冲","豹子头");
        //创建一个双向链表
        DoubleLinkList doubleLinkList = new DoubleLinkList();
        //往双向链表中添加节点
        doubleLinkList.add(hero1);
        doubleLinkList.add(hero2);
        doubleLinkList.add(hero3);
        doubleLinkList.add(hero4);

        doubleLinkList.list();

        //修改
        HeroNode2 newHeroNode = new HeroNode2(4,"花和尚","鲁智深");
        doubleLinkList.update(newHeroNode);
        System.out.println("修改过后的双向链表的情况");
        doubleLinkList.list();

        //删除
        doubleLinkList.deleteNode(2);
        System.out.println("删除过后的双向链表的情况");
        doubleLinkList.list();

        //按照顺序添加
        System.out.println("按照顺序添加后的双向链表的情况");
        HeroNode2 newSequenceNode = new HeroNode2(2,"武松","行者");
        doubleLinkList.addSequence(newSequenceNode);
        doubleLinkList.list();
    }
}

class DoubleLinkList {

    //先初始化一个头节点，头节点不要动，不存放具体数据
    HeroNode2 head = new HeroNode2(0,"","");

    //返回头节点
    public HeroNode2 getHead() {
        return head;
    }

    //遍历双向链表的方法，遍历方法与遍历单链表一样
    public void list() {
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        HeroNode2 temp = head.next;
        while (temp != null) {
            System.out.println(temp);
            temp = temp.next;
        }
    }

    //往双向链表的末尾添加一个新的节点
    public void add(HeroNode2 heroNode2) {
        HeroNode2 temp = head;
        //遍历链表，找到最后的节点
        while (temp.next != null) {
            temp = temp.next;
        }
        //形成一个双向链表
        temp.next = heroNode2;
        heroNode2.next = null;
        heroNode2.pre = temp;
    }

    //修改双向链表中的节点，基本和单链表的修改操作是一致的
    public void update(HeroNode2 heroNode2) {
        boolean flag = false;
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        HeroNode2 temp = head.next;
        while (true) {
            if (temp.no == heroNode2.no) {
                temp.name = heroNode2.name;
                temp.nickname = heroNode2.nickname;
                flag = true;
                break;
            }
            if (temp == null) {
                break;   //已经遍历完链表
            }
            temp = temp.next;
        }
        if (flag == false) {
            System.out.printf("没有找到编号为 %d 的节点，不能修改\n",heroNode2.no);
        }
    }

    //从双向链表中删除一个节点
    //1、对于双向链表，可以直接找到要删除的这个节点
    //2、找到该节点后，自我删除即可
    public void deleteNode(int no) {
        HeroNode2 temp = head.next;
        if (temp == null) {
            System.out.println("链表为空，不能删除");
            return;
        }
        while (true) {
            if (temp == null) {
                System.out.println("已经到了链表的最后，没有找到该节点，无法删除");
                return;
            }
            if (no == temp.no) {  //删除节点
                temp.pre.next = temp.next;
                //如果是最后一个节点，就不需要执行下面这个语句，否则会出现空指针异常
                //如果是最后一个节点，它的next就是空了，空指针的pre就没有意义，会报错
                if (temp.next != null) {
                    temp.next.pre = temp.pre;
                }

                System.out.printf("找到编号为 %d 的节点，可以进行删除\n",temp.no);
                break;
            }
            temp = temp.next;
        }
    }

    //按照编号的顺序，对双向链表进行添加节点
    public void addSequence(HeroNode2 heroNode2) {
        HeroNode2 temp = head;
        while (true) {
            if (temp.next == null && temp.no != heroNode2.no) {
                System.out.println("temp已经是最后一个节点，且新节点的no不等于temp的no，则在temp后面直接插入新节点即可");
                temp.next = heroNode2;
                heroNode2.pre = temp;
                heroNode2.next = null;
                return;
            }
            if (temp.no == heroNode2.no) {
                System.out.printf("已经存在编号为 %d 的节点，不能进行添加\n",temp.no);
                return;
            }
            if (temp.no > heroNode2.no) {
                break;
            }
            temp = temp.next;
        }
        heroNode2.next = temp;
        temp.pre.next = heroNode2;
        heroNode2.pre = temp.pre;

    }
}

class HeroNode2 {
    public int no;
    public String name;
    public String nickname;
    public HeroNode2 next;   //指向下一个节点，默认为null
    public HeroNode2 pre;   //指向前一个节点，默认为null
    //构造器
    public HeroNode2(int no, String name, String nickname) {
        this.no = no;
        this.name = name;
        this.nickname = nickname;
    }
    //为了显示方便，重更新toString
    @Override
    public String toString() {
        return "HeroNode [no=" + no + ", name=" + name + ", nickname=" + nickname + "]";
    }
}