java实现双向链表的增删改查

package com.bigdata.datastructure.linkedlist;

/**
 * @ description: 双向链表的增删改查
 * @ author: spencer
 * @ date: 2020/10/28 10:41
 */
public class DoubleLinkedListDemo {

    public static void main(String[] args) {
        // 创建节点对象
        HeroNode2 hero1 = new HeroNode2(1, "宋江", "及时雨");
        HeroNode2 hero2 = new HeroNode2(2, "卢俊义", "玉麒麟");
        HeroNode2 hero3 = new HeroNode2(3, "林冲", "豹子头");
        HeroNode2 hero4 = new HeroNode2(4, "赵信", "菊花");

        DoubleLinkedList doubleLinkedList = new DoubleLinkedList();

        // 测试不按照顺序添加节点到双向链表，每次添加到末尾
//        doubleLinkedList.add(hero1);
//        doubleLinkedList.add(hero2);
//        doubleLinkedList.add(hero3);
//        doubleLinkedList.add(hero4);

        // 测试按照编号顺序添加节点到双向链表
        doubleLinkedList.addByOrder(hero1);
        doubleLinkedList.addByOrder(hero3);
        doubleLinkedList.addByOrder(hero2);
        doubleLinkedList.addByOrder(hero4);

        doubleLinkedList.addByOrder(new HeroNode2(7, "zhangsan", "xiaozhang"));
        doubleLinkedList.addByOrder(new HeroNode2(5, "lisi", "xiaoli"));
        doubleLinkedList.addByOrder(new HeroNode2(6, "王五", "小王"));


        //测试更新和删除双向链表中的节点
//        doubleLinkedList.update(new HeroNode2(4, "赵信", "德邦总管"));
//        doubleLinkedList.delete(4);

        doubleLinkedList.list();
    }
}

class DoubleLinkedList {

    private 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 (true) {
            // 判断链表是否到最后
            if (temp == null) {
                break;
            }

            // 输出节点的信息
            System.out.println(temp);
            // 将节点后移
            temp = temp.next;
        }
    }

    /**
     * 添加一个节点到双向链表的最后
     *
     * @param heroNode
     */
    public void add(HeroNode2 heroNode) {

        // 因为head节点不能动，所有需要一个辅助变量来替代head节点
        HeroNode2 temp = head;
        while (true) {
            if (temp.next == null) { // 当遍历完成时退出循环
                break;
            }
            // 如果没有找到，将temp后移
            temp = temp.next;
        }
        // 当退出while循环时，temp就指向了链表的最后，将新添加的节点赋给temp.next
        temp.next = heroNode;
        heroNode.pre = temp;

    }

    /**
     * 按照编号顺序添加节点到双向链表
     * @param heroNode
     */
    public void addByOrder(HeroNode2 heroNode){
        HeroNode2 temp = head;
        boolean flag = false; // 标志是否添加到链表中间
        boolean flag1 = false; // 标志是否添加到链表最后
        while (true){
            if (temp.next == null){
                flag1 = true;
                break;
            } else if (temp.next.no > heroNode.no){
                break;
            } else if (temp.next.no == heroNode.no){
                flag = true;
                break;
            }
            temp = temp.next;
        }

        if (flag){
            System.out.println("编号已经存在，无法添加");
            return;
        }else if (flag1){
            temp.next = heroNode;
            heroNode.pre = temp;
        } else {
            // 先更新next节点
            heroNode.next = temp.next;
            temp.next = heroNode;
            // 再更新pre节点
            temp.next.pre = heroNode;
            heroNode.pre = temp;
        }
    }

    /**
     * 根据编号修改heroNode对象
     * @param heroNode
     */
    public void update(HeroNode2 heroNode) {

        if (head.next == null) { // 空链表
            return;
        }
        // 找到需要修改的节点(不需要找到修改节点的前一个节点)
        HeroNode2 temp = head;
        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.printf("没有找到编号为 %d 的节点，不能修改\n", heroNode.no);
        }
    }

    /**
     *双向链表中删除一个节点(对于双向链表，我们可以直接找到要删除的节点)
     * @param 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;
        }

        // 根据编号找到要删除的节点
        if (flag) {
            temp.pre.next = temp.next;
            // 如果是最后一个节点，就不需要执行下面这句话，否则会报空指针异常
            if (temp.next != null) {
                temp.next.pre = temp.pre;
            }
        } else {
            System.out.println("要删除的节点编号不存在，无法删除");
        }
    }

}

// 创建HeroNode2，每一个节点就是一个HeroNode2对象
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;
    }

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