链表LinkedList(2)

1. 双向链表相较单链表的优势

• 单链表只能顺着一个方向查找，而双向链表可以向前或向后查找；
• 单链表不能自我删除，删除节点时需要找到待删除节点的前一个节点，做temp.next = temp.next.next操作；而双向链表

可以进行自我删除。

2. 双向链表的增删改查

• 双向链表的遍历方式与单链表相同，只是可以向前也可以向后查找；
• 添加（默认添加到双向链表的最后）
  • 先遍历找到双向链表的最后一个节点；
  • temp.next = newNode；
  • newNode.pre = temp;
  • 需要注意的是，双向链表的按序插入在插入时需要考虑两种情况：
    • 链表为空或已遍历到链表尾，直接添加到链表最后即可（即上面的方式）；
    • 新节点插入到链表中间，需要将新节点的next域和pre域都与其插入位置两侧的节点建立联系。
• 修改的思路和原理与单链表相同；
• 删除
  • 双向链表可以实现自我删除某个节点；
  • 因此直接找到待删除节点temp即可；
  • temp.pre.next = temp.next;
  • temp.next.pre = temp.pre;
  • 同时也需要注意，待删除的节点是否是双向链表的最后一个节点：
    • 若是，则只执行temp.pre.next = temp.next。

3. 代码实现

package com.datastructure;

/**
 * @author SnkrGao
 * @create 2023-03-11 17:00
 */
public class DoubleLinkedListDemo {

    public static void main(String args[]) {

        DHeroNode hero1 = new DHeroNode(1, "宋江", "及时雨");
        DHeroNode hero2 = new DHeroNode(2, "卢俊义", "玉麒麟");
        DHeroNode hero3 = new DHeroNode(3, "吴用", "智多星");
        DHeroNode hero4 = new DHeroNode(4, "林冲", "豹子头");

        DoubleLinkedList doubleLinkedList = new DoubleLinkedList();

        doubleLinkedList.addByOrder(hero1);
        doubleLinkedList.addByOrder(hero4);
        doubleLinkedList.addByOrder(hero2);
        doubleLinkedList.addByOrder(hero3);
        doubleLinkedList.addByOrder(hero4);
        System.out.println("原双向链表：");
        doubleLinkedList.ergodic();

        System.out.println("更新节点后的双向链表：");
        DHeroNode updateHero = new DHeroNode(1, "TheShy", "送姜");
        doubleLinkedList.update(updateHero);
        doubleLinkedList.ergodic();

        System.out.println("删除节点后的双向链表：");
        doubleLinkedList.delete(1);
        doubleLinkedList.delete(4);
        doubleLinkedList.delete(3);
        doubleLinkedList.delete(2);
        doubleLinkedList.ergodic();

    }
}

// 节点类
class DHeroNode {
    public int No;
    public String HeroName;
    public String NickName;
    public DHeroNode next; // 指向下一个节点
    public DHeroNode pre; // 指向前一个节点

    // 构造方法
    public DHeroNode(int hNo, String hHeroName, String hNickName) {
        this.No = hNo;
        this.HeroName = hHeroName;
        this.NickName = hNickName;
    }

    // 为显示方便，重写toString方法
    @Override
    public String toString() {
        return "DHeroNode{" +
                "No=" + No +
                ", HeroName='" + HeroName + '\'' +
                ", NickName='" + NickName + '\'' +
                '}';
    }
}

// 双向链表类
class DoubleLinkedList {

    // 先初始化一个头节点，头节点不能动，不存放具体数据
    private DHeroNode headNode = new DHeroNode(0, "", "");

    public DHeroNode getHeadNode() {
        return headNode;
    }

    // 向双向链表中直接添加节点
    public void add(DHeroNode heroNode) {
        DHeroNode temp = headNode;
        // 遍历到链表最后
        while (temp.next != null) {
            temp = temp.next;
        }
        // 形成完整的双向链表
        temp.next = heroNode;
        heroNode.pre = temp;
    }

    // 向双向链表中按序添加节点
    public void addByOrder(DHeroNode heroNode) {
        DHeroNode temp = headNode;
        // 遍历查找到要插入的位置
        while (temp.next != null && temp.next.No < heroNode.No) {
            temp = temp.next;
        }
        // 重复插入判断
        if (temp.next != null && temp.next.No == heroNode.No) {
            System.out.println("当前插入的好汉编号"+heroNode.No+"已存在，插入失败！");
        }else {
            // 分两种情况
            if (temp.next == null) {
                // 链表为空或已遍历到双向链表尾部，即直接插入到双向链表最后
                temp.next = heroNode;
                heroNode.pre = temp;
            }else {
                // 插入到双向链表的中间
                heroNode.next = temp.next;
                temp.next.pre = heroNode;
                temp.next = heroNode;
                heroNode.pre = temp;
            }
        }
    }

    // 更新双向链表的节点信息
    public void update(DHeroNode heroNode) {
        if (headNode.next == null) {
            System.out.println("双向链表为空，无法更新！");
            return;
        }
        DHeroNode temp = headNode.next;
        Boolean flag = false;
        while (temp != null) {
            if (temp.No == heroNode.No) {
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            temp.HeroName = heroNode.HeroName;
            temp.NickName = heroNode.NickName;
        }else {
            System.out.println("没有找到编号为"+heroNode.No+"的节点，无法修改！");
        }
    }

    // 删除双向链表中的节点，不需要查找待删除节点的前一个节点
    public void delete(int no) {
        if (headNode.next == null) {
            System.out.println("链表为空，无法删除！");
            return;
        }
        DHeroNode temp = headNode.next;
        Boolean flag = false;
        while (temp != null) {
            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.println("没有找到排行为"+no+"的好汉，无法删除");
        }
    }

    // 遍历双向链表
    public void ergodic() {
        if (headNode.next == null) {
            System.out.println("双向链表为空！");
            return;
        }
        DHeroNode temp = headNode.next;
        while (temp != null) {
            System.out.println(temp);
            temp = temp.next;
        }
    }
}