单向环形链表实现及约瑟夫问题解决方案

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

实现类：

package demo03_LinkedList;

import java.util.Iterator;

public class CircleSingleLinkedList<T> implements Iterable<T> {
    private Node<T> first;
    private Node<T> last;
    private int size = 0;

    public CircleSingleLinkedList() {
    }

    public CircleSingleLinkedList(T elem) {
        this.first = new Node<>();
        first.temp = elem;
        first.next = first;
        last = first;
        size++;
    }

    // 添加元素
    public void add(T elem) {
        if (size == 0) {
            first = new Node<>();
            first.temp = elem;
            first.next = first;
            last = first;
            size++;
        } else {
            Node<T> node = new Node<>();
            last.next = node;
            node.temp = elem;
            node.next = first;
            last = node;
            size++;
        }
    }

    // 根据先进先出原则删除元素,并返回被删除的元素
    public T getQueue() {
        if (size == 0)
            throw new RuntimeException("空链表,无法删除元素");
        T elem = first.temp;
        if (size == 1) {
            first = last = null;
            size--;
            return elem;
        }
        first = first.next;
        last.next = first;
        size--;
        return elem;
    }

    // 根据后进先出原则删除元素,并返回被删除的元素
    public T getStack() {
        if (size == 0)
            throw new RuntimeException("空链表,无法删除元素");

        T elem = last.temp;
        Node<T> previous = getPrevious(first);
        if (previous == last) { // 只有一个结点
            last = first = null;
            size--;
            return elem;
        }
        previous.next = first;
        last.next = null;
        last = previous;
        size--;
        return elem;
    }

    // 返回当前链表last结点的前一位结点
    private Node<T> getPrevious(Node<T> node) {
        Node<T> previous = node;
        if (previous.next == last) {
            return previous;
        } else {
            previous = previous.next;
            return getPrevious(previous);
        }
    }

    // 修改链表中第一个检索到的指定元素值为想要修改成的指定值,并返回被修改的元素
    public T alterElement(T beforeElem, T afterElem) {
        Node<T> node = searchNode(beforeElem);
        T elem = node.temp;
        node.temp = afterElem;
        return elem;
    }

    // 根据指定值查找链表信息,返回检索到的第一个指定值所在的结点
    public Node<T> searchNode(T elem) {
        if (size == 0)
            throw new RuntimeException("空链表");

        Node<T> node = first;
        while (true) {
            if (elem.equals(node.temp))
                return node;
            if (node.next == first)
                break;
            node = node.next;
        }
        throw new RuntimeException("链表中不存在指定值");
    }

    // 判断是否包含指定元素
    public boolean contains(T elem) {
        if (size == 0)
            throw new RuntimeException("空链表");

        Node<T> node = first;
        while (true) {
            if (elem.equals(node.temp))
                return true;
            if (node.next == first)
                break;
            node = node.next;
        }
        return false;
    }

    // 获取链表中最先放入链表的元素
    public T getFirstElement(){
        return first.temp;
    }

    // 获取链表中最后放入链表的元素
    public T getLastElement(){
        return last.temp;
    }

    // 判空
    public boolean isEmpty() {
        return size == 0;
    }

    // 获取链表中元素数量
    public int getSize() {
        return size;
    }

    public Node<T> getFirst() {
        return first;
    }

    public void setFirst(Node<T> first) {
        this.first = first;
    }

    public Node<T> getLast() {
        return last;
    }

    public void setLast(Node<T> last) {
        this.last = last;
    }

    @Override
    public String toString() {
        StringBuilder str = new StringBuilder();
        str.append("Link = {");
        Node<T> node = first;
        while (true) {
            if (node == null)
                break;
            if (node.next == first) {
                str.append(node.temp);
                break;
            }
            str.append(node.temp + ",");
            node = node.next;
        }
        str.append("} -- size = " + size);
        return str.toString();
    }

    // 后进先出迭代器
    public Iterator<T> stackIterator() {
        return new StackIterator();
    }

    // 后进先出迭代器封装内部类
    private class StackIterator implements Iterator<T> {
        private Node<T> newFirst = first;
        private Node<T> newLast = last;
        private int n = size;
        private T elem = null;

        @Override
        public boolean hasNext() {
            return n != 0;
        }

        @Override
        public T next() {
            elem = newLast.temp;
            newLast = getStackPrevious(newFirst);
            n--;
            return elem;
        }

        public Node<T> getStackPrevious(Node<T> node){
            Node<T> previous = node;
            if (previous.next == newLast){
                return previous;
            }else {
                previous = previous.next;
                return getStackPrevious(previous);
            }
        }
    }

    // 先进先出迭代,支持增强for
    @Override
    public Iterator<T> iterator() {
        return new QueueIterator();
    }

    //先进先出迭代器内部类
    private class QueueIterator implements Iterator<T> {
        private Node<T> node = first;
        private int n = size;

        @Override
        public boolean hasNext() {
            return n != 0;
        }

        @Override
        public T next() {
            T elem = node.temp;
            node = node.next;
            n--;
            return elem;
        }
    }

    // 结点类
    private class Node<T> {
        private T temp;
        private Node<T> next;
    }
   
/**
     * 约瑟夫问题解决方案:
     * start: 表示从第几个小孩开始数(k)
     * count: 表示要数几下(m)
     */
    public static <T> void countBoy(CircleSingleLinkedList<T> link, int start, int count) {
        // 判断参数是否符合要求
        if (link.size == 0 || start < 1 || start > link.size || count <= 0) {
            System.out.println("参数输入有误,请重新输入");
            return;
        }

        // 打印参与游戏小孩信息
        System.out.println("参与做游戏的小孩及其编号为:");
        System.out.println(link.toString());

        // 将指针移动到起始报数位置
        for (int i = 1; i < start; i++) {
            link.first = link.first.next;
            link.last = link.last.next;
        }

        int cnt = 0;
        T temp = null;
        System.out.println("游戏开始:");
        while (link.size > 0) {
            if (link.first == link.last) {
                temp = link.first.temp;
                link.first = link.last = null;
                link.size--;
                cnt++;
                System.out.printf("第%d次,%s出圈了!\n", cnt, temp);
            } else {
                // 将指针移动到报数完毕的小孩位置
                for (int i = 1; i < count; i++) {
                    link.first = link.first.next;
                    link.last = link.last.next;
                }
                // 小孩出圈(从链表中移除最后报数的小孩)
                temp = link.first.temp;
                link.last.next = link.first.next;
                link.first = link.first.next;
                link.size--;
                cnt++;
                System.out.printf("第%d次,%s出圈了!\n", cnt, temp);
            }
        }
        System.out.printf("参与游戏的小孩还有%d个,游戏结束!", link.size);
    }

    /**
     * 创建单向循环链表
     * num: 链表中包含的元素个数
     * clazz: 链表中存储元素类型的类
     */
    public static CircleSingleLinkedList creatLink(int num, Class clazz) {
        CircleSingleLinkedList link = new CircleSingleLinkedList();
        for (int i = 1; i < num + 1; i++) {
            try {
                // 利用反射获取构造函数
                Constructor constructor = clazz.getConstructor(int.class);
                Object boy = constructor.newInstance(i);
                link.add(boy);
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }
        }
        return link;
    }
}

测试类：

package demo03_LinkedList;

import java.util.Iterator;

public class Test {
    public static void main(String[] args) {
        CircleSingleLinkedList<Integer> link = new CircleSingleLinkedList<>();
        try {
            for (int i = 1; i < 11; i++) {
                link.add(i);
            }
            System.out.println(link.toString());
            int length = link.getSize();
            System.out.println("按照先进先出原则删除元素:");
            for (int i = 0; i < length ; i++) {
                Integer integer = link.getQueue();
                System.out.print(integer + " ");
            }
            System.out.println();
            for (int i = 1; i < 11; i++) {
                link.add(i);
            }
            System.out.println(link.toString());
            System.out.println("按照后进先出原则删除元素:");
            for (int i = 0; i < length; i++) {
                System.out.print(link.getStack() + " ");
            }
            System.out.println();
            for (int i = 1; i < 11; i++) {
                link.add(i);
            }
            System.out.println("先进先出迭代:");
            for (Integer integer : link) {
                System.out.print(integer + " ");
            }
            System.out.println();
            System.out.println("后进先出迭代:");
            Iterator<Integer> it = link.stackIterator();
            while (it.hasNext()){
                System.out.print(it.next() + " ");
            }
        } catch (RuntimeException e) {
            e.printStackTrace();
        }finally {

        }
    }
}

测试结果：

Link = {1,2,3,4,5,6,7,8,9,10} -- size = 10
按照先进先出原则删除元素:
1 2 3 4 5 6 7 8 9 10 
Link = {1,2,3,4,5,6,7,8,9,10} -- size = 10
按照后进先出原则删除元素:
10 9 8 7 6 5 4 3 2 1 
先进先出迭代:
1 2 3 4 5 6 7 8 9 10 
后进先出迭代:
10 9 8 7 6 5 4 3 2 1

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


/**
 * 约瑟夫问题解决方案:
 * start: 表示从第几个小孩开始数(k)
 * count: 表示要数几下(m)
 */
public static <T> void countBoy(CircleSingleLinkedList<T> link, int start, int count) {
    // 判断参数是否符合要求
    if (link.size == 0 || start < 1 || start > link.size || count <= 0) {
        System.out.println("参数输入有误,请重新输入");
        return;
    }

    // 打印参与游戏小孩信息
    System.out.println("参与做游戏的小孩及其编号为:");
    System.out.println(link.toString());

    // 将指针移动到起始报数位置
    for (int i = 1; i < start; i++) {
        link.first = link.first.next;
        link.last = link.last.next;
    }

    int cnt = 0;
    T temp = null;
    System.out.println("游戏开始:");
    while (link.size > 0) {
        if (link.first == link.last) {
            temp = link.first.temp;
            link.first = link.last = null;
            link.size--;
            cnt++;
            System.out.printf("第%d次,%s出圈了!\n", cnt, temp);
        } else {
            // 将指针移动到报数完毕的小孩位置
            for (int i = 1; i < count; i++) {
                link.first = link.first.next;
                link.last = link.last.next;
            }
            // 小孩出圈(从链表中移除最后报数的小孩)
            temp = link.first.temp;
            link.last.next = link.first.next;
            link.first = link.first.next;
            link.size--;
            cnt++;
            System.out.printf("第%d次,%s出圈了!\n", cnt, temp);
        }
    }
    System.out.printf("参与游戏的小孩还有%d个,游戏结束!", link.size);
}

/**
 * 创建单向循环链表
 * num: 链表中包含的元素个数
 * clazz: 链表中存储元素类型的类
 */
public static CircleSingleLinkedList creatLink(int num, Class clazz) {
    CircleSingleLinkedList link = new CircleSingleLinkedList();
    for (int i = 1; i < num + 1; i++) {
        try {
            // 利用反射获取构造函数
            Constructor constructor = clazz.getConstructor(int.class);
            Object boy = constructor.newInstance(i);
            link.add(boy);
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }
    return link;
}

测试：

package demo03_LinkedList;

import java.util.Scanner;

public class JosephTest {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入参与游戏的小孩数量:");
        int num = sc.nextInt();
        CircleSingleLinkedList link = CircleSingleLinkedList.creatLink(num, Boy.class);
        System.out.println("请输入起始报数小孩编号:");
        int start = sc.nextInt();
        System.out.println("请输入报数次数:");
        int count = sc.nextInt();
        CircleSingleLinkedList.countBoy(link, start, count);
    }


}

class Boy {
    private int num;

    public Boy() {
    }

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

    @Override
    public String toString() {
        return "Boy" + num;
    }
}

测试结果：

请输入参与游戏的小孩数量:
5
请输入起始报数小孩编号:
1
请输入报数次数:
2
参与做游戏的小孩及其编号为:
Link = {Boy1,Boy2,Boy3,Boy4,Boy5} -- size = 5
游戏开始:
第1次,Boy2出圈了!
第2次,Boy4出圈了!
第3次,Boy1出圈了!
第4次,Boy5出圈了!
第5次,Boy3出圈了!
参与游戏的小孩还有0个,游戏结束!
是筱鱼呀
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
单向循环链表解决约瑟夫问题
buhuixiea的博客
10-21 105
在学习单链表后，尝试使用单向循环链表解决约瑟夫问题，本文以从1开头报数到4淘汰为例编写
循环单链表解决约瑟夫环问题
eexiaobai的博客
10-12 1272
约瑟夫环问题的解决： ##数据结构课的作业，使用了循环单链表来解决这个问题，不过在原题的基础上作了一点点变化，下面上代码！ 首先放上解决问题的代码！ import java.util.Scanner; public class Y { /** * @param args */ public static void main(String[] args) { // TODO Aut...
C#数据结构-约瑟夫问题
nameyichao的博客
10-18 1003
解决约瑟夫问题的完整思路。
C语言用循环单链表解决约瑟夫环(约瑟夫问题) Josephus problem
qq_45066152的博客
10-27 1627
C语言用循环单链表解决约瑟夫环(约瑟夫问题) Josephus problem
使用C#循环链表解决约瑟夫环的问题
weixin_30340353的博客
05-19 2382
前几日看到一个关于约瑟夫环的面试题，于是试着动手做了一下，没有采用.Net类库的LinkedList类，自己实现了一个循环链表结构，然后模拟游戏过程得出结果。具体代码如下：代码classProgram{staticvoidMain(string[]args){constintHUMAN_MAX=17;...
C#单向循环列表 解决 约瑟夫问题
清山博客
09-29 2145
背景故事：     约瑟夫问题是个有名的问题：N个人围成一圈，从第一个开始报数，第M个将被杀掉，最后剩下一个，其余人都将被杀掉。例如N=6，M=5，被杀掉的人的序号为5，4，6，2，3。最后剩下1号。类似的问题：     一堆猴子都有编号，编号是1，2，3 ...m ,这群猴子（m个）按照1-m的顺序围坐一圈，从第1开始数，每数到第N个，该猴子就要离开此圈，这样依次下来，直到圈中只剩下
循环单链表解决约瑟夫问题
Main_Int2022的博客
09-07 1482
用不带头结点的循环单链表解决约瑟夫问题
详细介绍约瑟夫环问题解析.docx
03-25
约瑟夫环问题解析 约瑟夫环问题是计算机科学和数学中一个著名的问题，它是指在一个圆圈中的人按照一定的规则依次出列的...约瑟夫环问题可以使用单向链表和循环链表来解决，通过设计合适的算法可以实现高效的解决方案。
约瑟夫环的问题完整代码
06-20
约瑟夫环问题，也称为约瑟夫环序列或约瑟夫问题，是一个经典的理论问题，源自古希腊历史学家约瑟夫斯的故事。...这种解决方案的关键在于正确地追踪报数和删除节点，以及利用循环链表的特性来模拟环形结构。
单链表C语言实现约瑟夫游戏
10-17
此程序通过构建一个单向链表来模拟约瑟夫问题中的环形结构，并实现相应的算法逻辑。 #### 约瑟夫问题背景 约瑟夫问题源自古罗马时期，描述了一群人围成一圈按特定规则报数，每报到某个固定数字的人将被淘汰，直至...
数据结构约瑟夫问题实验报告
10-01
### 数据结构约瑟夫问题实验报告知识点...通过本次实验，不仅加深了对数据结构中线性表的理解，还掌握了如何使用单向循环链表解决实际问题的方法。同时，通过编写和调试代码的过程，提高了编程技巧和解决问题的能力。
数据结构约瑟夫环问题
03-28
给定的代码使用C语言实现了约瑟夫环问题的解决方案，具体包括三个主要函数：`CreatList_L`用于创建链表，`ListDelete`用于从链表中删除指定位置的节点，而`main`函数则控制整个程序的流程。 1. **创建链表** (`...
【C语言】单向循环链表（实例详解约瑟夫问题）
m0_60511809的博客
11-27 4022
类似单链表，循环链表也是一种链式的存储结构，由单链表演化而来。 单向循环链表来源于单链表，所以单链表的基本操作基本都适合于循环链表。两者的不同点主要表现在链表的建立和链表表尾的判断。 接下来我们通过分析一个经典的问题即 “ 约瑟夫问题 ”来理解单循环链表。 “ 约瑟夫问题 ” 简单来说就是：有n个人围成一个圈，规定一个数字num，从某个人开始报数，每次从1报到这个数字num，报到num的人出列，现在要我们按顺序输出...
单向环形链表之约瑟夫问题
xiangjunyes的博客
06-09 1116
约瑟夫问题，是一个计算机科学和数学中的问题，在计算机编程的算法中，类似问题又称为约瑟夫环，又称“丢手绢问题”。约瑟夫问题是个有名的问题：N个人围成一圈，从第一个开始报数，第M个将被杀掉，最后剩下一个，其余人都将被杀掉。例如N=6，M=5，被杀掉的顺序是：5，4，6，2，3。 分析：用一个不带头结点的循环链表来处理Josephus 问题，首先构成一个有n个结点的单循环链表。由k结点起从1开始计数，记到m时，对应结点从链表删除。然后从被删除结点的下一个节点又从1开始计数，直到最后一个节点从链表中删除。 对于单链
数据结构实现一个单向环形链表(同时解决约瑟夫问题)
m0_59089055的博客
10-26 239
实现一个单向环形链表的同时，再解决一道例题，不美吗？
链表(二) -- 单向环形链表(约瑟夫环)
JeremyIverson的博客
02-12 253
1.单向环形链表应用场景 Josephu(约瑟夫、约瑟夫环) 问题 Josephu 问题为：设编号为 1，2，… n 的 n 个人围坐一圈，约定编号为 k（1<=k<=n）的人从 1 开始报数，数到 m 的那个人出列，它的下一位又从 1 开始报数，数到 m 的那个人又出列，依次类推，直到所有人出列为止，由此产生一个出队编号的序列。 单向环形链表介绍 单向链表中最后一个节点的ne...
C# 实现单向链表
什么风把您给吹来了
05-04 377
public class LinkedList<T> { private class Node { public T data; public Node next; public Node(T data, Node next) { this.data = data; this.next = next; } public Node(T .
数据结构与算法之单向环形链表
Happy_Boy_z的博客
01-05 358
单向环形链表单向环形链表josephu问题提示构建环形链表解决josephu问题特别感谢 韩顺平 老师的教导 单向环形链表 josephu问题 设编号为 1,2, …n的n个人围坐在一圈，约定编号为k(1<=k<=n)的人从1开始报数，数到m的那个人出列，它的下一位又从1开始报数，数到m的那个人又出列，依次类推，直到所有人出列为止，由此产生一个出队编号的序列 提示 用一个不带头结点的循...
【创新未发表】Matlab实现秃鹰优化算法BES-Kmean-Transformer-LSTM组合状态识别算法研究.rar
最新发布
07-29
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
约瑟夫问题Ｃ语言单向链表实现
03-29
现在我来介绍一下如何使用C语言的单向链表来实现约瑟夫问题。 首先，我们需要定义一个链表节点的结构体，包含两个成员变量：一个是保存人员编号的整型变量，另一个是指向下一个节点的指针。 ```c typedef struct ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值