数据结构-----双向链表笔记

双向链表

对比

**1)**单向链表，查找的方向只能是一一个方向，而双向链表可以向前或者向后查找。
**2)**单向链表不能自我删除，需要靠辅助节点，而双向链表，则可以自我删除，所以前面我们单链表删除时节点，总是找到temp的前一个节点来删除的

我们的双向链表增加了一个节点：pre 指向前一个节点，加上我们的next，指向下一个节点，就是双向的了

遍历像单链表一样，只不过能可以向前，也可以向后

添加

先找到双向链表的最后这个节点

temp.next = newHeroNode;

newHeroNode.pre = temp;

修改

和原来的单向链表一样

删除

因为是双向链表，因此我们可以实现自我删除某个节点

直接找到要删除的这个节点，比如是temp

temp.pre.next = temp.next 前一个节点的下一个节点，变成了要删除的节点的下一个节点

temp.next.pre = temp.pre 后面那个节点的前一个节点，变成本节点的前一个节点

代码实现

package com.wang.linkedlist;

/**
 * @author 王庆华
 * @version 1.0
 * @date 2020/12/4 22:33
 * @Description TODO
 * @pojectname 算法代码
 */
public class DoubleLinkedListDemo {
    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, "林冲", "豹子头");
        DoubleLinkedtList doubleLinkedList = new DoubleLinkedtList();
        doubleLinkedList.add(hero1);
        doubleLinkedList.add(hero2);
        doubleLinkedList.add(hero3);
        doubleLinkedList.add(hero4);
        System.out.println("双向链表打印");
        doubleLinkedList.findAllList();
        System.out.println("修改测试");
        HeroNode2 heroNode = new HeroNode2(4,"公孙胜","入云龙");
        doubleLinkedList.update(heroNode);
        doubleLinkedList.findAllList();
        System.out.println("删除3测试");
        doubleLinkedList.delete(3);
        doubleLinkedList.findAllList();
    }
}
//创建一个双向链表
class DoubleLinkedtList{
    //初始化双向链表
    private HeroNode2 head = new HeroNode2(0,"","");

    //返回头结点
    public HeroNode2 getHead(){
        return head;
    }
    //添加操作
    public void add(HeroNode2 heroNode){
        //因为我们的头结点head不能移动，因此我们需要一个辅助变量temp
        HeroNode2 temp = head;
        //遍历链表，找到最后
        while(true){
            //找到最后
            if (temp.next == null)
            {
                break;
            }
            //不是最后，指针后裔
            temp = temp.next;
        }
        //档推出while循环时，temp就指向了链表最后
        //形成一个双向链表
        temp.next = heroNode;
        heroNode.pre = temp;
    }
    //修改双向链表内容
    //修改链表
    public void update(HeroNode2 heroNode){
        //判断是否为空
        if (head.next == null)
        {
            System.out.println("链表为空");
            return;
        }
        //找到需要修改的编号
        //用一个辅助节点,可以看到，我们只是把节点类型改了一下，其他的和单链表操作一样
        HeroNode2 temp = head.next;
        boolean flag = false;
        while (true)
        {
            if (temp == null){
                break;//遍历结束
            }
            if (temp.no == heroNode.no){
                //找到我们的修改位置
                flag = true;
                break;
            }
            temp = temp.next;
        }
        //根据flag判断是否找到节点
        if (flag)
        {
            temp.name = heroNode.name;
            temp.nickname = heroNode.nickname;
        }else {
            System.out.println("没有找到"+heroNode.no+"的英雄");
        }
    }
    //删除节点
    public void delete(int no){
        //判断当前链表是否为空
        if (head.next == null)//已经找到最后的节点了
        {
            System.out.println("链表为空，无法删除");
            return;
        }

        HeroNode2 temp = head.next;//辅助节点
        boolean flag = false;//标志是否找到待删除的节点
        while (true)
        {
            if (temp==null)
            {
                break;
            }
            if (temp.no == no){
                //找到了待删除的节点
                flag = true;
                break;
            }
            temp = temp.next;
        }
        //判断flag
        if (flag){
            //可以删除
            //单向链表的删除方式temp.next = temp.next.next;
            temp.pre.next = temp.next;
            //有风险，如果是最后一个节点呢，最后一个节点没有下一个节点了
            if (temp.next != null) {
                temp.next.pre = temp.pre;
            }
        }else {
            System.out.println("要删除的"+no+"不存在");
        }
    }



    //遍历双向链表
    //显示链表
    public void findAllList() {
        //先判断链表是否为空
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        //因为头结点不能动，因此需要一个辅助变量来遍历
        HeroNode2 temp = head.next;
        while (true) {
            //是否为最后
            if (temp.next == null) {
                System.out.println(temp);
                break;
            }
            //输出节点信息
            System.out.println(temp);
            //将指针后裔
            temp = temp.next;
        }
    }

}
class HeroNode2{
    public int no;
    public String name;
    public String nickname;
    public  HeroNode2 next;//指向下一个节点
    public HeroNode2 pre;//指向前一个节点
    //构造器
    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 + '\'' +
                '}';
    }
}