链表 Linked List (Josephus 问题)

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

链表 Linked List

文章目录

一、介绍

链表是一种物理存储单元上非连续，非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现的。

Untitled

特点：

  1. 链表是以结点形式存储的，是链式存储
  2. 每个结点包含data区域和next区域
  3. 如上图各个结点并不是连续存储的
  4. 链表分带头结点链表和没有带头结点链表，根据实际的需求来确定
  • 带头结点链表逻辑结构

Untitled

二、单链表

1.需求：

根据带有头部的单链表，实现商品增删改查，并且也可以针对商品已编号进行排序，完成排行榜

Node节点：

package com.example.linklist.single.basic;

/**
 * 链表的节点：用来构成链表
 */
public class GoodNode {
    //节点需要有节点自己的信息
    int id;

    int price;

    String name;

    //节点需要有指向下一个节点的指针（引用）
    GoodNode next;

    public GoodNode(int id, int price, String name) {
        this.id = id;
        this.price = price;
        this.name = name;
    }
}

SingleLinkedList:

package com.example.linklist.single.basic;

/**
 * 自定义 链表
 */
public class MySingleLinkedList {

    //定义空的 头节点
    GoodNode head = new GoodNode(0,0,"");

    /**
     * 增加方法；在队尾直接添加
     */
    public void add(GoodNode goodNode){

        GoodNode temp = head;
        while (true){
            if (temp.next == null){
                break;
            }
            temp = temp.next;
        }
        temp.next = goodNode;
    }

    /**
     * 按id顺序添加
     */
    public void addById(GoodNode goodNode){

        GoodNode temp = head;

        while (true){

            if (temp.next == null){
                temp.next = goodNode;
                return;
            }
            //找到插入位置：先将后面的节点挂在 待插入节点后面，（如果先去挂载到前面）不然就丢了。
            if (temp.next.id > goodNode.id){
                goodNode.next = temp.next;
                temp.next = goodNode;
                return;
            }else if (temp.next.id == goodNode.id){
                System.out.println("存在相同id,不能插入");
                return;
            }

            temp = temp.next;

        }
    }

    /**
     * 修改：
     */
    public void update(GoodNode goodNode){
        //用来遍历 链表
        GoodNode temp = head.next;
        while (true){

            if (temp == null){
                return;
            }

            //找到id相同的 节点了
            if (temp.id == goodNode.id ){
                // 修改
                temp.id = goodNode.id;
                temp.name = goodNode.name;
                temp.price = goodNode.price;
                return;
            }
            //向后遍历
            temp = temp.next;

        }
    }

    /**
     * 删除：根据节点编号删除
     */
    public void delete(int id){

        //定义前一个节点 用于删除
        GoodNode tempBefore = head;
        //定义 节点 用于寻找 该id的节点。
        GoodNode temp = head.next;

        //是否找打的标识
        boolean flag = false;
        while (true) {
            //链表结束了
            if (temp == null){
                break;
            }
            //找到了
            if (temp.id == id){
                flag = true;
                break;
            }
            //继续向后遍历
            temp = temp.next;
            tempBefore = tempBefore.next;
        }

        if (flag){
            //使 temp前一个节点 直接连接后一个节点。（跳过temp节点）
            tempBefore.next = temp.next;
        }else {
            System.out.println("没找到该id的节点");
        }

    }

    /**
     * 查看 链表所有元素
     */
    public  void  list(){
        if (head.next == null){
            System.out.println("为空");
        }

        GoodNode temp = head.next;
        while (true){
            if (temp ==null){
                break;
            }
            System.out.printf("node id:%d,name:%s,price:%d \n",temp.id,temp.name,temp.price);
            temp = temp.next;
        }

    }

}

Test:

package com.example.linklist.single.basic;

public class SingleLinkedListTest {
    public static void main(String[] args) {
        GoodNode goodNode1 = new GoodNode(1,10,"上衣");
        GoodNode goodNode2 = new GoodNode(2,1,"鞋");
        GoodNode goodNode4 = new GoodNode(4,5,"帽子");

        MySingleLinkedList mySingleLinkedList = new MySingleLinkedList();

        mySingleLinkedList.add(goodNode1);
        mySingleLinkedList.add(goodNode2);
        mySingleLinkedList.add(goodNode4);
        mySingleLinkedList.list();

        mySingleLinkedList.update(new GoodNode(1,100,"上衣"));
        mySingleLinkedList.list();

        GoodNode goodNode3 = new GoodNode(3,8,"裤子");
        mySingleLinkedList.addById(goodNode3);
        mySingleLinkedList.delete(2);
        mySingleLinkedList.list();

        //结果：
        //node id:1,name:上衣,price:10
        //node id:2,name:鞋,price:1
        //node id:4,name:帽子,price:5

        //node id:1,name:上衣,price:100
        //node id:2,name:鞋,price:1
        //node id:4,name:帽子,price:5

        //node id:1,name:上衣,price:100
        //node id:3,name:裤子,price:8
        //node id:4,name:帽子,price:5

    }
}

二、双向链表

双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。

Untitled

Untitled

BookNode:

package com.example.linklist.doublelist.basic;

/**
 * 双向链表的节点
 * 有指向前驱节点的 pre ,有指向后继节点的 next
 */
public class BookNode {

    int id;

    String name;

    int price;

    //指向前驱
    BookNode pre;

    //指向后继
    BookNode next;

    public BookNode(int id, String name, int price) {
        this.id = id;
        this.name = name;
        this.price = price;
    }
}

DaulLinkedList:

package com.example.linklist.doublelist.basic;

import javax.xml.stream.FactoryConfigurationError;
import java.util.jar.JarEntry;

/**
 * 双向链表
 */
public class DualLinkedList {

    //头节点
    BookNode head = new BookNode(0, "", 0);

    /**
     * 在结尾添加节点
     */
    public void addLast(BookNode bookNode) {

        BookNode temp = head;

        while (true) {
            //到达 末尾
            if (temp.next == null) {
                break;
            }
            temp = temp.next;
        }
        //新节点加到 原链表 末尾。 新节点 前驱指向 原链表 末尾节点
        temp.next = bookNode;
        bookNode.pre = temp;
    }

    /**
     * 根据id插入：需要找到 比当前id大的 或者到末尾
     */
    public void addById(BookNode bookNode){
        //是否找到了 比当前大的
        boolean flag = false;
        BookNode temp = head;
        while (true){
            if (temp.next == null){
                break;
            }
            if (temp.next.id  > bookNode.id){
                flag = true;
                break;
            }else if (temp.next.id == bookNode.id){
                System.out.println("已存在，不能添加");
                return;
            }
            temp = temp.next;
        }
        if (flag){
            //新节点与后面节点 连接
            temp.next.pre = bookNode;
            bookNode.next = temp.next;
            //新节点 前面节点连接
            temp.next = bookNode;
            bookNode.pre = temp;
        }else {
            //没找到直接加到末尾
            temp.next = bookNode;
            bookNode.pre = temp;
        }
    }

    /**
     * 修改节点
     */
    public void update(BookNode bookNode) {

        BookNode temp = head.next;
        boolean flag = false;
        while (true) {
            if (temp == null) {
                break;
            }
            if (temp.id == bookNode.id) {
                flag = true;
                break;
            }
            temp = temp.next;
        }

        if (flag) {
            temp.name = bookNode.name;
            temp.price = bookNode.price;
        } else {
            System.out.println("未找到对应id 的节点。");
        }

    }

    /**
     * 双向链表删除
     */
    public void delete(int id) {
        BookNode temp = head;
        boolean flag = false;
        while (true) {
            if (temp.next == null) {
                break;
            }
            if (temp.next.id == id) {
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            //从前往后指
            temp.next = temp.next.next;
            //注意可能未num的情况。
            if (temp.next.next != null) {
                temp.next.next.pre = temp;
            }
        } else {
            System.out.println("没找到该id");
        }

    }

    public void list(){
        if (head.next == null){
            System.out.println("为空");
        }
        BookNode temp = head.next;
        while (true){
            if (temp == null){
                break;
            }
            System.out.printf("id:%d,name:%s,price:%d \n",temp.id,temp.name,temp.price);
            temp = temp.next;
        }

    }

}

Test:

package com.example.linklist.doublelist.basic;

public class DualTest {
    public static void main(String[] args) {
        DualLinkedList dualLinkedList = new DualLinkedList();

        BookNode bookNode1= new BookNode(1,"红楼梦",300);
        BookNode bookNode2= new BookNode(2,"水浒传",300);
        BookNode bookNode3= new BookNode(3,"西游记",300);
        BookNode bookNode4= new BookNode(4,"三国演义",300);
        dualLinkedList.addLast(bookNode1);
        dualLinkedList.addLast(bookNode2);
        dualLinkedList.addLast(bookNode3);
        dualLinkedList.addLast(bookNode4);
        dualLinkedList.list();

        BookNode bookNode= new BookNode(3,"西游记",400);
        dualLinkedList.update(bookNode);
        dualLinkedList.list();

        dualLinkedList.delete(2);
        dualLinkedList.list();

        dualLinkedList.addById(bookNode2);
        dualLinkedList.list();

        //结果：
        //id:1,name:红楼梦,price:300
        //id:2,name:水浒传,price:300
        //id:3,name:西游记,price:300
        //id:4,name:三国演义,price:300

        //id:1,name:红楼梦,price:300
        //id:2,name:水浒传,price:300
        //id:3,name:西游记,price:400
        //id:4,name:三国演义,price:300

        //id:1,name:红楼梦,price:300
        //id:3,name:西游记,price:400
        //id:4,name:三国演义,price:300

        //id:1,name:红楼梦,price:300
        //id:2,name:水浒传,price:300
        //id:3,name:西游记,price:400
        //id:4,name:三国演义,price:300

    }
}

三、环形链表解决约瑟夫问题：

1.问题描述

约瑟夫问题（约瑟夫环）

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

2.使用构建单向链表实现

BoyNode:

package com.learn.linklist.josephus;

/**
 * 用于 构建单项环形链表
 */
public class BoyNode {

    private int  no;

    private BoyNode next;

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

    public int getNo() {
        return no;
    }

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

    public BoyNode getNext() {
        return next;
    }

    public void setNext(BoyNode next) {
        this.next = next;
    }
}

CircleSingleLinkedList:

package com.learn.linklist.josephus;

import java.util.ArrayList;

/**
 * 单向环形 链表
 *
 * 设编号为1,2…，n的n个人围坐一圈，约定编号为k(1<=k<=n)的人从1开始报数，数到m的那个人出列，它的下一位又从1开始报数，数到m的那个人出列，
 * 它的下一位又从1开始报数，数到m的那个人又出列，依次类推，直到所有人出列为止，由此产生一个出队编号的序列。
 */
public class CircleSingleLinkedList {

    //外部的旁观节点，指向第一个节点。
    BoyNode head = new BoyNode(-1);

    public CircleSingleLinkedList(int n){
        if(n<1){
            System.out.println("不能");
        }
        BoyNode temp = head;
        for (int i = 1; i <= n; i++) {
            BoyNode boyNode = new BoyNode(i);
            temp.setNext(boyNode);
            temp = temp.getNext();
        }
        temp.setNext(head.getNext());
    }

    /**
     * list
     */
    public void showBoy(){
        if (head == null){
            System.out.println("链表为空");
            return;
        }

        BoyNode first = head.getNext();
        BoyNode temp = head.getNext();
        while (true){
            System.out.printf("no:%d \n",temp.getNo());
            temp = temp.getNext();
            if (temp == first ){

                break;
            }
        }

    }

    //约瑟夫问题：设编号为1,2…，n的n个人围坐一圈，约定编号为k(1<=k<=n)的人从1开始报数，数到m的那个人出列，它的下一位又从1开始报数，数到m的那个人出列，
    //          它的下一位又从1开始报数，数到m的那个人又出列，依次类推，直到所有人出列为止，由此产生一个出队编号的序列。
    public static ArrayList josephusCount(int n, int k, int m){
        ArrayList<Integer> result = new ArrayList<>();

        //创建一个环形队列
        CircleSingleLinkedList circleSingleLinkedList = new CircleSingleLinkedList(n);

        //初始化计数
        int count = 0;

        //单向链表 删除，最好使用两个指针，因为需要操作三个节点。 前一个、当前节点、后一个节点
        BoyNode temp = circleSingleLinkedList.head.getNext();
        BoyNode tempBefore = temp;
        while (true){
            if (tempBefore.getNext() == temp){
                break;
            }
            tempBefore = tempBefore.getNext();
        }

        //找到第k个人，开始计数 即移动 k-1次
        for (int i = 0; i < k-1; i++) {
            temp = temp.getNext();
            tempBefore = tempBefore.getNext();
        }

        //模拟出列
        while (true){
            //当temp 和 tempBefore 指向同一节点，则说明 当前环形队列仅剩一个节点 直接出列结束
            if (temp == tempBefore){
                result.add(temp.getNo());
                break;
            }
            //开始数数
            count++;
            //判断 是否到达 m
            if (count == m){
                //出列
                result.add(temp.getNo());
                //删除该节点。
                tempBefore.setNext(temp.getNext());
                temp = tempBefore.getNext();

                //计数归0，从0开始数数
                count = 0;

                continue;
            }else {
                temp = temp.getNext();
                tempBefore = tempBefore.getNext();
            }
        }

        return result;
    }

}

3.使用LinkedList 实现 并测试：

package com.learn.linklist.josephus;

import java.util.ArrayList;
import java.util.LinkedList;

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

        ArrayList arrayList = CircleSingleLinkedList.josephusCount(5, 2, 3);
        System.out.println(arrayList);
        //结果：
        //no:1
        //no:2
        //no:3
        //no:4
        //no:5
        //[4, 2, 1, 3, 5]

        ArrayList arrayList2 = josephusLinkedList(5, 2, 3);
        System.out.println(arrayList2);
        //[4, 2, 1, 3, 5]
    }

    //直接使用 LinkedList 实现。
    private static ArrayList josephusLinkedList(int n, int k, int m) {
        ArrayList<Integer> result = new ArrayList();

        LinkedList<Integer> linkedList = new LinkedList<>();
        //向集合中加入n个元素：
        for (int i = 1; i <= n ; i++) {
            linkedList.add(i);
        }
        //操作下标出列。
        int count = 0;
        int index = k-1;// 第k个人，下标为k-1

        //直接找到 数m的那个人；
        while (true){
            //剩最后一个人结束
            if (linkedList.size() == 1){
                break;
            }
            //直接找到下个出列人 下标。
            index = (index + m-1)%linkedList.size();

            Integer no = linkedList.get(index);
            result.add(no);
            linkedList.remove(index);
            //重新定义现在的 index（可能为最后一个元素，删完就变成 从第一个开始了）
            index = index% linkedList.size();
        }
        Integer no = linkedList.get(0);
        result.add(no);

        return  result;
    }
}
95年的巨蟹
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
linked-list:简约链表
05-02
链表 小双。 安装 该软件包仅适用于ESM：需要使用Node 12+才能使用它，并且必须将其import而不是require d。 ： npm install linked-list 用 import { List , Item } from 'linked-list' var item1 = new Item ( ...
Java链表（Linked List）基本原理与实现方法入门示例
08-19
主要介绍了Java链表（Linked List）基本原理与实现方法,结合实例形式分析了Java链表（Linked List）的功能、原理、实现方法与操作注意事项,需要的朋友可以参考下
第三章 链表（Linked List）
JavaAlenboy
01-29 221
第三章 链表（Linked List） 算法演示地址 动态数组有个明显的缺点： 可能会造成内存空间的大量浪费。 能否用到多少就申请多少内存呢？ 链表可以办到 链表是一种链式存储的线性表，所有元素的内存地址不一定是连续的 链表的设计 链表的接口设计 由于链表的大部分接口和动态数组一致，我们抽取出一个共同的 List 接口 package cn.xx.java; /** * @author xiexu * @create 2021-07-13 9:59 上午 */ public i
单向环形链表之约瑟夫问题
xiangjunyes的博客
06-09 1075
约瑟夫问题，是一个计算机科学和数学中的问题，在计算机编程的算法中，类似问题又称为约瑟夫环，又称“丢手绢问题”。约瑟夫问题是个有名的问题：N个人围成一圈，从第一个开始报数，第M个将被杀掉，最后剩下一个，其余人都将被杀掉。例如N=6，M=5，被杀掉的顺序是：5，4，6，2，3。 分析：用一个不带头结点的循环链表来处理Josephus 问题，首先构成一个有n个结点的单循环链表。由k结点起从1开始计数，记到m时，对应结点从链表删除。然后从被删除结点的下一个节点又从1开始计数，直到最后一个节点从链表中删除。 对于单链
约瑟夫(Josephus)问题的求解——利用循环链表
Catherine的笔记
05-07 8512
约瑟夫(Josephus)问题的求解——利用循环链表 1. 约瑟夫问题的提法 约瑟夫问题(约瑟夫环)是一个数学的应用问题。 已知n个人(以编号1，2，3…n分别表示)围坐在一张圆桌周围，从编号为k的人开始报数，数到m的那个人出列，他的下一个人又从1开始报数，数到m的那个人又出列，依此规律重复下去，直到圆桌周围的人全部出列。 通常解决这类问题时我们把编号从1~n，最后结果编号即为原问题的解。 2. 求解约瑟夫问题的
Josephus问题（约瑟夫问题）链表的实现
Tim_bin的专栏
06-18 1585
Josephus问题（约瑟夫问题）链表的实现Josephus问题，下面的游戏：Ｎ个人编号从１到Ｎ，围坐成一个圈．从１好开始传递一个热土豆．经过Ｍ次传递后，拿着热土豆的人被清楚离座，围坐的圈缩紧，由坐在被清除的人后面的人拿着热土豆，继续进行游戏．最后剩下的人取胜．因此，如果Ｍ＝０和Ｎ＝５，则游戏人依序被清除，５号游戏人获胜．如果Ｍ＝１和Ｎ＝５，那么被清除的人的顺序是２，４，１，５下面是通过Linked
链表的应用
m0_67371175的博客
04-05 340
Josephus及他的朋友躲到⼀个洞中，39个犹太⼈决定宁愿死也不要被⼈抓到，于是决定了⼀个⾃杀 ⽅式，41个⼈排成⼀个圆圈，由第1个⼈开始报数，每报数到第3⼈该⼈就必须⾃杀，然后再由⼀ 个重新报数，直到所有⼈都⾃杀⾝亡为⽌。然⽽Josephus 和他的朋友并不想遵从，Josephus要他的朋友先假装遵从，他将朋友与⾃⼰安排在。思路2.创建三个指针，分别定义前驱节点，当前节点，后续节点，来反转链表具体实现如下，思路1.创建一个新i链表然后头插。单链表相关经典算法OJ题4。单链表经典算法OJ题⽬。
用循环链表解决约瑟夫环问题
dongchuan5097的博客
06-11 224
约瑟夫环是一个数学的应用问题：已知n个人（以编号1，2，3...n分别表示）围坐在一张圆桌周围。从编号为k的人开始报数，数到m的那个人出列；他的下一个人又从1开始报数，数到m的那个人又出列；依此规律重复下去，直到圆桌周围的人全部出列。 下面我们用循环列表模拟这个过程： 1 //节点定义与单链表相同，在此省略 2 //use cyclical linked list to s...
【数据结构与算法】【约瑟夫问题】还在用递归？教你用链表秒杀约瑟夫
终于等到你啦~欢迎来到我的知识空间 这里是苏泽的成神之路
02-10 1717
约瑟夫问题（Josephus Problem）是一个经典的数学问题，它的形式是：n个人围成一圈，从第k个人开始报数，数到m的那个人出列，然后从下一个人开始重新报数，直到最后剩下一个人。这个问题可以用链表来解决。 我们可以使用循环链表来模拟这个过程。具体地，我们先创建一个有n个节点的循环链表，每个节点代表一个人。然后，我们从第k个人开始，遍历链表并数m个人，将第m个人删除并输出，然后从下一个人开始重新报数，直到只剩下一个人为止。
【数据结构与算法】 01 链表 （单链表、双向链表、循环链表、块状链表、头结点、链表反转与排序、约瑟夫环问题）
热门推荐
满堂花醉三千客，一剑霜寒十四州
06-07 1万+
单链表、双向链表、循环链表、块状链表、头结点、链表反转与排序、约瑟夫环问题
第二章-数据结构之链表
JavaAlenboy
10-25 407
第二章-链表 1.链表(Linked List)介绍 1.1 内存结构 链表是以节点的方式来存储的,是链式存储 每个节点包含 data 域：存放数据， next 域：指向下一个节点 链表的各个节点不一定是连续存储，比如a1的地址是150，而next指向的a2地址是110 链表分带头节点的链表和没有头节点的链表 1.2 逻辑结构 链表的逻辑结构虽然看起来像是连续的，但实际上的结构如1.1的内存结构所示，链表的存储空间是不连续的 2.链表的应用场景 使用带head头的单向链表实现 –水浒英雄排行榜管
danlianbiao.rar_Linked list_链表
09-23
利用c#语言实现对单链表的操作，包括单链表的反转、单链表的删除、单链表的插入等等。
基于python的数据结构-链表Linked list
06-25
基于python的数据结构-链表Linked list
Linked List 链表 基础
02-25
这是stanford cs library里的资料，讲得非常详细，还配有非常详尽的例子
【STM32学习】HAL库点灯学习
2301_78895982的博客
05-26 892
STM32基于HAL库流水灯实验_hel库安装教程中文版-CSDN博客t=N7T8。
operator ＜=＞ (spaceship operator)
janeqi1987的专栏
05-28 898
= 与!= 操作符为了检查是否相等，现在定义== 操作符就够了。当编译器找不到表达式的匹配声明a!=b 时，编译器会重写表达式并查找!(a==b)。若这不起作用，编译器也会尝试改变操作数的顺序，所以也会尝试!(b==a):a!=b,!(b==a)因此，对于TypeA 的a 和TypeB 的b，编译器将能够识别并编译a!= b若需要的话，可以这样做• 一个独立函数operator!• 一个独立函数operator==(TypeA, TypeB)
Spring6基础笔记
质胜文则野，文胜质则史。文质彬彬，然后君子。
05-21 1208
Spring 是一款主流的 Java EE 轻量级开源框架 ，Spring 由“Spring 之父”Rod Johnson 提出并创立，其目的是用于简化 Java 企业级应用的开发难度和开发周期。Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。Spring 框架除了自己提供功能外，还提供整合其他技术和框架的能力。Spring 自诞生以来备受青睐，一直被广大开发人员作为 Java 企业级应用程序开发的首选。时至今日，Spring 俨然
Java 异常处理中try-catch块、finally子句以及自定义异常的使用
最新发布
Itmastergo的博客
05-31 671
异常是程序运行过程中出现的非正常情况。Java 使用异常类（Exception 类及其子类）来表示这些异常情况。异常处理的核心思想是将正常的程序流程与异常处理流程分离开来，使代码更加清晰和可维护。Throwable 类：所有异常和错误的基类。Error 类：表示系统级的错误，程序通常无法处理，比如内存不足（OutOfMemoryError）。Exception 类：表示程序中可以处理的异常情况。RuntimeException 类。
用循环链表解决约瑟夫问题，并实现一个复杂的主程序python
05-31
好的，我理解了你的问题。以下是用循环链表解决约瑟夫问题的Python代码： ```python class Node: def __init__(self, data): self.data = data self.next = None class CircularLinkedList: def __init__(self): self.head = None def add_node(self, data): new_node = Node(data) if self.head is None: self.head = new_node self.head.next = self.head else: current = self.head while current.next != self.head: current = current.next current.next = new_node new_node.next = self.head def remove_node(self, node): if self.head == node: current = self.head while current.next != self.head: current = current.next current.next = self.head.next self.head = self.head.next else: current = self.head while current.next != self.head: if current.next == node: current.next = node.next break current = current.next def josephus(n, k): linked_list = CircularLinkedList() for i in range(1, n+1): linked_list.add_node(i) current = linked_list.head while current.next != current: count = 1 while count != k: current = current.next count += 1 linked_list.remove_node(current) current = current.next return current.data if __name__ == '__main__': n = 10 k = 3 survivor = josephus(n, k) print(f"The survivor is {survivor}.") ``` 在主程序中，我设置了$n=10$和$k=3$。你也可以根据需要更改这些值。运行程序后，输出将显示最后一个幸存者的编号。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值