单向环形链表与约瑟夫问题

最新推荐文章于 2022-10-10 20:42:16 发布

原创最新推荐文章于 2022-10-10 20:42:16 发布 · 168 阅读

1 ·

CC 4.0 BY-SA版权

数据结构与算法专栏收录该内容

19 篇文章

订阅专栏

单向环形链表（CircleSingleLinkedList）

单向环形链表，也就是单向循环链表，也就是在单链表的基础上，将尾节点的next指针指回头节点，形成一个环

Node节点实现

和单链表一样的实现，没什么好说的额

/**
 * 链表节点
 */
class Node2 {
    private int no;
    private Node2 next;

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

    public int getNo() {
        return no;
    }

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

    public Node2 getNext() {
        return next;
    }

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

单向环形链表的实现

这边只写了链表的快速初始化和遍历方法，基本增删改查和单链表也差不多

/**
 * 单向环形链表
 */
class CircleSingleLinkedList {
    //头节点，指向第一个节点
    private Node2 head = null;

    /**
     * 初始化环形链表
     *
     * @param num
     */
    public void init(int num) {
        if (num < 1) {
            System.out.print("初始化错误");
            return;
        }
        //辅助节点,指向最后的节点
        Node2 curNode = null;
        for (int i = 1; i <= num; i++) {
            //创建新节点
            Node2 node = new Node2(i);
            if (i == 1) {
                head = node;
                curNode = node;
                node.setNext(node);
            } else {
                curNode.setNext(node);
                node.setNext(head);
                curNode = node;
            }
        }
    }

    /**
     * 遍历链表
     */
    public void show() {
        if (head == null) {
            System.out.println("链表为空");
            return;
        }
        Node2 curNode = head;
        while (true) {
            System.out.println("节点" + curNode.getNo());
            if (curNode.getNext() == head) {
                break;
            }
            curNode = curNode.getNext();
        }
    }
}

约瑟夫问题

问题由来

据说著名犹太历史学家 Josephus有过以下的故事：在罗马人占领乔塔帕特后，39 个犹太人与Josephus及他的朋友躲到一个洞中，39个犹太人决定宁愿死也不要被敌人抓到，于是决定了一个自杀方式，41个人排成一个圆圈，由第1个人开始报数，每报数到第3人该人就必须自杀，然后再由下一个重新报数，直到所有人都自杀身亡为止。然而Josephus 和他的朋友并不想遵从。首先从一个人开始，越过k-2个人（因为第一个人已经被越过），并杀掉第k个人。接着，再越过k-1个人，并杀掉第k个人。这个过程沿着圆圈一直进行，直到最终只剩下一个人留下，这个人就可以继续活着。问题是，给定了和，一开始要站在什么地方才能避免被处决？Josephus要他的朋友先假装遵从，他将朋友与自己安排在第16个与第31个位置，于是逃过了这场死亡游戏。
————————————————
版权声明：本文为优快云博主「小鸡炖蘑菇_」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.youkuaiyun.com/qq_21120027/article/details/51183767

使用单向环形链表解决

假设有一个节点数量为5的单向环形链表，并使用helper辅助节点进行约瑟夫问题的推导
在这里插入图片描述

代码实现

/**
     * 约瑟夫问题
     * @param startNo 第几个开始
     * @param count 链表中的节点个数
     * @param nums 朝一个方向数到几的节点出圈
     */
    public void Joseph(int startNo, int count, int nums) {
        if (head == null || startNo < 1 || startNo > count) {
            System.out.println("参数有误,约瑟夫出圈失败");
            return;
        }
        //创建helper辅助节点，指向“ 以startNo节点为head的链表的最后一个节点 ”
        Node2 helper = head;
        while (true) {
            if (helper.getNext() == head) {
                break;
            }
            helper = helper.getNext();
        }
        //将helper和head移动到相应startNo的位置
        for (int i = 0; i < startNo - 1; i++) {
            head = head.getNext();
            helper = helper.getNext();
        }
        while (true) {
            if (helper == head) {
                System.out.println("最后出圈节点" + head.getNo());
                return;
            }
            for (int i = 0; i < nums - 1; i++) {
                head = head.getNext();
                helper = helper.getNext();
            }
            System.out.println("出圈节点" + head.getNo());
            head = head.getNext();
            helper.setNext(head);
        }
    }

测试

public static void main(String[] args) {
        //测试 - 初始化个数为5的链表
        CircleSingleLinkedList circleSingleLinkedList = new CircleSingleLinkedList();
        circleSingleLinkedList.init(5);
        circleSingleLinkedList.show();

        //测试 - 个数为5的链表进行约瑟夫出圈
        System.out.println("--------------------------");
        circleSingleLinkedList.Joseph(1, 5, 2);
    }

节点1
节点2
节点3
节点4
节点5
--------------------------
出圈节点2
出圈节点4
出圈节点1
出圈节点5
最后出圈节点3

结果符合预期

总结

以上是比较简单的约瑟夫实现，时间复杂度是O(nm)，太高了，网上有大佬的更吊的实现，可惜看不懂哈哈哈哈