单链表（通俗易懂）

定义 HeroNode

package com.lmh.test.structure.linkedlist;

/**
 *  定义 HeroNode, 每个 HeroNode对象就是一个节点
 * @author BestHeaker.
 * @date 2022/4/6
 * @time 10:09
 */
public class HeroNode {
    public Integer no;
    public String name;
    public String nickname;
    public HeroNode next;  // 指向下一个节点

    // 构造器
    public HeroNode(Integer 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 + '\'' +
                '}';
    }

}

定义SingleLinkedList

package com.lmh.test.structure.linkedlist;

/**
 *  定义SingleLinkedList  管理我们的英雄
 * @author BestHeaker.
 * @date 2022/4/6
 * @time 10:08
 */
public class SingleLinkedList {

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

    /**
     * 添加节点到单向链表
     * 思路，当不考虑编号顺序时
     * 1.找到当前链表的最后节点
     * 2.将最后这个节点的 next 指向 新的节点
     */
    public void add(HeroNode heroNode) {
        // 因为 head节点不能动，因此我们需要一个辅助遍历 temp
        HeroNode temp = head;
        // 遍历链表，找到最后
        while (true) {
            // 找到链表的最后
            if (temp.next == null) {
                break;
            }
            // 如果没有找到最后，将 temp后移, 此时 temp.next就是下个节点HeroNode
            temp = temp.next;
        }
        // 当退出 while循环时，temp就指向了链表的最后
        // 将最后的这个节点的 next 指向新的节点
        temp.next = heroNode;
    }

    // 第二种方式在添加英雄时，根据排名将英雄插入到指定位置
    // 如果有这个排名，则添加失败，并给出提示
    public void addByOrder(HeroNode heroNode) {
        // 因为头节点不能动，因此我们仍然通过辅助指针(变量)来帮助找到添加的位置
        // 因为是单链表，因此我们找到的 temp是位于 添加位置的前一个节点，否则添加不了
        HeroNode temp = head;
        boolean flag = false; // flag 标志添加的编号是否存在，默认为 false
        while (true) {
            if (temp.next == null) { // 说明 temp已经在链表的最后
                break;
            }
            if (temp.next.no > heroNode.no) { // 位置找到，就在 temp的后面插入
                break;
            } else if (temp.next.no == heroNode.no) { // 说明希望添加的 heroNode的编号已存在
                flag = true; // 说明编号存在
                break;
            }
            temp = temp.next; // 后移，遍历当前链表
        }
        // 判断 flag的值
        if (flag) { // 不能添加，说明编号存在
            System.out.println("准备插入的英雄编号:"+ heroNode.no + "已经存在了，不能加入" );
        }else {
            // 插入到链表中，temp的后面
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }

    // 修改节点的信息，根据 no编号来修改，即 no编号不能该。
    // 1.根据 newHeroNod 的 no 来修改即可
    public void update(HeroNode newHeroNode) {
        // 判断是否为空
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        // 找到需要修改的节点，根据 no编号
        // 定义一个辅助变量
        HeroNode temp = head.next;
        boolean flag = false; // 表示是否找到该节点
        while (true) {
            if (temp == null) {
                break; // 已经遍历完链表
            }
            if (temp.no == newHeroNode.no) {
                // 找到
                flag = true;
                break;
            }
            temp = temp.next;
        }
        // 根据 flag 判断是否找到要修改的节点
        if (flag) {
            temp.name = newHeroNode.name;
            temp.nickname = newHeroNode.nickname;
        } else {  // 没有找到
            System.out.println("没有找到编号的节点，不能修改" + newHeroNode.no);
        }
    }


    // 显示链表 遍历
    public void list() {
        // 判断链表是否为空
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        // 因为头节点，不能动，因此我们需要一个辅助变量来遍历
        HeroNode temp = head.next;
        while (true) {
            // 判断是否到链表最后
            if (temp == null) {
                break;
            }
            // 输出节点的信息
            System.out.println(temp);
            // 将 temp后移，一定要注意后移
            temp = temp.next;
        }
    }
}

测试

package com.lmh.test.structure.linkedlist;

/**
 * @author BestHeaker.
 * @date 2022/4/5
 * @time 12:30
 */
public class SingleLinkedListDemo {

    public static void main(String[] args) {
        // 进行测试
        // 先创建节点
        HeroNode hero1 = new HeroNode(1, "路明非", "黑王");
        HeroNode hero2 = new HeroNode(2, "凯撒", "花花公子");
        HeroNode hero3 = new HeroNode(3, "楚子航", "冷面男");
        HeroNode hero4 = new HeroNode(4, "昂热", "校长");

        // 创建一个链表
        SingleLinkedList singleLinkedList = new SingleLinkedList();
        // 插入
        singleLinkedList.add(hero1);
        singleLinkedList.add(hero2);
        singleLinkedList.add(hero3);
        singleLinkedList.add(hero4);

//        // 加入按照编号的顺序
//        singleLinkedList.addByOrder(hero1);
//        singleLinkedList.addByOrder(hero4);
//        singleLinkedList.addByOrder(hero2);
//        singleLinkedList.addByOrder(hero3);
//        singleLinkedList.addByOrder(hero3);

        // 显示
        singleLinkedList.list();

        // 测试修改节点的代码
        HeroNode newHeroNode = new HeroNode(2, "张三", "花花公子三");
        singleLinkedList.update(newHeroNode);

        // 显示
        System.out.println("修改后的链表情况:");
        singleLinkedList.list();
    }
}

删除节点

单链表反转


不易理解代码：该行代码，看链表反转思路第一张图就知道。