【数据结构与算法】链表

最新推荐文章于 2024-05-11 10:24:57 发布
最新推荐文章于 2024-05-11 10:24:57 发布
阅读量19 收藏
点赞数
分类专栏： 数据结构和算法 文章标签： 链表 java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62200539/article/details/131710119
版权

链表

基本介绍

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

单向链表

应用实例

使用带 head 头的单向链表实现 水浒英雄排行榜管理

  1. 完成对英雄人物的增删改查操作
  2. 第一种方式在添加英雄时，直接添加在链表尾部
  3. 第二种方式在添加英雄时，根据排名将英雄插入到指定位置（如果有这个排名，则添加失败，并给出提示）

第一种方式：

package com.lango.linkedlist;

/**
 * @author Lango
 * @version 1.0
 */
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.list();
    }
}

// 定义 SingleLinkedList，管理英雄
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 = temp.next;
        }
        // 当退出 while 循环时，temp 就指向了链表的最后
        // 将最后这个节点的 next 指向新的节点
        temp.next = heroNode;
    }

    // 显示链表【遍历】
    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;
        }
    }
}

// 定义 HeroNode，每个 HeroNode 对象就是一个节点
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;
    }

    // 为了显示方便，重写 toString
    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickname='" + nickname + '\'' +
                '}';
    }
}

第二种方式：

package com.lango.linkedlist;

/**
 * @author Lango
 * @version 1.0
 */
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.addByOrder(hero1);
        singleLinkedList.addByOrder(hero4);
        singleLinkedList.addByOrder(hero2);
        singleLinkedList.addByOrder(hero3);
        // 显示
        singleLinkedList.list();
    }
}

// 定义 SingleLinkedList，管理英雄
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 = 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.printf("准备插入的英雄编号 %d 已经存在了，不能插入", heroNode.no);
        } else {
            // 插入到链表
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }

    // 显示链表【遍历】
    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;
        }
    }
}

// 定义 HeroNode，每个 HeroNode 对象就是一个节点
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;
    }

    // 为了显示方便，重写 toString
    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickname='" + nickname + '\'' +
                '}';
    }
}

增加修改、删除功能：

package com.lango.linkedlist;

/**
 * @author Lango
 * @version 1.0
 */
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.addByOrder(hero1);
        singleLinkedList.addByOrder(hero4);
        singleLinkedList.addByOrder(hero2);
        singleLinkedList.addByOrder(hero3);

        // 显示
        singleLinkedList.list();

        // 修改
        HeroNode newHeroNode = new HeroNode(2, "小卢", "玉麒麟~~");
        singleLinkedList.update(newHeroNode);

        // 修改后
        System.out.println("修改后的链表~~");
        singleLinkedList.list();

        // 删除
        singleLinkedList.delete(2);
        singleLinkedList.delete(4);

        // 删除后
        System.out.println("删除后的链表~~");
        singleLinkedList.list();
    }
}

// 定义 SingleLinkedList，管理英雄
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 = 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.printf("准备插入的英雄编号 %d 已经存在了，不能插入", heroNode.no);
        } else {
            // 插入到链表
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }

    // 修改节点的信息，根据编号来修改，即 no 编号不能改
    // 说明
    // 1. 根据 newHeroNode 的 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.printf("没有找到编号 %d 的节点，不能修改\n", newHeroNode.no);
        }
    }

    // 删除节点
    public void delete(int no) {
        // 判断是否为空
        if (head.next == null) {
            System.out.println("链表为空~");
            return;
        }
        // 根据 no 编号，找到需要删除的节点
        // 定义一个辅助变量
        HeroNode temp = head;
        boolean flag = false; // 标识是否找到该节点
        while (true) {
            if (temp.next == 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 = temp.next;
        }
    }
}

// 定义 HeroNode，每个 HeroNode 对象就是一个节点
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;
    }

    // 为了显示方便，重写 toString
    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickname='" + nickname + '\'' +
                '}';
    }
}

新浪面试题（基于上面链表）：

/**
     * 查找单链表中的倒数第 k 个节点【新浪面试题】
     * 思路
     * 1. 编写一个方法，接收 head 节点，同时接收一个 index
     * 2. index 表示是倒数第 index 个节点
     * 3. 先把链表从头到尾遍历，得到链表的总长度 getLength
     * 4. 得到 size 后，我们从链表的第一个开始遍历（size - index）个，就可得到
     * 
     * @param head
     * @param index
     * @return
     */
     public static HeroNode findLastIndexNode(HeroNode head, int index) {
        // 判断 如果链表为空，返回null
        if (head.next == null) {
            return null;
        }
        // 第一次遍历得到链表的长度
        int size = getLength(head);
        // 第二次遍历 size - index 位置，就是倒数的第 k 个节点
        // 先做一个数据校验
        if (index <= 0 || index > size) {
            return null;
        }
        // 定义一个辅助变量
        HeroNode temp = head.next;
        // 遍历 for 循环定位
        for (int i = 0; i < size - index; i++) {
            temp = temp.next;
        }
        return temp;
    }

    /**
     * 获取单链表的节点的个数，如果是带头节点的链表，需要不统计头节点
     *
     * @param head 链表的头节点
     * @return 返回的是有效节点的个数
     */
    public static int getLength(HeroNode head) {
        if (head.next == null) {
            return 0;
        }
        int length = 0;
        // 定义一个辅助变量
        HeroNode cur = head.next;
        while (cur != null) {
            length++;
            cur = cur.next; // 遍历
        }
        return length;
    }
}

腾讯面试题：

/**
 * 将链表反转【腾讯面试题】
 *
 * @param head
 */
public static void reverseList(HeroNode head) {
    if (head.next == null || head.next.next == null) {
        return;
    }

    // 定义一个辅助变量，帮助我们遍历原来的链表
    HeroNode cur = head.next;
    HeroNode next = null; // 指向当前节点的下一个节点
    HeroNode reverseHead = new HeroNode(0, "", "");
    // 遍历原来的链表，每遍历一个节点，就将其取出，并放在新的链表 reverseHead 的最前端
    while (cur != null) {
        next = cur.next; // 暂时保存当前节点的下一个节点
        cur.next = reverseHead.next; // 将 cur 的下一个节点指向
        reverseHead.next = cur;
        cur = next; // 后移
    }
    // 将 head.next 指向 reverseHead.next,实现单链表的反转
    head.next = reverseHead.next;
}

百度面试题：

/**
 * 逆序打印单链表
 * 利用栈这个数据结构，将各个节点压入到栈中，然后利用栈的先进后出特点，就实现了逆序打印的效果
 *
 * @param head
 */
public static void reversePrint(HeroNode head) {
    if (head.next == null) {
        return; // 空链表，不能答应
    }
    // 创建要给一个栈，将各个节点压入栈
    Stack<HeroNode> stack = new Stack<>();
    HeroNode cur = head.next;
    // 将链表的所有节点压入栈中
    while (cur != null) {
        stack.push(cur);
        cur = cur.next;
    }
    // 将栈中的节点进行打印
    while (stack.size() > 0) {
        System.out.println(stack.pop());
    }
}

双向链表

应用实例

使用带 head 头的双向链表实现 水浒英雄排行榜管理

单向链表的缺点分析：

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

代码：

package com.lango.linkedlist;

/**
 * @author Lango
 * @version 1.0
 */
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, "林冲", "豹子头");
        HeroNode2 hero5 = new HeroNode2(5, "林冲", "豹子头");

        // 创建一个双向链表对象
        DoubleLinkedList doubleLinkedList = new DoubleLinkedList();
        doubleLinkedList.addByOrder(hero1);
        doubleLinkedList.addByOrder(hero4);
        doubleLinkedList.addByOrder(hero3);
        doubleLinkedList.addByOrder(hero2);
        doubleLinkedList.addByOrder(hero5);

        doubleLinkedList.list();

//        // 修改测试
//        HeroNode2 newHeroNode = new HeroNode2(4, "公孙胜", "入云龙");
//        doubleLinkedList.update(newHeroNode);
//        System.out.println("修改后");
//        doubleLinkedList.list();
//
//        // 删除
//        doubleLinkedList.delete(3);
//        System.out.println("删除后");
//        doubleLinkedList.list();
    }
}

// 创建一个双向链表的类
class DoubleLinkedList {
    // 初始化头节点，头节点不要动，不存放具体数据
    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 = temp.next;
        }
        // 当退出 while 循环时，temp 就指向了链表的最后
        // 构成一个双向链表
        temp.next = heroNode;
        heroNode.pre = temp;
    }

    // 按编号添加
    public void addByOrder(HeroNode2 heroNode) {
        // 因为头节点不能动，因此我们任然通过一个辅助指针（变量）来帮助找到添加的位置
        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 已经存在了，不能插入", heroNode.no);
        } else {
            // 插入到链表
            if (temp.next != null){
                temp.next.pre = heroNode;
            }
            heroNode.next = temp.next;
            temp.next = heroNode;
            heroNode.pre = temp;

        }
    }

    // 修改一个节点的内容，双向链表的节点内容修改和单向链表一样
    // 只是节点类型改变
    public void update(HeroNode2 newHeroNode) {
        // 判断是否为空
        if (head.next == null) {
            System.out.println("链表为空~");
            return;
        }
        // 找到需要修改的节点，根据 no 编号
        // 定义一个辅助变量
        HeroNode2 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.printf("没有找到编号 %d 的节点，不能修改\n", newHeroNode.no);
        }
    }

    // 删除节点
    // 说明
    // 1. 对于双向链表，我们可以直接找到要删除的这个节点
    // 2. 找到后，自我删除即可
    public void delete(int no) {
        // 判断是否为空
        if (head.next == null) {
            System.out.println("链表为空~");
            return;
        }
        // 根据 no 编号，找到需要删除的节点
        // 定义一个辅助变量
        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);
        }

    }

    // 遍历双向链表
    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 = temp.next;
        }
    }
}

// 定义 HeroNode，每个 HeroNode 对象就是一个节点
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 "HeroNode2{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickname='" + nickname + '\'' +
                '}';
    }
}

单向环形链表

JosePhu（约瑟夫、约瑟夫环）问题

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

提示：

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

代码：

package com.lango.linkedlist;

/**
 * 约瑟夫问题（环形链表）
 *
 * @author Lango
 * @version 1.0
 */
public class Josephu {
    public static void main(String[] args) {
        // 测试
        CircleSingleLinkedList circleSingleLinkedList = new CircleSingleLinkedList();
        circleSingleLinkedList.addBoy(5);
        circleSingleLinkedList.showBoy();

        // 测试小孩出圈
        circleSingleLinkedList.countBoy(1,2,5); // 2 -> 4 -> 1 -> 5 -> 3
    }
}

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

    // 添加小孩节点，构建成一个环形链表
    public void addBoy(int nums) {
        // nums 数据校验
        if (nums < 1) {
            System.out.println("nums的值不正确");
            return;
        }
        Boy curBoy = null; // 辅助指针，帮助构建环形链表
        // 使用 for 循环创建我们的环形链表
        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);
                boy.setNext(first);
                curBoy = boy;
            }
        }
    }

    // 遍历当前的环形链表
    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 countNum 表示数几下
     * @param nums     表示最初有多少小孩在圈中
     */
    public void countBoy(int startNO, int countNum, int nums) {
        // 先对数据进行校验
        if (first == null || startNO < 1 || startNO > nums) {
            System.out.println("参数输入有误，请重新输入");
            return;
        }
        // 创建一个辅助指针，帮助完成小孩出圈
        Boy helper = first;
        // 需求创建一个辅助指针（变量）helper，事先应该指向环形链表的最后这个节点
        while (true) {
            if (helper.getNext() == first) { // 说明 helper 指向最后小孩节点
                break;
            }
            helper = helper.getNext();
        }
        // 小孩报数前，先让 first 和 helper 移动 k - 1 次
        for (int i = 0; i < startNO - 1; i++) {
            first = first.getNext();
            helper = helper.getNext();
        }
        // 当小孩报数时，让 first 和 helper 指针同时移动 m - 1 次，然后出圈
        // 这里是一个循环操作，直到圈中只有一个节点
        while (true) {
            if (helper == first) { // 说明圈中只有一个节点
                break;
            }
            // 让 first 和 helper 指针同时移动 countNum - 1
            for (int i = 0; i < countNum - 1; i++) {
                first = first.getNext();
                helper = helper.getNext();
            }
            // 这时 first 指向的节点，就是要出圈的节点
            System.out.printf("小孩%d出圈\n",first.getNo());
            // 这时将 first 指向的小孩节点出圈
            first = first.getNext();
            helper.setNext(first);
        }
        System.out.printf("最后留在圈中的小孩编号%d \n",helper.getNo());
    }
}

// 创建一个 boy 类，表示一个节点
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;
    }
}
superLango
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构与算法 链表.doc
09-30
数据结构与算法 链表.doc
数据结构与算法——线性表（链表篇）
小田是个程序员的博客欢迎你的到来呀~
06-20 2万+
本篇文章，主要详细解读和总结线性表的链式存储结构——链表，包括单链表、双链表、静态链表以及循环链表，讲解较为全面，图文并茂，总结各链表的特性以及基本操作，干货满满，各位小伙伴们请细细品读，你会收获你想要的知识的！.........
数据结构与算法学习笔记
热门推荐
ityqing的博客
09-25 33万+
本文是王争老师的《算法与数据结构之美》的学习笔记，详细内容请看王争的专栏。有不懂的地方指出来，我做修改。 数据结构与算法思维导图 数据结构指的是“一组数据的存储结构”，算法指的是“操作数据的一组方法”。 数据结构是为算法服务的，算法是要作用再特定的数据结构上的。 最常用的数据结构预算法: 数据结构：数组、链表、栈、队列、散列表、二叉树‘、堆、跳表、图、Tire树 算法： 递归...
【尚硅谷】Java数据结构与算法笔记03 - 链表
知不足而奋进，望远山而前行
12-07 1万+
链表是有序的列表，它在内存中的存储如下：单链表(带头结点) 逻辑结构示意图如下：使用带 head 头的单向链表实现 - 水浒英雄排行榜管理完成对英雄人物的增删改查操作 输出： 2.3 面试题（新浪、百度、腾讯） 求单链表中有效节点的个数 查找单链表中的倒数第k个结点 单链表的反转 从尾到头打印单链表 合并两个有序链表 三、双向链表 3.1 思路分析 使用带 head 头的双向链表实现 - 水汻英雄排行榜管理单向链表的缺点分析:分析 双向链表的遍历, 添加, 修改, 删除的操作思路 ===>===>===
数据结构与算法 链表
weixin_65637841的博客
10-04 606
数据结构与算法 链表 1、链表介绍 2、单链表的实现 3、单链表面试题(新浪、百度、腾讯) 4、双向链表的实现 5.Josephu问题及循环链表
Java数据结构与算法之链表插入操作
m0_43405302的博客
10-29 1808
一、链表的定义 链表是数据结构中线性结构中最为重要的数据结构，关于Java链表的定义以及数据实例化，请查看数据结构之数组和链表（Java语言描述）。 二、插入元素操作 在介绍插入元素之前，我先对数据进行进行节点实例化。首先，我们建立n1、n2和n3的三个节点，其中n1的后继节点是n2，现在我们想把n3插入其中。这样我们有三种插入方式： class ListNode{ int val; //节点值 ListNode next; //后续节点使用 ListNode(int x){val=x;} } Li
数据结构与算法之链表
努力让自己发光，对的人才能迎着光而来
08-24 1万+
单链表 概念 单链表操作 循环链表 概念 循环链表操作 双向循环链表 概念 双向循环链表操作单链表 概念 单链表操作 实现类： 测试类： 循环链表 概念 循环链表操作 实现类： 测试类： 双向链表 概念 双向链表操作 实现类： 测试类： ...
数据结构与算法-链表（练习一）
LoveXming的博客
03-12 1372
数据结构与算法-链表练习
数据结构与算法 -- 链表
u012967763的专栏
08-21 526
一点一滴学算法，算法从入门到放弃
数据结构与算法（总结）
weixin_45397053的博客
04-23 5万+
总结： 一、数据结构（Data Structure） 是数据的组织结构，用来组织、存储数据。算法（Algorithm） 就是解决问题的方法或者过程。 二、数据结构分为逻辑结构和物理结构。逻辑结构分为集合结构、线性结构、树形结构、图形结构；物理结构分为顺序存储结构、链式存储结构。 三、算法是一系列运算步骤。算法有5个基本特性，输入、输出、有穷性、确定性、可行性；算法最求5个目标，正确性、可读性、健壮性、运行时间少、内存空间小。 四、「数组」 是实现线性表的顺序结构存储的基础；「链表」 是实现线性表的链式存储结
数据结构与算法实验报告——实验一 链表
weixin_46055804的博客
04-28 9346
实验一 链表 实验目的和要求 1.理解线性表的链式存储结构。 2.熟练掌握动态链表结构及有关算法的设计。 根据具体问题的需要，设计出合理的表示数据的链表结构，并设计相关 算法。 实验任务 1. 对任意输入的一组数据，建立一个递增有序的单链表。 2. 将单链表Ｌ中的奇数项和偶数项结点分解开，并分别连成一个单链表。 3. 用递增有序的链表A、B表示两个集合，判断B是否是A的子集。 4. 用递增...
《数据结构与算法》课程上机实验二（链表）_链表_fruitd55_C++_数据结构与算法_
10-04
编写一个程序，实现单链表的各种基本运算，并在此基础上完成初始化等各种基础功能。
JavaScript数据结构与算法之链表
10-22
链表就是线性表中针对顺序存储结构的一种优化手段，但是在javascript语言中由于数组的特殊性（自动更新引用位置），所以我们可以采用对象的方式做链表存储的结构
java数据结构与算法.pdf
01-04
包含了各种数据结构和算法（java）的实现方式和详解（图解），包括单双链表、环形链表（约瑟夫问题）、栈、后缀表达式、中缀表达式转后缀表达式、迷宫问题、八大排序算法、多种查找算法、哈希表、二叉树实现以及操作...
恋上数据结构与算法课件.rar
11-23
主要针对复杂度、链表、栈、队列、二叉树、B树、红黑树、集合。课件包含图片展示，容易理解，爱，就码上行动。
jdk8新特性----Lambda表达式
最新发布
w_t_y_y的博客
05-11 184
Java的Lambda表达式是Java 8引入的一个特性，它支持函数式编程，允许将函数作为方法的参数或返回值，从而简化了匿名内部类的使用，并提供了对并行编程的更好支持。
java jar包如何运行或调用
NLP与推荐算法
05-08 254
java服务启动
【数据结构】二叉树
m0_73911405的博客
05-05 647
前序：根，左子树，右子树中序：左子树，根，右子树后序：左子树，右子树，根N代表空元素前序 1 2 3 N N N 4 5 N N 6 N N中序 N 3 N 2 N 1 N 5 N 4 N 6 N后序 N N 3 N 2 N N 5 N N 6 4 1层序 1 2 4 3 5 6一层层从左到右一个树分成根和子树，子树再分为根和子树。
CMS垃圾回收器为什么被移除
m0_54187478的博客
05-10 342
由于上述缺点，加上需要将资源投入到更现代垃圾回收器的开发和优化上，Oracle决定从Java 9开始标记CMS为废弃，并在后续版本中完全移除CMS。这些新的收集器旨在提供更低的停顿时间和更高的性能，同时减少配置和维护的复杂性。当它在垃圾收集周期内无法足够快地回收内存时，会退回到一种需要完全暂停所有应用线程的老年代收集模式，这与它设计的初衷相违背。：CMS使用的标记-清除算法会导致较多的内存碎片。：CMS需要更多的CPU资源来执行垃圾回收的并发阶段，而且它在运行时对系统资源的利用也较为激进。
数据结构与算法 链表代码
06-09
好的，以下是一个简单的链表的实现代码，包括链表的创建、插入、删除和遍历等基本操作： ```python class Node: def __init__(self, data=None): self.data = data self.next = None class LinkedList: def __...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

superLango

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值