链表「Java数据结构与算法学习笔记3」

岛雨QA2026-02-26 11:02

🔥工程代码已上传至github：github.com/doublev2026...

链表(LinkedList)

链表是有序的列表，但是它在内存中是存储如下：

  1. 链表是以节点的方式来存储，是链式存储
  2. 每个节点包含data域、next域（指向下一个节点）
  3. 链表的各个节点不一定是连续存储
  4. 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定

单链表

单链表介绍

单链表(带头结点) 逻辑结构示意图如下：

应用实例

需求：使用带head头的单向链表实现"水浒英雄排行榜管理"，完成对英雄人物的增删改查操作

  1. 第一种方法在添加英雄时，直接添加到链表的尾部，思路分析示意图如下：
  1. 第二种方式在添加英雄时，根据排名将英雄插入到指定位置（如果有这个排名，则添加失败，并给出提示）。思路分析示意图如下：
  1. 修改节点功能
    1. 第一步，先找到该节点，通过遍历；
    2. 第二步，修改信息：temp.name = newHeroNode.name; temp.nickName = newHeroNode.nickName
  2. 删除节点。思路分析示意图如下：

代码实现：

java 复制代码 
package com.datastructures.linkedlist;

/**
 * 定义 HeroNode，每个 HeroNode 对象就是一个节点
 */
public class HeroNode {
    public int no;
    public String name;
    public String nickName;
    public HeroNode next; // 【指向下一个节点】

    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 + '\'' + ", next=" + next + '}';
        return "HeroNode{" + "no=" + no + ", name='" + name + '\'' + ", nickName='" + nickName + '}';
    }
}
java 复制代码 
package com.datastructures.linkedlist;

/**
 * 定义链表
 */
public class SingleLinkedList {
    // 初始化一个头节点，头节点不要动，不存放具体的数据
    private HeroNode head = new HeroNode(0, "", "");

    /**
     * 添加节点到单向链表，当不考虑编号顺序时：
     * 1、找到当前链表的最后节点
     * 2、将最后这个节点的next指向新加入的节点
     *
     * @param heroNode
     */
    public void add(HeroNode heroNode) {
        // head节点不能动，因此我们需要一个辅助遍历 temp
        HeroNode temp = head;
        // 遍历链表，找到最后
        while (true) {
            // 找到链表最后就结束
            if (temp.next == null) {
                break;
            }
            // 如果没找到最后，则将temp后移
            temp = temp.next;
        }
        // 退出while循环的时候，temp已经指向了链表的最后
        // 【将最后这个节点的next指向新的节点】
        temp.next = heroNode;
    }

    /**
     * 第二种方式，在添加英雄时，根据排名将英雄插入到指定位置
     * 如果有这个排名，则添加失败，并给出提示
     *
     * @param heroNode
     */
    public void addByOrder(HeroNode heroNode) {
        // head节点不能动，因此我们仍然通过一个辅助指针（变量）来帮助找到添加的位置
        // 因为是单链表，我们找的temp是位于添加位置的前一个节点，否则插入不了（因为只有next）
        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.printf("准备插入的英雄的编号%d已经存在了，不能加入\n", heroNode.no);
        } else {
            // 插入到链表中，temp的后面
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }

    /**
     * 修改节点的信息，根据no编号来修改，no编号不能改
     *
     * @param heroNode
     */
    public void update(HeroNode heroNode) {
        // 判断链表是否为空
        if (head.next == null) {
            System.out.println("链表为空，无法修改，请添加数据");
            return;
        }
        HeroNode temp = head.next; // 根据no编号找到需要修改的节点
        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);
        }
    }

    /**
     * 删除节点
     * 1、head不能动，因此我们需要一个temp辅助节点找到待删除节点的前一个节点
     * 2、说明我们在比较时，是temp.next.no和需要删除的节点的no比较
     *
     * @param no
     */
    public void del(int no) {
        HeroNode temp = head;
        boolean flag = false; // 表示是否已经找到待删除的节点
        while (true) {
            if (temp == null) {
                break; //已经遍历完链表
            }
            if (temp.next.no == no) {
                flag = true;
                break;
            }
            temp = temp.next; // 如果没有找到，继续后移，遍历当前链表
        }
        // 根据flag判断是否已经找到需要删除的节点
        if (flag) {
            temp.next = temp.next.next;
        } else {
            System.out.printf("没有找到英雄编号为%d的节点，不能删除\n", 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.next; // 将temp后移
        }
    }
}
java 复制代码 
package com.datastructures.linkedlist;

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(hero4);
        singleLinkedList.addByOrder(hero1);
        singleLinkedList.addByOrder(hero3);
        singleLinkedList.addByOrder(hero2);

        singleLinkedList.list();

        // 修改节点
        HeroNode newHero2 = new HeroNode(2, "卢俊义new", "玉麒麟new");
        singleLinkedList.update(newHero2);
        System.out.println("修改节点后的链表信息：");
        singleLinkedList.list();

        // 删除节点
        // singleLinkedList.del(5);
        singleLinkedList.del(4);
        System.out.println("删除节点后的链表信息：");
        singleLinkedList.list();
    }
}

单链表面试题

  1. 求单链表中有效节点的个数
java 复制代码 
/**
 * 面试题：获取单链表中有效节点的个数。如果是带头节点的链表，需求不统计头节点
 *
 * @param head 头节点
 * @return 有效节点的个数
 */
public static int getLength(HeroNode head) {
    if (head.next == null) {
        return 0;
    }
    int length = 0;
    HeroNode temp = head.next; // 这样就不会统计头节点了
    while ((temp != null)) {
        length++;
        temp = temp.next;
    }
    return length;
}
  1. 查找单链表中的倒数第k个结点
java 复制代码 
/**
 * 面试题：查找单链表中的倒数第k个结点
 * 1、编写一个方法，接收 head 节点，同时接收一个 index
 * 2、index 表示倒数第 index 个节点
 * 3、先把链表从头到尾遍历，得到链表的总长度 getLength(head)
 * 4、得到size后，我们从链表的第一个开始遍历 size-index个（从 0 开始的索引位置），就可以得到
 * 5、如果找到了，则返回该节点。否则返回null
 *
 * @param head
 * @param index
 * @return
 */
public static HeroNode findLastIndexNode(HeroNode head, int index) {
    if (head.next == null) {
        return null;
    }
    // 先得到链表总长度
    int size = getLength(head);
    // 对index输入做校验
    if (index < 0 || index > size) {
        return null;
    }
    HeroNode temp = head.next;
    for (int i = 0; i < size - index; i++) {
        temp = temp.next;
    }
    return temp;
}
  1. 单链表的反转 🔥

思路：

  1. 先定义一个节点 reverseHead = new HeroNode();
  2. 从头到尾遍历原来的链表，每遍历一个节点，就将其取出，并放在新的链表reverseHead 的最前端；
  3. 原来的链表的head.next = reverseHead.next;
java 复制代码 
/**
 * 面试题：反转单链表
 *
 * @param head
 */
public static void reverseList(HeroNode head) {
    // 如果当前链表为空，或者只有一个节点，无需反转直接返回
    if (head.next == null || head.next.next == null) {
        return;
    }

    // 定义一个辅助的指针，帮助我们遍历原来的链表
    HeroNode current = head.next;
    HeroNode next = null; // 指向当前节点current的下一个节点，后面用来让current继续往后移动
    HeroNode reverseHead = new HeroNode(0, "", ""); // 新的链表

    // 遍历原来的链表，每遍历一个节点，将其取出，放在新的链表reverseHead的最前端
    while (current != null) {
        next = current.next; // 先暂时保存当前节点的下一个节点，后面使用
        current.next = reverseHead.next; // 【将current的下一个节点指向新的链表的最前端】
        reverseHead.next = current;
        current = next; // current继续往后移动
    }

    // 最后，将head.next指向reverseHead.next，其实就是最前端数据
    head.next = reverseHead.next;
}
  1. 从尾到头打印单链表
java 复制代码 
/**
 * 面试题：逆序打印单链表
 *
 * @param head
 */
public static void reversePrint(HeroNode head) {
    if (head.next == null) {
        return;
    }
    // 创建一个栈，循环链表，将各个节点压入栈
    Stack<HeroNode> stack = new Stack<>();
    HeroNode temp = head.next;
    while (temp != null) {
        stack.push(temp);
        temp = temp.next;
    }
    // 出栈，并打印数据
    while (stack.size() > 0) {
        System.out.println(stack.pop());
    }
}

双向链表

双向链表介绍

单向链表的缺点：

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

下面使用带head头的双向链表实现水浒英雄排行榜。

应用实例

代码实现：

java 复制代码 
package com.datastructures.linkedlist;

/**
 * 定义 HeroNode，每个 HeroNode 对象就是一个节点
 */
public class HeroNode2 {
    public int no;
    public String name;
    public String nickName;
    public HeroNode2 next; // 【指向下一个节点，默认为null】
    public HeroNode2 pre; // 【指向前一个节点，默认为null】

    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 + '}';
    }
}
java 复制代码 
package com.datastructures.linkedlist;

/**
 * 定义链表
 */
public 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; // 将temp后移
        }
    }

    /**
     * 添加节点到双向链表的最后
     *
     * @param heroNode
     */
    public void add(HeroNode2 heroNode) {
        // head节点不能动，因此我们需要一个辅助遍历 temp
        HeroNode2 temp = head;
        // 遍历链表，找到最后
        while (true) {
            // 找到链表最后就结束
            if (temp.next == null) {
                break;
            }
            // 如果没找到最后，则将temp后移
            temp = temp.next;
        }
        // 退出while循环的时候，temp已经指向了链表的最后。操作形成一个双向链表
        temp.next = heroNode;
        heroNode.pre = temp;
    }

    /**
     * 第二种方式，在添加英雄时，根据排名将英雄插入到指定位置
     * 如果有这个排名，则添加失败，并给出提示
     *
     * @param heroNode
     */
    public void addByOrder(HeroNode2 heroNode) {
        // head节点不能动，因此我们仍然通过一个辅助指针（变量）来帮助找到添加的位置
        HeroNode2 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.printf("准备插入的英雄的编号%d已经存在了，不能加入\n", heroNode.no);
        } else {
            // 插入到链表中，temp的后面
            // 如果正好是插入到最后，则不需要做如下动作
            if (temp.next != null) {
                heroNode.next = temp.next;
                temp.next.pre = heroNode;
            }
            temp.next = heroNode;
            heroNode.pre = temp;
        }
    }

    /**
     * 修改节点的信息，根据no编号来修改，no编号不能改
     *
     * @param heroNode
     */
    public void update(HeroNode2 heroNode) {
        // 判断链表是否为空
        if (head.next == null) {
            System.out.println("链表为空，无法修改，请添加数据");
            return;
        }
        HeroNode2 temp = head.next; // 根据no编号找到需要修改的节点
        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);
        }
    }

    /**
     * 删除节点
     * 1、对于双向链表，我们可以直接找到要删除的节点
     * 2、找到后，自我删除即可
     *
     * @param no
     */
    public void del(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.pre.next = temp.next;
            // 如果是最后一个节点，不需要执行下面的
            if (temp.next != null) {
                temp.next.pre = temp.pre;
            }
        } else {
            System.out.printf("没有找到英雄编号为%d的节点，不能删除\n", no);
        }
    }
}
java 复制代码 
package com.datastructures.linkedlist;

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(hero4);
        doubleLinkedList.addByOrder(hero1);
        doubleLinkedList.addByOrder(hero3);
        doubleLinkedList.addByOrder(hero2);

        doubleLinkedList.list();

        // 修改节点
        HeroNode2 newHero2 = new HeroNode2(2, "卢俊义new", "玉麒麟new");
        doubleLinkedList.update(newHero2);
        System.out.println("修改节点后的链表信息：");
        doubleLinkedList.list();

        // 删除节点
        // doubleLinkedList.del(5);
        doubleLinkedList.del(4);
        System.out.println("删除节点后的链表信息：");
        doubleLinkedList.list();
    }
}

单向环形链表

单向环形链表介绍

约瑟夫问题

Josephu（约瑟夫、约瑟夫环**）**问题：

Josephu问题为：设编号为 1，2，... n 的n个人围坐一圈，约定编号为k（1<=k<=n）的人从1开始报数，数到m 的那个人出列，它的下一位又从1开始报数，数到m的那个人又出列，依次类推，直到所有人出列为止，由此产生一个出队编号的序列。

提示：用一个不带头结点的循环链表来处理Josephu 问题。先构成一个有n个结点的单循环链表，然后由k结点起从1开始计数，计到m时，对应结点从链表中删除，然后再从被删除结点的下一个结点又从1开始计数，直到最后一个结点从链表中删除算法结束。

问题示意图如下：

创建环形链表的思路图解：

约瑟夫问题出圈逻辑示意图：

约瑟夫问题代码实现

java 复制代码 
package com.datastructures.linkedlist;

/**
 * 表示一个节点
 */
public class Boy {
    private int no; // 编号
    private Boy next; // 指向下一个节点，默认为null

    public Boy(int no) {
        this.no = no;
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public Boy getNext() {
        return next;
    }

    public void setNext(Boy next) {
        this.next = next;
    }
}
java 复制代码 
package com.datastructures.linkedlist;

/**
 * 环形单向链表
 */
public class CircleSingleLinkedList {
    // 创建一个first节点，当前没有编号
    private Boy first = null;

    // 添加小孩节点，构建成一个环形的链表
    public void addBoy(int nums) {
        if (nums < 1) {
            System.out.println("请输入正确的nums的值");
            return;
        }
        Boy curBoy = null; // 辅助指针，帮助构建环形链表。最开始为null
        for (int i = 1; i <= nums; i++) {
            Boy boy = new Boy(i);
            if (i == 1) {
                first = boy;
                first.setNext(first); // 只有一个数据的时候，也要自己构成环
                curBoy = first; // 让curBoy指向第一个小孩
            } else {
                curBoy.setNext(boy); // 往后插入，让前一个的next设置为新boy
                boy.setNext(first); // 最后一个指向第一个
                curBoy = boy; // 让curBoy指向新加入的小孩，后面好继续移动（因为 first 不能动）
            }
        }
    }

    // 遍历当前的环形链表
    public void showBoy() {
        // 判断链表是否为空
        if (first == null) {
            System.out.println("队伍没有小孩");
            return;
        }
        // 因为 first 还是不能动，因此我们需要使用一个辅助指针完成遍历
        Boy curBoy = first;
        while (true) {
            System.out.printf("%d号小孩\n", curBoy.getNo());
            if (curBoy.getNext() == first) { // 说明已经遍历完毕
                break;
            }
            curBoy = curBoy.getNext(); // curBoy往后移动，继续遍历
        }
    }

    /**
     * 根据输入，计算小孩出圈的顺序
     *
     * @param startNo 表示从第几个小孩开始数数
     * @param countNo 表示数几下
     * @param nums    表示最初有多少小孩在圈中
     */
    public void countBoy(int startNo, int countNo, int nums) {
        // 首先对数据进行校验
        if (first == null || startNo < 1 || startNo > nums) {
            System.out.println("参数输入有误，请重新输入");
            return;
        }
        // 创建一个辅助指针(变量) helper , 事先应该指向环形链表的最后这个节点
        Boy helper = first;
        while (true) {
            if (helper.getNext() == first) { // 说明helper指向了最后的小孩节点
                break;
            }
            helper = helper.getNext();
        }
        // 小孩报数前，先让 first 和  helper 移动 startNo - 1次
        for (int j = 0; j < startNo - 1; j++) {
            first = first.getNext();
            helper = helper.getNext();
        }
        // 当小孩报数时，让first 和 helper 指针同时的移动 countNo - 1 次，然后出圈
        // 这里是一个循环操作，直到圈中只有一个节点
        while (true) {
            if (helper == first) { // 说明圈中只有一个节点
                break;
            }
            // 让first 和 helper 指针同时的移动 countNo - 1 次
            for (int j = 0; j < countNo - 1; j++) {
                first = first.getNext();
                helper = helper.getNext();
            }
            // 此时 first 指向的节点，就是要出圈的小孩节点
            System.out.printf("%d号小孩出圈\n", first.getNo());
            // 这时将 first 指向的小孩节点出圈
            first = first.getNext();
            helper.setNext(first); // helper 后移，依旧跟在 first 后面
        }
        System.out.printf("最后留在圈中的小孩编号是%d\n", first.getNo());
    }
}
java 复制代码 
package com.datastructures.linkedlist;

public class Josepfu {
    public static void main(String[] args) {
        CircleSingleLinkedList circleSingleLinkedList = new CircleSingleLinkedList();
        circleSingleLinkedList.addBoy(5);
        circleSingleLinkedList.showBoy();

        circleSingleLinkedList.countBoy(3, 2, 5);
    }
}
相关推荐
Sunsets_Red1 小时前
P8277 [USACO22OPEN] Up Down Subsequence P 题解
c语言·c++·算法·c#·学习方法·洛谷·信息学竞赛
菜鸟小九1 小时前
redis原理篇(基本数据结构）
数据结构·数据库·redis
汉克老师1 小时前
GESP2023年12月认证C++二级( 第三部分编程题（2） 小杨的H字矩阵）
c++·算法·矩阵·循环结构·gesp二级·gesp2级
_Li.1 小时前
Simulink-螺旋桨动力模块
人工智能·算法·机器学习
Charlie_lll2 小时前
力扣解题-438. 找到字符串中所有字母异位词
后端·算法·leetcode
奶茶树2 小时前
【数据结构】红黑树
数据结构·c++·算法
AI周红伟2 小时前
周红伟：OpenAI 首席运营官，尚未真正看到人工智能渗透到企业业务流程中
人工智能·算法·性能优化
问好眼2 小时前
《算法竞赛进阶指南》0x01 位运算-2.增加模数
c++·算法·位运算·信息学奥赛
Full Stack Developme2 小时前
哈希是什么
算法·哈希算法
热门推荐
01GitHub 镜像站点02【OpenClaw 本地实战 Ep.3】突破瓶颈：强制修改 openclaw.json 解锁 32k 上下文记忆03Claude Code + GLM4.7 避坑指南：解决 Unable to connect to Anthropic services04AI Agent 平台横评：ZeroClaw vs OpenClaw vs Nanobot05OpenClaw 使用和管理 MCP 完全指南06Clawdbot部署教程：解决‘gateway token missing’授权问题的完整步骤07AI 规范驱动开发“三剑客”深度对比：Spec-Kit、Kiro 与 OpenSpec 实战指南08OpenClaw 安装之（三）DeepSeek模型接入配置和详细配置参数09AI agent：介绍 ZeroClaw 安装，使用10EvoMap 是什么？