约瑟夫(Joseph)问题，循环单向链表

目录

前言

一、约瑟夫问题是什么？

二、代码实现思路

三、代码实现

总结

---

---

前言

约瑟夫问题可以使用循环单向链表来解决，本参考案例使用Java语言来实现，在这之前对单向链表有些遗忘的小伙伴可以回顾一下单向链表单向链表SingleLinkedList_康凯哇咔咔的博客-CSDN博客

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、约瑟夫问题是什么？

1.设编号为 1，2，••n的n个人围坐一圈

2.规定从编号为k（1<=k<=n）的人从1开始报数，数到m 的那个人出列，它的下一位又从1开始报数，数到m 的那个人又出列，依次类推，直到所有人出列为止，由此产生一个出队编号的序列。

二、代码实现思路

1.用一个不带头结点的单向循环链表来处理 Josephu 问题，先构成一个有n个结点的单循环链表

   创建单向循环链表思路：

2.由k结点起从1开始计数，计到n时，对应结点从链表中删除(出圈)

3.再从被删除(出圈)结点的下一个结点又从1开始计数，直到最后一个结点从链表中删除算法结束。

示例如下图：

 使用helper辅助节点是因为单向链表无法实现自我删除，需要借助前一个指向删除节点前一个节点的辅助节点。

 

三、代码实现

package com.dream.linkedlist;

public class CircleSingleLinkedListDemo {
    /**
     * 环形单向链表 --- 解决 ---> Josephu（约瑟夫）问题
     *
     * Josephu：
     *      设编号为1，2，……n的口个人围坐一圈，约定编号为k（1<=k<=n）的人从1开始报数，数到
     * m 的那个人出列，它的下一位又从1开始报数，数到m 的那个人又出列，依次类推，直到所有人出列为止，由此
     * 得到一个出队编号的序列。
     *
     * 解决方案：
     *      用一个不带头结点的循环链表来处理Josephu问题：先构成一个有n个结点的单循环链表，然后由 k结点 起从1开
     * 始计数，计到m时，对应结点从链表中删除，然后再从被删除结点的下一个结点又从1开始计数，直到最后一个结点从链表中删除，算法结束
     *
     */
    public static void main(String[] args) {

        //测试
        CircleSingleLinkedList list = new CircleSingleLinkedList();

        //添加五个节点的环形链表
        list.add(5);
        //遍历
        list.printList();
        //链表一圈的长度
//        int size = list.size();
//        System.out.println(size);

        System.out.println("------------------------");

        list.countNode(1,2);//k=1,m=2


    }

    static class CircleSingleLinkedList {

        Node first;//第一个节点

        public CircleSingleLinkedList() {
        }

        /**
         * 添加形成指定节点个数的环形链表
         * @param num 节点个数
         */
        public void add(int num) {
            //验证传入数据合法性
            if(num < 1) {
                System.out.println("链表为空");
                return;
            }
            Node currentNode = null;//创建一个辅助节点记录first
            //利用for循环创建num个节点的环形链表
            for(int i = 1; i <= num; i++ ) {
                Node node = new Node(i);//创建第i个编号节点
                if(i == 1) {//如果节点编号为1，先让它自身成环
                    first = node;//初始化first，将第一个添加的节点作为first
                    first.setNext(node);//第一个节点自身成环,设置first节点的下一个节点指向自身
                    currentNode = first;//让当前的辅助变量指向第一个节点
                } else {
                    currentNode.setNext(node);//让当前辅助变量指向新节点
                    node.setNext(first);//让新节点指向第一个节点
                    currentNode = node;//更新辅助节点--记录新节点
                }
            }
        }

        /**
         * 循环链表一圈长度
         * @return 长度
         */
        public int size() {
            int size = 0;
            if(first == null) {
                System.out.println("链表为空");
                return size;
            }
            Node current = first;//辅助节点，辅助遍历
            while (true) {
                size++;
                if (current.getNext() == first) {//当前节点的下一个节点为null，说明遍历了一圈
                    break;
                }
                current = current.getNext();
            }
            return size;
        }


        /**
         *  从第k个节点开始，每次数m个节点，第m个节点出圈（退出环形链表）
         *  然后从第m+1个重复之前步骤，获取最后一个出圈的节点
         * @param start 开始节点（从第几个节点开始数）
         * @param count 每次向后计数（每次往后数几个）
         */
        public void countNode(int start,int count) {
            //验证：当前链表的长度
            int size = size();
            if(size == 0) {
                System.out.println("链表为null");
                return;
            }
            //验证：数据合法性
            if(start < 1 || start > size || count < 0) {
                System.out.println("输入数据不合法，请重新检查再输入");
                return;
            }
            //1.先找到帮助节点的位置 -- 指向first节点前一个节点
            Node helperNode = first;
            while (true) {
                if(helperNode.getNext() == first) {
                    break;
                }
                helperNode = helperNode.getNext();
            }

            //2.将当前节点和辅助节点一起移动！！！"start-1"！！！个节点（找到起始节点）
            for(int i = 0; i < start-1; i++) {
                first = first.getNext();//辅助节点后移
                helperNode = helperNode.getNext();//辅助出圈节点后移
            }

            //3.依次出圈，找到最后一个节点
            while (true) {

                if (first == helperNode) {//说明找到了最后一个出圈的节点（此时圈中只有一个节点）
                    break;
                }

                //4.数到第count个节点 -- 记录在first节点中
                for(int i = 0; i < count-1; i++) {
                    first = first.getNext();
                    helperNode = helperNode.getNext();
                }
                System.out.printf("出圈--节点编号%d\n",first.no);//数到第count的节点就出圈

                //5.将出圈的节点删除（垃圾回收器会回收出圈的节点，因为没有引用指向它了）
                first = first.getNext();//将当前节点后移一个节点
                helperNode.setNext(first);//辅助节点指向当前节点

            }
            //while循环结束后，就找到了最后一个出圈节点 currentNode == helperNode
            System.out.printf("最后一个出圈的节点为%d\n",first.no);

        }


        /**
         * 遍历环形链表
         */
        public void printList() {
            if(first == null) {
                System.out.println("链表为空");
                return;
            }
            Node current = first;//辅助节点，辅助遍历
            while (true) {
                System.out.printf("节点编号%d\n",current.getNo());
                if (current.getNext() == first) {//当前节点的下一个节点为first，说明遍历了一圈
                    break;
                }
                current = current.getNext();
            }
        }


        //环形链表节点
        class Node {

            private int no;//节点编号
            private Node next;//指向下一个节点

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

            public int getNo() {
                return no;
            }

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

            public Node getNext() {
                return next;
            }

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

示例结果如下图：

 

---

总结

以上就是今天要讲的内容，通过约瑟夫问题可以对单向链表以及循环单向链表有一些更多的理解。