数据结构与算法 19 链表 → 循环链表(约瑟夫环问题)

4.6 链表 → 循环链表(约瑟夫环问题)


循环链表,顾名思义,链表整休要形成一个圆环状。在单向链表中,最后一个节点的指针为null ,不指向任何结点,因为没有下一个元素了。要实现循环链表,我们只需要让单向链表的最后一个节点的指针指向头结点即可。

数据结构与算法 19 链表 → 循环链表(约瑟夫环问题)_第1张图片
所以说 循环链表,是一个很简单的数据结构。它只不过是把 单向链表的最后一个结点.next 连接到了 第一个节点上。

但是看似简单的循环链表 却可以解决一个 很经典的算法问题。


4.6.1 约瑟夫环问题

  • 问题描述∶

传说有这样一个故事,在罗马人占领乔塔帕特后,39个犹太人与约瑟夫及他的朋友躲到一个洞中,39个犹太人决定宁愿死也不要被敌人抓到,于是决定了一个自杀方式,41个人排成一个圆圈,第一个人从1开始报数,依次往后,如果有人报数到3,那么这个人就必须自杀,然后再由他的下一个人重新从1开始报数,直到所有人都自杀身亡为止。然而约瑟夫和他的朋友并不想遵从。于是,约瑟夫要他的朋友先假装遵从,他将朋友与自己安排在第16个与第31个位置,从而逃过了这场死亡游戏。(在此看来 约瑟夫是一个 很聪明的人

  • 问题转换︰

41个人坐一圈,第一个人编号为1,第二个人编号为2,第n个人编号为n。

  1. 编号为1的人开始从1报数,依次向后,报数为3的那个人退出圈;
  2. 自退出那个人开始的下一个人再次从1开始报数﹐以此类推;
  3. 求出最后退出的那个人的编号。
    数据结构与算法 19 链表 → 循环链表(约瑟夫环问题)_第2张图片

我们的第一个思路就是,直接利用 new 开辟 存储 node 类型 的 数据,也就是我们 必须 开辟 一个 数组用来存储 这些 结点的地址。方便我们 对 这些结点 进行 各种复杂的操作!

然后我们 通过 这些 数组里面 存储的 各个结点的地址,就可以 先将其 变为 单向链表,再将其 变为 循环链表。

然后我们再 声明一个变量 count = 0; 用来表明 当前 查数 查到了 几。每次 查数 count++ 自增一下,当 count == 3 的时候 需要 删除掉查到3 的 这个人的 结点,并且 count 重置为 0。再次 重新进行。

我们知道 这个游戏,其实是至少得 三个人 来玩的,因为 如果 最后那两个人不想死。就可以 无视游戏规则!

  • 假设这41个人 都想死,包括约瑟夫和它的朋友那么就设定一个 num = 41 每次干掉一个人 num–,while(num >0 )如果不大于0就证明全死了。游戏结束!
package com.muquanyu.algorithm.test;

public class JosephTest {
    public static void main(String[] args) {
        //构建循环链表
        Node<Integer> nodeArray[] = new Node[41];
        for(int i = 0;i<=40;++i)
        {
            nodeArray[i] = new Node<Integer>(i+1,null);
        }
        for(int i = 0;i<=39;++i)
        {
            nodeArray[i].next = nodeArray[i+1];
        }
        nodeArray[40].next = nodeArray[0];

        int count = 0;
        Node<Integer> head = nodeArray[0];
        Node<Integer> temp = head;
        int num = 41;//最后剩下的人数 如果不满足 三个人 这个游戏就无法进行下去
        // 1 2 3 4
        while(head != null && num > 0)
        {
            count++;
            if(count == 3)
            {
                count = 0;
                System.out.println(head.item + "号玩家:已出局!");
                temp.next = head.next;
                num--;
            }
            temp = head;
            head = head.next;
        }

        //最后肯定就剩两个人
       /*System.out.println(head.item + "号玩家幸存!");
        System.out.println(head.next.item + "号玩家幸存!");
*/


    }

    private static class Node<T> {
        T item;
        Node next;
        public Node(T item,Node next)
        {
            this.item = item;
            this.next = next;
        }
    }
}

数据结构与算法 19 链表 → 循环链表(约瑟夫环问题)_第3张图片
可以看到,其实 16 号 和 31 号 就是 最后那两个 出局的 编号。要不然 咋说 约瑟夫 聪明呢,如果 最后就剩两个人,人家 约瑟夫和朋友不想死。直接就可以无视规则了!

  • 真正的约瑟夫问题最后的结果
package com.muquanyu.algorithm.test;

public class JosephTest {
    public static void main(String[] args) {
        //构建循环链表
        Node<Integer> nodeArray[] = new Node[41];
        for(int i = 0;i<=40;++i)
        {
            nodeArray[i] = new Node<Integer>(i+1,null);
        }
        for(int i = 0;i<=39;++i)
        {
            nodeArray[i].next = nodeArray[i+1];
        }
        nodeArray[40].next = nodeArray[0];

        int count = 0;
        Node<Integer> head = nodeArray[0];
        Node<Integer> temp = head;
        int num = 41;//最后剩下的人数 如果不满足 三个人 这个游戏就无法进行下去
        // 1 2 3 4
        while(head != null && num >= 3)
        {
            count++;
            if(count == 3)
            {
                count = 0;
                System.out.println(head.item + "号玩家:已出局!");
                temp.next = head.next;
                num--;
            }
            temp = head;
            head = head.next;
        }

        //最后肯定就剩两个人
        System.out.println(head.item + "号玩家(约瑟夫)幸存!");
        System.out.println(head.next.item + "号玩家(约瑟夫的朋友)幸存!");



    }

    private static class Node<T> {
        T item;
        Node next;
        public Node(T item,Node next)
        {
            this.item = item;
            this.next = next;
        }
    }
}

数据结构与算法 19 链表 → 循环链表(约瑟夫环问题)_第4张图片

你可能感兴趣的:(学习笔记,链表,算法,数据结构,约瑟夫环问题)