环形链表解释约瑟夫问题

IT小辉同学

已于 2023-05-14 18:06:47 修改

阅读量901

点赞数 2

分类专栏：基础扎实文章标签：链表数据结构 java

于 2023-05-14 18:05:47 首次发布

本文链接：https://blog.csdn.net/weixin_53742691/article/details/130671582

版权

基础扎实专栏收录该内容

120 篇文章 3 订阅

订阅专栏

环形链表解释约瑟夫问题

来自尚硅谷开放课程的迁移学习，致敬尚硅谷的各位老师，受益匪浅！！！

单向链表，双向链表，环形链表对比介绍

单向链表、双向链表和环形链表都是常见的链表数据结构，它们在不同场景下具有不同的特点和优缺点。

单向链表：

特点：

插入和删除操作只能在头部进行；
遍历整个链表时，时间复杂度为O(n)。

使用场景：

当需要在链表头插入或删除元素时，可以选择单向链表；
需要高效地遍历整个链表时，可以使用单向链表。

优点：

插入和删除操作简单；
遍历整个链表的时间复杂度较低。

缺点：

只能在头部进行插入和删除操作；
不适用于需要在任意位置插入或删除元素的场景。

双向链表：

特点：

在任意位置都可以进行插入和删除操作；
遍历整个链表的时间复杂度为O(1)。

使用场景：

需要频繁地在链表中插入和删除元素时，可以选择双向链表；
需要高效地遍历整个链表时，可以使用双向链表。

优点：

可以方便地在任意位置插入和删除元素；
遍历整个链表的时间复杂度较低。

缺点：

由于需要维护两个指针，空间开销较大；
在插入和删除操作时，可能需要移动后面的节点。

环形链表：

特点：

每个节点都指向前一个节点的下一个节点；
如果某个节点不存在，则形成一个环。

使用场景：

当需要表示循环的数据结构时，可以选择环形链表；
需要快速查找某个节点的前驱节点时，可以使用环形链表。

优点：

可以方便地表示循环的数据结构；
在查找前驱节点时，时间复杂度为O(1)。

缺点：

每个节点都需要指向前一个节点的下一个节点，空间开销较大；

约瑟夫问题引入

约瑟夫问题是一个经典的数学问题，它描述了有n个人围成一圈，从第一个人开始报数，报到m的人出圈，直到只剩下一个人。问这个人是谁。这个问题可以用循环链表来解决。

具体来说，我们可以定义一个长度为n的循环链表，其中每个节点包含两个信息：当前的位置i和已经出圈的人数count。初始时，第一个节点的位置为1,count为0;其余节点的位置为2、4、6…n-1,count均为1。然后从第一个节点开始报数，每报到一个位置i的人出圈，同时更新该节点的count值。当count变为n-1时，指向该节点的前一个节点即为最后幸存者。

这个方法的时间复杂度是O(n),空间复杂度是O(1)。因此，它是一种高效的解决方案。

环形链表与约瑟夫问题之间的关联在于，我们可以使用环形链表来模拟约瑟夫问题的过程。具体来说，我们可以将每个人看作一个节点，将他们的位置作为该节点的值，将已经出圈的人数作为该节点的count值。这样，我们就可以使用环形链表来模拟约瑟夫问题的过程了。

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6EOvdAzi-1684058523540)(C:\Users\ASUS\AppData\Roaming\Typora\typora-user-images\image-20230514161609028.png)]$

思路解析

约瑟夫问题-创建环形链表的思路：

构建一个单向的环形链表

1.先创建第一个节点，让first指向该节点，并且形成环形

2.后面我们每创建一个新的节点，就把该节点加入已有的环形链表中

遍历环形链表

1.先让第一个辅助指针（变量）curBoy，指向first节点

2.然后通过一个while循环遍历该环形链表即可curBoy.next==first结束

约瑟夫问题-小孩出圈的思路分析：

根据用户的输入，生成有n个小孩出圈的顺序

n=5,即有5个人

k=1,从第一个人开始报数

m=2,数两下

1.需要创建一个辅助指针（变量）helper，事先应该指向环形链表的最后这一个节点

2.小孩报数前，先让first和helper移动k-1次

3.当小孩报数时，让first和helper指针同时移动m-1次

4.这时就可以将first指向的小孩节点出圈

first=first.next

helper.next=first

原来first指向的节点就没有任何作用,就会被回收

出圈的顺序

2->4->1->5->3

代码描述

package com.success.day05;

/**
 * @Description 创建一个Boy实体类
 * @Author IT小辉同学
 * @Date 2023/05/14
 */
class Boy {
    private int no; //编号
    private Boy next; //指向下一个节点，默认为null

    /**
     * @Description 构造函数
     * @Author IT小辉同学
     * @Date 2023/05/14
     */
    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;
    }
}

/**
 * @Description 创建一个环形单向链表
 * @Author IT小辉同学
 * @Date 2023/05/14
 */
class CircleSingleLinkedList {
    //创建一个first节点，当前没有编号
    private Boy first = null;

    /**
     * @Description 添加小孩节点，形成一个环形的链表
     * @Author IT小辉同学
     * @Date 2023/05/14
     */
    public void addBoy(int nums) {
        //对于nums数据进行校验
        if (nums < 1) {
            System.out.printf("nums的值不正确");
            return;
        }
        //创建辅助指针，帮助构建环形链表
        Boy curBoy = null;
        //循环创建环形链表
        for (int i = 1; i <= nums; i++) {
            //根据编号，创建小孩节点
            Boy boy = new Boy(i);
            //如果是第一个小孩
            if (i == 1) {
                first = boy;
                first.setNext(first); //构成环
                curBoy = first;
            } else {
                curBoy.setNext(boy);
                boy.setNext(first);
                curBoy = boy;
            }
        }
    }

    /**
     * @Description 遍历当前的环形链表
     * @Author IT小辉同学
     * @Date 2023/05/14
     */
    public void showBoy() {
        //判断链表是否为空
        if (first == null) {
            System.out.printf("没有任何小孩~~");
            return;
        }
        // 因为 first 不能动，因此我们仍然使用一个辅助指针完成遍历
        Boy curBoy = first;
        while (true) {
            System.out.printf("小孩的编号 %d \n", curBoy.getNo());
            //判断是不是遍历到了最后一个节点
            if (curBoy.getNext() == first) {
                break;
            }
            // curBoy 后移
            curBoy = curBoy.getNext();
        }
    }

    /**
     * @param countNum 表示数几下
     * @param nums     表示最初有多少小孩在圈中
     * @Param startNo 表示数几下
     * @Return
     * @Description 根据用户的输入，计算出小孩出圈的顺序
     * @Author IT小辉同学
     * @Date 2023/05/14
     */
    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) {
            //说说明helper已经指向了最后一个小孩节点
            if (helper.getNext() == first) {
                break;
            }
            helper = helper.getNext();
        }
        //小孩报数前，先让 first 和 helper 移动 k - 1 次
        for (int j = 0; j < startNo - 1; j++) {
            first = first.getNext();
            helper = helper.getNext();
        }
        //当小孩报数时，让 first 和 helper 指针同时 的移动 m - 1 次, 然后出圈
        //这里是一个循环操作，知道圈中只有一个节点
        while (true) {
            if (helper == first) { //说明圈中只有一个节点
                break;
            }
            //让 first 和 helper 指针同时 的移动 countNum - 1
            for (int j = 0; j < countNum - 1; j++) {
                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", first.getNo());
    }
}

public class Josepfu {
    public static void main(String[] args) {
        // 测试一把看看构建环形链表，和遍历是否 ok
        CircleSingleLinkedList circleSingleLinkedList = new CircleSingleLinkedList();
        circleSingleLinkedList.addBoy(5);// 加入 5 个小孩节点
        circleSingleLinkedList.showBoy();
        //测试一把小孩出圈是否正确
        circleSingleLinkedList.countBoy(1, 6, 5); // 2->4->1->5->3
    }
}