【Java数据结构和算法】007-链表：循环链表和约瑟夫问题

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

0、警醒自己

1、学习不用心，骗人又骗己；

2、学习不刻苦，纸上画老虎；

3、学习不惜时，终得人耻笑；

4、学习不复习，不如不学习；

5、学习不休息，毁眼伤身体；

7、狗才等着别人喂，狼都是自己寻找食物；

 

一、循环列表和约瑟夫问题

1、单向环形列表应用场景

Josephu(约瑟夫、约瑟夫环)  问题：

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

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

 

2、单向环形链表介绍

（第一个节点指定第二个节点、第二个节点指向第三个节点……最后一个节点又指向第一个节点，由此形成了一个环）

 

3、约瑟夫问题解决思路图解

 

二、添加节点

（瑕疵方案-自己想的，添加节点的方法是跟老师讲的一样的，遍历写得不一样，我写的有瑕疵，老师写的会在“代码演示”下面贴出来）

1、实现逻辑图解

 

2、代码演示

我写的：

package com.zb.ds;

public class TestJosephu {
    public static void main(String[] args) {
        CircularList list = new CircularList();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        list.show();
    }
}
//list
class CircularList{
    BoyNode first;
    BoyNode current;

    //添加一个节点
    public void add(int id){
        //这里主要目的是演示添加节点，不再考虑id重复的情况
        BoyNode boy = new BoyNode(id);
        //如果first为null，说明这是第一个节点
        if(first==null){
            first = boy;
            current = boy;
            current.next = boy;
        }else {
            current.next = boy;
            current = boy;
            current.next = first;
        }
    }

    //循环遍历输出boy，我们从first输出到current
    public void show(){
        if(first==null){
            System.out.println("无任何节点！");
            return;
        }
        BoyNode temp = first;
        System.out.println(temp.id);
        do {
            temp = temp.next;
            System.out.println(temp.id);
        }while (temp.next!=first);
    }
}
//boy
class BoyNode{

    int id;
    BoyNode next;

    public BoyNode(int id) {
        this.id = id;
    }
}

根据老师讲解写的（遍历）：

package com.zb.ds;

public class TestJosephu {
    public static void main(String[] args) {
        CircularList list = new CircularList();
        list.add(5);
        list.show();
    }
}
//list
class CircularList{
    //创建一个first节点，没有编号
    BoyNode first;
    //创建curBoy，辅助我们构建环形列表，主要作用是记录环形列表的尾
    BoyNode curBoy;

    //添加节点，构建环形列表，nums为节点的数量
    public void add(int nums){
        //验证nums，如果nums<1，则返回
        if(nums<1){
            System.out.println("nums不能小于1");
            return;
        }
        //使用for循环创建环形列表
        for (int i = 1; i <= nums; i++) {
            //根据编号创建节点
            BoyNode boy = new BoyNode(i);
            //如果是第一个小孩，咱们对齐进行记录
            if(i==1){
                first = boy;
                //自己成环
                first.next = first;
                curBoy = first;
            }else {
                curBoy.next = boy;
                boy.next = first;
                curBoy = boy;
            }
        }
    }

    //循环遍历输出boy，我们从first输出到current
    public void show(){
        System.out.println("当前链表的所有小朋友编号：");
        if(first==null){
            System.out.println("无任何节点！");
            return;
        }
        BoyNode temp = first;
        while (true){
            System.out.print(temp.id + " ");
            if(temp.next==first){
                //此时当前节点的next指向first，说明是最后一个节点
                break;
            }
            temp = temp.next;
        }
        System.out.println();
    }
}
//boy
class BoyNode{

    int id;
    BoyNode next;

    public BoyNode(int id) {
        this.id = id;
    }
}

 

3、运行结果

我写的：

根据老师讲解写的：

评析：

区别不大！

 

三、出圈（瑕疵方案-自己想的）

1、实现逻辑图解

 

2、代码演示

（再次明确我们的需求：有n个小朋友、从第k个小朋友开始数，数到m的出场！）

package com.zb.ds;

public class TestJosephu {
    public static void main(String[] args) {
        CircularList.go(10,3,6);
    }
}
//list
class CircularList{
    BoyNode first;
    BoyNode current;

    //添加一个节点
    public void add(int id){
        //这里主要目的是演示添加节点，不再考虑id重复的情况
        BoyNode boy = new BoyNode(id);
        //如果first为null，说明这是第一个节点
        if(first==null){
            first = boy;
            current = boy;
            current.next = boy;
        }else {
            current.next = boy;
            current = boy;
            current.next = first;
        }
    }

    //循环遍历输出boy，我们从first输出到current
    public void show(){
        System.out.println("当前链表的所有小朋友编号：");
        if(first==null){
            System.out.println("无任何节点！");
            return;
        }
        BoyNode temp = first;
        System.out.print(temp.id);
        do {
            temp = temp.next;
            if(temp.id!=temp.next.id){
                System.out.print(temp.id);
            }
        }while (temp.next!=first);
        System.out.println();
    }

    //进行出场模拟：有n个小朋友、从第k个小朋友开始数，数到m的出场
    //这里之演示简化之后的模型，不考虑过多其他情况
    public static void go(int n,int k,int m){
        //初始化list
        CircularList list = new CircularList();
        //初始化n个小朋友
        for (int i = 1; i <= n; i++) {
            list.add(i);
            System.out.println("初始化了第" + i + "个小朋友！");
        }

        //定义一些辅助变量
        BoyNode last = new BoyNode(-1),next = new BoyNode(-2);
        int num = 0;
        BoyNode temp = list.getFirst();
        boolean add = false;
        while (last!=next){
            //数之前记录上一个节点
            last = temp;
            if(temp.id==k){
                add = true;
            }
            if(add){
                //数数
                num++;
            }
            temp = temp.next;
            //数之后记录下一个节点
            next = temp.next;
            if(num==m){
                //如果first出圈了，就像下一个赋值给first
                if(temp.id==list.first.id){
                    list.first=next;
                }
                System.out.println("出圈小朋友的id为：" + temp.id);
                //数到了，直接将
                last.next = next;
                k = next.id;
                num=0;
                //显示当前剩余节点
                list.show();
            }
        }
        //跳出循环之后，还有两个，分别出局即可
        System.out.println("出圈小朋友的id为：" + temp.id);
        last.next = last;
        //显示当前剩余节点
        list.show();
        System.out.println("出圈小朋友的id为：" + list.first.id);
        list.first = null;
        list.show();
    }

    public BoyNode getFirst() {
        return first;
    }

    public BoyNode getCurrent() {
        return current;
    }
}
//boy
class BoyNode{

    int id;
    BoyNode next;

    public BoyNode(int id) {
        this.id = id;
    }
}

 

3、运行结果

（看上去，我们成功了，实际上还是存在瑕疵的！）

初始化了第1个小朋友！
初始化了第2个小朋友！
初始化了第3个小朋友！
初始化了第4个小朋友！
初始化了第5个小朋友！
初始化了第6个小朋友！
初始化了第7个小朋友！
初始化了第8个小朋友！
初始化了第9个小朋友！
初始化了第10个小朋友！
出圈小朋友的id为：9
当前链表的所有小朋友编号：
1234567810
出圈小朋友的id为：5
当前链表的所有小朋友编号：
123467810
出圈小朋友的id为：2
当前链表的所有小朋友编号：
13467810
出圈小朋友的id为：10
当前链表的所有小朋友编号：
134678
出圈小朋友的id为：8
当前链表的所有小朋友编号：
13467
出圈小朋友的id为：1
当前链表的所有小朋友编号：
3467
出圈小朋友的id为：4
当前链表的所有小朋友编号：
367
出圈小朋友的id为：3
当前链表的所有小朋友编号：
67
出圈小朋友的id为：7
当前链表的所有小朋友编号：
6
出圈小朋友的id为：6
当前链表的所有小朋友编号：
无任何节点！

 

四、出圈（较完美方案-老师讲的）

1、思路分析

 

2、代码演示

package com.zb.ds;

public class TestJosephu {
    public static void main(String[] args) {
        CircularList list = new CircularList();
        list.go(5,1,2);
    }
}
//list
class CircularList{
    //创建一个first节点，没有编号
    BoyNode first;
    //创建curBoy，辅助我们构建环形列表，主要作用是记录环形列表的尾
    BoyNode curBoy;

    //添加节点，构建环形列表，nums为节点的数量
    public void add(int nums){
        //验证nums，如果nums<1，则返回
        if(nums<1){
            System.out.println("nums不能小于1");
            return;
        }
        //使用for循环创建环形列表
        for (int i = 1; i <= nums; i++) {
            //根据编号创建节点
            BoyNode boy = new BoyNode(i);
            //如果是第一个小孩，咱们对齐进行记录
            if(i==1){
                first = boy;
                //自己成环
                first.next = first;
                curBoy = first;
            }else {
                curBoy.next = boy;
                boy.next = first;
                curBoy = boy;
            }
        }
    }

    //循环遍历输出boy，我们从first输出到current
    public void show(){
        System.out.println("当前链表的所有小朋友编号：");
        if(first==null){
            System.out.println("无任何节点！");
            return;
        }
        BoyNode temp = first;
        while (true){
            System.out.print(temp.id + " ");
            if(temp.next==first){
                //此时当前节点的next指向first，说明是最后一个节点
                break;
            }
            temp = temp.next;
        }
        System.out.println();
    }
    /**
     * 进行出场模拟：有n个小朋友、从第k个小朋友开始数，数到m的出场
     * 这里之演示简化之后的模型，不考虑过多其他情况
     * @param n 有几个小孩
     * @param k 从第几个小孩开始数
     * @param m 数几次出圈
     */
    public void go(int n,int k,int m){
        //首先进行数据校验
        if(k<1 || k>n){
            System.out.println("参数输入有误，请重新输入！");
            return;
        }
        //1、创建一个辅助变量helper，事先应该指向环形列表的最后一个节点；
        //创建环形链表
        add(n);
        //创建辅助变量helper，将helper指向环形链表的最后一个节点
        //其实这个时候最后一个节点就是curBoy，我写的curBoy是全局变量，老师写的是局部变量
        //写法一：老师写的
        BoyNode helper = first;
        //此时说明helper是最后一个节点了
        while (helper.next != first) {
            helper = helper.next;
        }
        //写法二：因为咱用的是全局变量，所有在add的时候curBoy指向的就是最后一个节点，所以直接赋值即可
        System.out.println(helper.id == curBoy.id);//咱在这里做一个的简单的验证，实际使用的时候可以直接赋值
        //2、小孩报数前，让first和helper同时移动移动k-1个位置；
        for (int i = 0; i < k-1; i++) {
            first = first.next;
            helper = helper.next;
        }
        //3、当小孩报数时，让first和helper同时移动m-1个位置；
        //此时说明圈中只有一个节点
        while (first != helper) {
            //让first和helper同时移动m-1个位置
            for (int i = 0; i < m - 1; i++) {
                first = first.next;
                helper = helper.next;
            }
            //移动完了，此时将first指向的小孩出圈
            System.out.println("出圈：" + first.id);
            first = first.next;
            helper.next = first;
        }
        //退出while循环的时候，剩下最后一个节点
        System.out.println("出圈：" + first.id);
    }
}
//boy
class BoyNode{

    int id;
    BoyNode next;

    public BoyNode(int id) {
        this.id = id;
    }
}

 

3、运行结果

 

五、总结

当理解老师的大致思路之后，觉得自己可以代码实现，最终发现自己写的代码有一些不完美，而且容易扰乱思路。但这是非常有必要的，因为如果全部跟着老师的思路来，确实不会出任何问题，但自己的思考在哪里呢？狗才等着别人喂，狼都是自己寻找食物；我希望自己能够在学习老师讲解的基础上有自己的想法或者理解。需要注意的一点是，老师的解题方法是比较完善的，自己的写法往往考虑不到一些情况，这里是要重视老师对各种情况的把控，毕竟理想状态是很少的，实际工作中不是理想状态！

 

 

 

 

 

 

 

 

訾博ZiBo
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Java数据结构与算法】环形链表及约瑟夫问题
12-21
【Java数据结构与算法】环形链表及约瑟夫问题 环形链表是一种特殊的数据结构，它的每个节点都包含一个数据元素和一个指向下一个节点的指针，且最后一个节点的指针会指向列表的第一个节点，形成一个闭合的循环。这种...
Java采用循环链表结构求解约瑟夫问题
09-04
在Java中，我们可以使用循环链表数据结构来解决约瑟夫问题。循环链表是一种特殊的链表，它的最后一个节点的next指针指向链表的第一个节点，形成一个闭合的环状结构。下面详细讲解如何实现这个解决方案。 首先，我们...
约瑟夫问题与魔术（一）——数学模型求解
magic2728的博客
09-04 623
最近两个月，思潮涌动，止不住笔地写了一系列的随笔（《听相声有感（三）——拼积累》，《传承的底线——关于研究癌症获奖神童的思考》），以及一些访谈活动（《智玩达人李学志老师访谈录》，《智玩达...
约瑟夫环模型问题的题解(java)
乐行僧的博客
09-20 459
1~10十个人进行编号，开始报数，报到3的人淘汰，剩余的人是编号为几的人？ 解题思路：设置一个长度为11的数组，其中索引为0的位置不进行编号，这索引和索引对应元素的值是意义对应的，即index==arr[index],被淘汰的人其元素值置为-1，用来标记其被淘汰。定义一个计数器count1来计数已经被淘汰的人，每当一个被淘汰时，计数器就加1。当计数器的值为9时，即10个人只剩一人，此时退出程序。此...
约瑟夫问题详解
weixin_43897882的博客
02-09 5594
1.什么是约瑟夫问题 设有编号为1，2，……，n的n(n>0)个人围成一个圈，从第1个人开始报数，报到m时停止报数，报m的人出圈，再从他的下一个人起重新报数，报到m时停止报数，报m的出圈，……，如此下去，直到所有人全部出圈为止。当任意给定n和m后，设计算法求n个人出圈的次序。 2.暴力解法 最直接的方法就是模拟报数的过程。模拟n-1次报数的过程，每次报数报m个人，第m个人被淘汰。最后查看哪个编号没有报到，该编号为结果。# 学习目标： 但是这样的时间复杂度是O(m*n)。所以当m和n较大的时候，
【尚硅谷】Java数据结构与算法笔记03 - 链表
热门推荐
知不足而奋进，望远山而前行
12-07 1万+
链表是有序的列表，它在内存中的存储如下：单链表(带头结点) 逻辑结构示意图如下：使用带 head 头的单向链表实现 - 水浒英雄排行榜管理完成对英雄人物的增删改查操作 输出： 2.3 面试题（新浪、百度、腾讯） 求单链表中有效节点的个数 查找单链表中的倒数第k个结点 单链表的反转 从尾到头打印单链表 合并两个有序链表 三、双向链表 3.1 思路分析 使用带 head 头的双向链表实现 - 水汻英雄排行榜管理单向链表的缺点分析:分析 双向链表的遍历, 添加, 修改, 删除的操作思路 ===>===>===
Java数据结构和算法---链表(单链表、双向链表、约瑟夫环)
TIANJIAWEN的博客
03-28 1321
拿下大厂!
数据结构和算法学习--循环链表应用--约瑟夫问题
weixin_45129136的博客
05-14 115
约瑟夫问题是个有名的问题：N个人围成一圈，从第一个开始报数，第M个将被杀掉，最后剩下一个，其余人都将被杀掉。例如N=6，M=5，被杀掉的顺序是：5，4，6，2，3，1。（此处取自百度百科） 用单链表模拟让计算机运行告诉结果 编程思想，建立N个节点的循环链表，每个节点都可以是Boolean true，每经过M-1个true节点就将第M个节点设为false，直到只剩最后一个true节点（判断为p.next=p），该节点即为幸存。（遍历时由于所有节点一直存在，因此时间复杂度会较高） 或者每经过M-1个节点就释放第
数据结构与算法 - 基础：循环链表（补充）
qq_33240556的博客
04-24 414
循环链表相比普通单向链表的优势在于某些情况下可以简化边界条件的处理，特别是当算法需要围绕链表的末尾无缝转至头部时。但同时，由于增加了判断循环结束的逻辑，对于一些简单的操作可能会稍微复杂化实现过程。，而是回指到链表的头节点，从而形成了一个逻辑上的环形结构。这样做的好处在于可以很容易地实现循环遍历，对于那些需要进行循环访问或处理闭环性质问题的数据结构非常适用。循环链表是单向链表或双向链表的一种变体，其中最后一个节点的指针不再是指向。
数据结构与算法（java）：线性表（链表-环形链表与约瑟夫问题）
lalala_dxf的博客
02-19 487
线性表（约瑟夫）
数据结构与算法--单向循环链表解决约瑟夫问题
weixin_45787495的博客
01-06 238
文章目录一、什么是约瑟夫问题二、约瑟夫问题举例1.题目描述2.解题思路3.图例分析三、代码示例 一、什么是约瑟夫问题 约瑟夫问题（有时也称为约瑟夫斯置换，是一个计算机科学和数学中的问题。在计算机编程的算法中，类似问题又称为约瑟夫环。又称“丢手绢问题”） 二、约瑟夫问题举例 1.题目描述 设编号为 1，2，… n 的 n 个人围坐一圈，约定编号为 k（1<=k<=n）的人从 1 开始报数，数到 m 的那个人出列，它的下一位又从 1 开始报数，数到 m 的那个人又出列，依次类推，直到所有人出列为止
约瑟夫问题（单向循环链表）---Java数据结构与算法
LanceHang的博客
07-10 396
约瑟夫问题，有时也称为约瑟夫斯置换，是一个出现在计算机科学和数学中的问题。在计算机编程的算法中，类似问题又称为约瑟夫环。又称“丢手绢问题”. 假设有num个小孩在玩丢手绢，现在从第n个小孩开始数数，数到第m个数，把这个数删除，接着从这个被删除的数开始数m个，在删除，再数… 例如：有五个孩子在玩丢手绢，从第二个小孩开始数，数2次，那么会得到一个出圈顺序：3-5-2-1-4 解决约瑟夫问题，我们正好可以用环形链表 相比于普通的单向链表，单向环形链表是把最后一个结点又指向了第一个结点。 因此我们可以先构建一个结
Java数据结构与算法-笔记-代码-课件-资料
05-17
内容包括: 稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式、递归与回溯、迷宫问题、八皇后问题、算法的时间复杂度、冒泡排序、...
循环双链表的约瑟夫问题-完整代码
10-04
试用双循环链表为存储结构， 写一个约瑟夫(Josephu) 问题的算法。约瑟夫问题是：有N个人围成一圈，由第i个人开始从1报数，数到m时，此人就出列。下一个人重新从1开始报数，再数到m时，又一个人出列，直到所有的人...
【初阶数据结构篇】单链表的实现（赋源码）
最新发布
2301_79849925的博客
07-25 1475
​ 链表是⼀种物理存储结构上⾮连续、⾮顺序的存储结构，数据元素的逻辑顺序是通过链表主要有两个部分：当前结点要保存的数据和保存下⼀个结点的地址（指针变量）。本篇主要介绍单链表的实现方法。
《Java初阶数据结构》----5.＜二叉树的概念及使用＞
m0_73456341的博客
07-24 1407
1.树的基本概念、2.二叉树概念及特性、3.二叉树的基本操作、4.二叉树相关编程题
数据结构——单链表OJ题（上）
2301_81888634的博客
07-24 843
一起加油，敬请期待“单链表OJ题（下）”~
数据结构（2）
m0_62881487的博客
07-23 1149
为建立数据元素之间的线性关系，对每个链表结点，除存放元素自身的信息之外，还需要存放一个指向其后继的指针。为指针域，存放其后继结点的地址。由于单链表的元素离散地分布在存储空间中，因此是非随机存取的存储结构。1. 线性表的链式存储又称单链表。它是指通过一组任意的存储单元来存储线性表中的数据元素。的存储单元依次存储线性表中的数据元素，从而使得逻辑上相邻的两个元素在物理地址上也相邻。3. 顺序表的特点是表中元素的逻辑顺序与其存储的物理顺序相同。2. 线性表的顺序存储又称顺序表。，分别指向其直接前躯和直接后继。
2024.7.24 作业
qq_64434282的博客
07-24 2047
【代码】2024.7.24 作业。
尚硅谷Java数据结构与算法详解：从面试题到实战应用
第二章概述了数据结构和算法之间的关系，并通过实际编程问题（如字符串替换、五子棋和约瑟夫问题）来展示它们在解决问题中的应用。这部分内容有助于理解理论与实践的结合。 接下来的章节深入到具体的数据结构，如...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值