双向链表的实现

双向链表

思想

通过前面的学习：单向链表的实现_Land-Cruise的博客-CSDN博客

单链表有以下几个缺点：

1.单向链表，查找的方向只能是一个方向，而双向链表可以向前或者向后查找。

2.单向链表不能自我删除，需要靠辅助节点 ，而双向链表，则可以自我删除，所以前面我们单链表删除时节点，总是找到temp,temp是待删除节点的前一个节点(认真体会).

具体实现

相比于单向链表，总的理解不差。

1.双向链表的遍历和单向链表一样，可以向前/后遍历

//遍历链表
    public void list() {
        //先判断链表是否为空
        if (headNode.next == null) {
            System.out.println("链表为空，不能遍历！");
            return;
        }
        //不为空，那么向后遍历，头结点不能动
        HeroNode temp = headNode.next;
        while (true) {
            if (temp == null) {
                break;
            }
            System.out.println(temp);
            temp = temp.next;
        }
    }

2.添加和单向链表一样，也可以有两种添加方式(默认是添加到链表的最后)

​ 1）先找的链表的最后一个节点

​ 2）temp.next = newHeroNode

​ 3）newHeroNode.pre = temp

//添加元素到链表，头结点不能动
    //第一种添加英雄的方式 不按顺序，往链表尾部添加
    public void add(HeroNode heroNode) {
        //头结点不能动 所以定义一个辅助节点用来遍历链表
        HeroNode temp = headNode;
        //先找到链表尾，从尾部加入新的节点，所以先遍历
        while (true) {
            //当temp==null的时候，就找到最后节点的位置
            if (temp.next == null) {
                break;
            }
            temp = temp.next;
        }
        //当跳出循环后，就说明找到了链表尾部
        temp.next = heroNode;
        heroNode.pre = temp;
    }

3.修改和单向链表一样，不需要改动

//修改节点信息
    //以no为查询条件，进行修改
    public void update(HeroNode newHeroNode) {
        //先判断是否为空
        if (headNode.next == null) {
            System.out.println("链表为空，不能修改！");
            return;
        }
        //头结点不能动，定义一个辅助指针
        HeroNode temp = headNode.next;
        //定义一个flag，用来判断是否找到该节点
        boolean flag = false;
        while (true) {
            //如果temp==null 说明找到链表尾部还没有找到
            if (temp == null) {
                System.out.println("该链表没有该元素！");
                break;
            } else if (temp.no == newHeroNode.no) {
                //temp.no==newHeroNode.no  说明找到了
                flag = true;
                break;
            }
            temp = temp.next;//后移操作
        }
        if (flag) {
            temp.name = newHeroNode.name;
            temp.nickname = newHeroNode.nickname;
        }
    }

4.删除

​ 1）因为是双向链表，可以自我删除，所以不用找到需要删除的前一个节点

​ 2）先通过遍历找到要删除的节点temp

​ 3）temp.pre.next = temp.next

​ 4）temp.next.pre = temp.pre 注意，如果temp是链表的最后一个节点，那么就不需要执行这一步，因为temp.next为null，而null.pre会报空指针异常，所以这一步骤是要删除的节点不在最后即可。

//删除指定no的节点
    //思路: 先找到要删除节点temp
    //再将 temp.next.pre=temp.pre  temp.pre.next = temp.next   temp就没有引用指向它，那么他就会被jvm回收
    public void delete(int no) {
        //先判断是否为空
        if (headNode.next == null) {
            System.out.println("链表为空，不能删除！");
            return;
        }
        //头结点不能动，定义一个辅助指针
        HeroNode temp = headNode;
        while (true) {
            //如果temp==null 说明找到链表尾部还没有找到
            if (temp == null) {
                break;
            } else if (temp.no == no) {
                temp.pre.next = temp.next;
                //这里有问题，如果要删除的节点刚好是最后一个节点时
                //temp.next为空，空的pre会出现空指针异常
                //当是最后一个节点时，下面就不用操作了
                if (temp.next != null) {
                    temp.next.pre = temp.pre;
                }
                return;
            }
            temp = temp.next;//后移
        }
        System.out.println("没有找到要删除的节点！");
    }

第二种添加方式(自动排序添加方式)

1.通过遍历找到要添加节点的位置 temp 的后面（按英雄编号 找到比要插入节点大的前一个元素）

2.如果要添加的位置不在链表最后。

​ 1）先创建一个临时节点用来存放比该节点大的后面的链表，cur = temp.next

​ 2）将临时节点的pre指向添加的节点，cur.pre = newHeroNode

​ 3）将要添加的节点的pre指向temp，newHeroNode.pre = temp

​ 4）将temp的next指向要添加的节点，temp.next = newHeroNode

​ 5）将要添加的节点的next指向临时节点cur，newHeroNode.next = cur

3.如果要添加的位置在链表最后

​ 1）temp.next = newHeroNode

​ 2）newHeroNode.pre = temp

代码实现

//第二种添加方式，为顺序添加，根据hero.no的排名添加
    //如果链表中有这个节点，那么添加失败
    public void addByOrder(HeroNode heroNode) {
        //头节点不能动 定义一个辅助指针
        HeroNode temp = headNode;
        while (true) {
            //当temp==null时，就遍历到链表的最后位置还没有找到加入的位置，就加入到最后
            if (temp.next == null) {
                break;
            }
            //当temp.next.no>heroNode.no时，就找到位置，在temp后边
            if (temp.next.no > heroNode.no) {
                HeroNode cur = temp.next;
                cur.pre = heroNode;
                heroNode.pre = temp;
                temp.next = heroNode;
                heroNode.next = cur;
                return;
            } else if (temp.next.no == heroNode.no) {//当temp.next.no==heroNode.no时，说明链表中有该值，则flag=true;
                System.out.println(heroNode.no + "该值存在，不能再次加入！");
            }
            temp = temp.next;
        }
        temp.next = heroNode;
        heroNode.pre = temp;
    }

完整代码

节点类

package com.datestructures.linkedlist;

public class HeroNode {
    //定义节点
    //这里以水浒传为例
    public int no;//排名
    public String name;
    public String nickname;
    public HeroNode next;//指向下一个节点  默认值null
    //双向链表会用到，单向链表不用管
    public HeroNode pre;//指向前一个节点   默认值null

    public HeroNode(int no, String name, String nickname) {
        this.no=no;
        this.name=name;
        this.nickname=nickname;
    }

    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickname='" + nickname + '\'' +
                '}';
    }
}

双向链表类

package com.datestructures.linkedlist;

public class DoubleLinkedList {
    /**
     * 双向链表
     */
    //初始化链表
    //创建一个头结点
    private HeroNode headNode = new HeroNode(0, "", "");

    //返回头结点
    public HeroNode getHeadNode() {
        return headNode;
    }

    //添加元素到链表，头结点不能动
    //第一种添加英雄的方式 不按顺序，往链表尾部添加
    public void add(HeroNode heroNode) {
        //头结点不能动 所以定义一个辅助节点用来遍历链表
        HeroNode temp = headNode;
        //先找到链表尾，从尾部加入新的节点，所以先遍历
        while (true) {
            //当temp==null的时候，就找到最后节点的位置
            if (temp.next == null) {
                break;
            }
            temp = temp.next;
        }
        //当跳出循环后，就说明找到了链表尾部
        temp.next = heroNode;
        heroNode.pre = temp;
    }

    //第二种添加方式，为顺序添加，根据hero.no的排名添加
    //如果链表中有这个节点，那么添加失败
    public void addByOrder(HeroNode heroNode) {
        //头节点不能动 定义一个辅助指针
        HeroNode temp = headNode;
        //定义一个flag 用来判断链表中是否含有这个值
        while (true) {
            //当temp==null时，就遍历到链表的最后位置还没有找到加入的位置，就加入到最后
            if (temp.next == null) {
                break;
            }
            //当temp.next.no>heroNode.no时，就找到位置，在temp后边
            if (temp.next.no > heroNode.no) {
                HeroNode cur = temp.next;
                cur.pre = heroNode;
                heroNode.pre = temp;
                temp.next = heroNode;
                heroNode.next = cur;
                return;
            } else if (temp.next.no == heroNode.no) {//当temp.next.no==heroNode.no时，说明链表中有该值，则flag=true;
                System.out.println(heroNode.no + "该值存在，不能再次加入！");
            }
            temp = temp.next;
        }
        temp.next = heroNode;
        heroNode.pre = temp;
    }

    //修改节点信息
    //以no为查询条件，进行修改
    public void update(HeroNode newHeroNode) {
        //先判断是否为空
        if (headNode.next == null) {
            System.out.println("链表为空，不能修改！");
            return;
        }
        //头结点不能动，定义一个辅助指针
        HeroNode temp = headNode.next;
        //定义一个flag，用来判断是否找到该节点
        boolean flag = false;
        while (true) {
            //如果temp==null 说明找到链表尾部还没有找到
            if (temp == null) {
                System.out.println("该链表没有该元素！");
                break;
            } else if (temp.no == newHeroNode.no) {
                //temp.no==newHeroNode.no  说明找到了
                flag = true;
                break;
            }
            temp = temp.next;//后移操作
        }
        if (flag) {
            temp.name = newHeroNode.name;
            temp.nickname = newHeroNode.nickname;
        }
    }

    //删除指定no的节点
    //思路: 先找到要删除节点temp
    //再将 temp.next.pre=temp.pre  temp.pre.next = temp.next   temp就没有引用指向它，那么他就会被jvm回收
    public void delete(int no) {
        //先判断是否为空
        if (headNode.next == null) {
            System.out.println("链表为空，不能删除！");
            return;
        }
        //头结点不能动，定义一个辅助指针
        HeroNode temp = headNode;
        while (true) {
            //如果temp==null 说明找到链表尾部还没有找到
            if (temp == null) {
                break;
            } else if (temp.no == no) {
                temp.pre.next = temp.next;
                //这里有问题，如果要删除的节点刚好是最后一个节点时
                //temp.next为空，空的pre会出现空指针异常
                //当是最后一个节点时，下面就不用操作了
                if (temp.next != null) {
                    temp.next.pre = temp.pre;
                }
                return;
            }
            temp = temp.next;//后移
        }
        System.out.println("没有找到要删除的节点！");
    }


    //遍历链表
    public void list() {
        //先判断链表是否为空
        if (headNode.next == null) {
            System.out.println("链表为空，不能遍历！");
            return;
        }
        //不为空，那么向后遍历，头结点不能动
        HeroNode temp = headNode.next;
        while (true) {
            if (temp == null) {
                break;
            }
            System.out.println(temp);
            temp = temp.next;
        }
    }
}

测试类

package com.datestructures.linkedlist;

public class DoubleLinkedListDemo {
    public static void main(String[] args) {
        //双向链表的测试
        System.out.println("双向链表的测试");
        //创建一个双向链表
        DoubleLinkedList doubleLinkedList = new DoubleLinkedList();
        //创建节点
        HeroNode heroNode1 = new HeroNode(1, "宋江", "及时雨");
        HeroNode heroNode2 = new HeroNode(2, "卢俊义", "玉麒麟");
        HeroNode heroNode3 = new HeroNode(3, "吴用", "智多星");
        HeroNode heroNode4 = new HeroNode(4, "林冲", "豹子头");
        //添加测试
        /*//按顺序加入
        doubleLinkedList.add(heroNode1);
        doubleLinkedList.add(heroNode2);
        doubleLinkedList.add(heroNode3);
        doubleLinkedList.add(heroNode4);*/
        //自动排序加入
        doubleLinkedList.addByOrder(heroNode1);
        doubleLinkedList.addByOrder(heroNode4);
        doubleLinkedList.addByOrder(heroNode3);
        doubleLinkedList.addByOrder(heroNode2);
        //遍历测试
        doubleLinkedList.list();

        //修改测试
        //new 一个需要修改的对象
        HeroNode newHeroNode=new HeroNode(2, "小卢", "玉麒麟~~");
        doubleLinkedList.update(newHeroNode);
        System.out.println("修改后的链表为~~");
        doubleLinkedList.list();
        //删除测试 这里我要删除节点.no为2的
        doubleLinkedList.delete(2);
        System.out.println("删除后链表为~~");
        doubleLinkedList.list();
    }
}