java 环形单链表实现及约瑟夫问题求解

已于 2022-04-15 17:31:59 修改
阅读量560 收藏 1
点赞数
分类专栏： 2022--magic 文章标签： java 数据结构
于 2022-04-15 17:28:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ducklikejava/article/details/124198686
版权

环形链表 约瑟夫问题 链表操作 递归 数据结构
关键词由CSDN通过智能技术生成

环形单链表其实跟普通单链表相识，只是最后一个元素会指向第一个元素；而普通的单链表最后的一个元素只是指向 null.

不过在实现的时候需要注意一下这个环形链表的遍历的退出条件，以及在插入与删除元素的时候，怎么去操作其中的节点。（与普通单链表会存在细微差别。）

然后，简单介绍一下约瑟夫问题：

问题描述
约瑟夫环问题（Joseph）又称丢手绢问题：已知 m 个人围坐成一圈，由某人起头，下一个人开始从 1 递增报数，报到数字 n 的那个人出列，他的下一个人又从 1 开始报数，数到 n 的那个人又出列；依此规律重复下去，直到 m 个人全部出列约瑟夫环结束。如果从 0 ~ (m-1) 给这 m 个人编号，请输出这 m 个人的出列顺序。
————————————————
版权声明：本文为CSDN博主「李春春_」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/zhongkelee/article/details/40594147

这个问题描述看起来清楚明了。直接在纸上画能很容易的求解。但是如果 n，很大的话，就不好弄了。所以，需要一个通用的解决方案。

刚好环形链表可以解决这个问题。把这 n个人当成一个环形链表，然后就是根据 k, m 找到对应的位置，去删除对应的元素，依次反复，直到最后一个元素被删除。

这里直接给出实现：

为了便于 插入与删除。定义 head 和 tail, 固定指向链表的头结点和尾结点。


import java.util.Arrays;
import java.util.StringJoiner;

/**
 * 环形单链表的实现.
 */
class AroundList<Z> {

    private static class Node<K> {
        K data;
        Node<K> next;
    }

    private final Node<Z> head = new Node<>();
    private final Node<Z> tail = new Node<>();

    private int length = 0;

    public AroundList() {
        head.data = null;
        head.next = null;
    }

    public int size() {
        return length;
    }

    public boolean isEmpty() {
        return length == 0;
    }

    public boolean add(Z data) {
        return insert(0, data);
    }

    public boolean addLast(Z data) {
        return insert(length, data);
    }

    public boolean replace(int index, Z data) {
        if (index < 0 || index >= length) {
            return false;
        }
        int pos = -1;
        Node<Z> h = head;
        do {
            if (index - 1 == pos) {
                break;
            }
            pos++;
            h = h.next;
        } while (h.next != head.next);

        h.next.data = data;
        return true;
    }

    // a [k] b c d
    public boolean insert(int index, Z data) {
        if (index < 0 || index > length) {
            return false;
        }
        if (length == 0) {
            Node<Z> young = new Node<>();
            young.data = data;
            young.next = young;
            head.next = young;
            tail.next = young;
        } else {
            int pos = -1;
            Node<Z> h = head;
            do {
                if (index - 1 == pos) {
                    break;
                }
                pos++;
                h = h.next;
            } while (h.next != head.next);

            if (pos == length) {
                return false;
            }
            Node<Z> old = h.next;
            Node<Z> young = new Node<>();
            young.data = data;
            young.next = old;
            h.next = young;
            if (pos == -1) {
                // let tail.next == young
                tail.next.next = young;
            } else if (pos == length - 1) {
                tail.next = young;
            }
        }
        length++;

        return true;
    }

    public int indexOf(Z data) {
        int pos = -1;
        if (data == null) {
            return pos;
        }
        Node<Z> h = head;
        boolean found = false;
        do {
            pos++;
            h = h.next;
            if (data.equals(h.data)) {
                found = true;
                break;
            }
        } while (h.next != head.next);
        return found ? pos : -1;
    }

    public Z get(int index) {
        if (index < 0 || index >= length) {
            return null;
        }
        int pos = -1;
        Node<Z> h = head;
        do {
            if (index - 1 == pos) {
                break;
            }
            pos++;
            h = h.next;
        } while (h.next != head.next);
        return h.next.data;
    }

    public boolean remove(Z data) {
        return remove(indexOf(data));
    }

    public boolean removeLast() {
        return remove(length - 1);
    }

    public boolean removeFirst() {
        return remove(0);
    }

    public boolean remove(int index) {
        if (index < 0 || index >= length) {
            return false;
        }
        int pos = -1;
        Node<Z> h = head;
        do {
            if (index - 1 == pos) {
                break;
            }
            pos++;
            h = h.next;
        } while (h.next != head.next);

        if (pos == length) {
            return false;
        }
        // now h' pos == index-1
        Node<Z> target = h.next;
        h.next.data = null; // remove target
        h.next = target.next;
        if (pos == -1) {
            // remove the first ele
            tail.next.next = h.next;
        } else if (pos == length - 2) {
            // remove the last ele
            tail.next = h;
        }
        length--;
        return true;
    }

    public boolean clear() {
        while (length > 0) {
            removeFirst();
        }
        return true;
    }

    public void listReverse() {
        // _ 3 8 9 7 6
        // + 8 3
        if (length <= 1) {
            return;
        }
        Node<Z> rh = new Node<>();

        Node<Z> next;
        Node<Z> tt = null;
        Node<Z> h = head.next;
        do {
            next = h.next;
            h.next = rh.next;
            rh.next = h;
            if (tt == null) {
                tt = h;
            }
            h = next;
        } while (h != head.next);
        tail.next = tt;
        tail.next.next = rh.next;
        head.next = rh.next;
    }

    /**
     * @param order 0== no sort; 1== 3,2,1 , -1 == 1,2,3.
     */
    public <T extends Comparable<T>> AroundList<T> merge(AroundList<T> another, int order) {
        AroundList<T> list = new AroundList<>();
        if (0 == order) {
            for (int i = 0; i < size(); ++i) {
                list.addLast((T) get(i));
            }
            if (another != null) {
                for (int i = 0; i < another.size(); ++i) {
                    list.addLast(another.get(i));
                }
            }
        } else {
            for (int i = 0; i < size(); ++i) {
//                list.addLast((T) get(i));
                T data = (T) get(i);
                int j;
                for (j = 0; j < list.size(); ++j) {
                    T z = list.get(j);
                    if (order < 0
                            ? z.compareTo(data) > 0 :
                            z.compareTo(data) < 0) {
                        break;
                    }
                }
                list.insert(j, data);
            }
            if (another != null) {
                for (int i = 0; i < another.size(); ++i) {
                    T data = another.get(i);
                    int j;
                    for (j = 0; j < list.size(); ++j) {
                        T z = list.get(j);
                        if (order < 0
                                ? z.compareTo(data) > 0 :
                                z.compareTo(data) < 0) {
                            break;
                        }
                    }
                    list.insert(j, data);
                }
            }
        }
        return list;
    }

    public String format() {
        int pos = -1;
        StringBuilder sb = new StringBuilder(getClass().getSimpleName() + ": {");
        if (length > 0) {
            Node<Z> h = head;
            do {
                h = h.next;
                pos++;
                sb.append("[").append(pos).append("]=").append(h.data).append(", ");
            } while (h.next != head.next);
        }
        int last = sb.lastIndexOf(", ");
        if (last != -1) {
            sb.delete(last, last + 2);
        }
        sb.append("} | size=").append(length).append(" ##|");
        return sb.toString();
    }

    @Override
    public String toString() {
        return new StringJoiner(", ",
                AroundList.class.getSimpleName() + "[", "]")
                .add(format()).toString();
    }

    public static void main(String[] args) {
        joseph(5, 1, 2);
        System.out.println("@@@@");
        joseph(5, 3, 2);
//        if (1 == 1) return;
        AroundList<Integer> list = new AroundList<>();
        System.out.println(list);
        list.add(1);
        System.out.println(list);
        list.removeFirst();
        System.out.println("--rr-" + list);
//        if (1 == 1) return;
        list.add(2);
        list.add(3);

        System.out.println("#######" + list);
        list.listReverse();
        System.out.println("r-r-r-r? " + list);
        list.addLast(4);
        list.addLast(5);
        list.addLast(6);
        list.add(-1);
        System.out.println("add... " + list);
        list.insert(3, 44);
        System.out.println("is: " + list);
        list.remove(list.size() - 1);
        System.out.println("rs-1?" + list);
        list.clear();
        System.out.println("clear---------" + list);
        list.add(12);
        System.out.println("----??? " + list);
        list.add(13);
        list.addLast(14);
        System.out.println(list);
        list.remove(0);
        System.out.println("r0? " + list);
        list.remove(1);
        System.out.println("r1? " + list);
        list.replace(0, -11);
        list.replace(1, -22);
        System.out.println("rp? " + list);
        for (int i = 0; i < list.size(); ++i) {
            Integer value = list.get(i);
            System.out.println(" get=-- [" + i + "] = " + value);
            System.out.println("index of " + list.indexOf(value));
        }
        System.out.println(list.indexOf(Integer.MIN_VALUE));
        System.out.println(list.indexOf(Integer.MAX_VALUE));

        joseph(6, 2, 4);
    }

    private static void joseph(int count, int start, int times) {
        if (start > count || times > count
                || count <= 0 || start <= 0 || times <= 0) {
            return;
        }
        // 5, 1, 2
        AroundList<Integer> list = new AroundList<>();
        for (int i = 0; i < count; ++i) {
            list.addLast(i + 1);
        }
        int[] results = new int[count];
        int offset = -99;
        for (int i = 0; i < count; ++i) {
            int size = list.size();
            int begin = i == 0 ? start - 1 : offset;
            offset = (begin + times - 1) % size;
            Integer value = list.get(offset);
            boolean rm = list.remove(offset);
            // System.out.printf("b=%d,offset=[%d], value=%d, rm=%s\n", begin, offset, value, rm);
            results[i] = value;
        }
        System.out.println("results: " + Arrays.toString(results));
        System.out.println("list--" + list);
    }
}

这里需要关注 insert(index, data) 及 remove(index, data) 的逻辑。环形链表的问题在于，最后一个元素始终会指向第一个元素，所以在 插入到链表头，及插入到链表尾；删除头元素，删除尾元素 的时候需要特别注意。

然后是约瑟夫问题的解决：

    private static void joseph(int count, int start, int times) {
        if (start > count || times > count
                || count <= 0 || start <= 0 || times <= 0) {
            return;
        }
        // 5, 1, 2
        AroundList<Integer> list = new AroundList<>();
        for (int i = 0; i < count; ++i) {
            list.addLast(i + 1);
        }
        int[] results = new int[count];
        int offset = -99;
        for (int i = 0; i < count; ++i) {
            int size = list.size();
            int begin = i == 0 ? start - 1 : offset;
            offset = (begin + times - 1) % size;
            Integer value = list.get(offset);
            boolean rm = list.remove(offset);
            // System.out.printf("b=%d,offset=[%d], value=%d, rm=%s\n", begin, offset, value, rm);
            results[i] = value;
        }
        System.out.println("results: " + Arrays.toString(results));
        System.out.println("list--" + list);
    }

在已经实现了环形链表的前提下，约瑟夫问题就变成了找到要删除的元素的位置，然后删除该元素。 不过要注意，找这个元素的逻辑。就是怎么去计算对应的索引值的偏移量。

看一下输出结果：

results: [2, 4, 1, 5, 3]
list--AroundList[AroundList: {} | size=0 ##|]
@@@@
results: [1, 5, 2, 4, 3]
...

可以看到，如果是5个人，从第1个开始数数，每数2个，就踢出；那么输出的顺序是2, 4, 1, 5, 3; 如果是5个人，从第3个开始数数，每数4个，就踢出；那么输出的顺序是1, 5, 2, 4, 3。

数的时候要包含当前的位置，自己也要被数一下。

南郭竽
关注
专栏目录
Java数据结构之单向环形链表（解决Josephu约瑟夫环问题）
猫不夜行的博客
07-24 302
1.Josephu（约瑟夫、约瑟夫环）问题： 设编号为1，2，… n的n个人围坐一圈，约定编号为k（1<=k<=n）的人从1开始报数，数到m 的那个人出列，它的下一位又从1开始报数，数到m的那个人又出列，依次类推，直到所有人出列为止，由此产生一个出队编号的序列。 提示： 用一个不带头结点的循环链表来处理Josephu 问题：先构成一个有n个结点的单循环链表，然后由k结点起从1开...
单向循环链表与约瑟夫问题求解
qq_41784749的博客
01-23 220
单向环形链表 将单链表中中断结点的指针端有空指针改为指向头结点，就使整个单链表形成一个环，这种头尾详解的单链表称为单循环链表，简称循环链表； 示意图： 注意： 　　①循环链表中没有NULL指针。涉及遍历操作时，其终止条件就不再是像非循环链表那样判别p或p->next是否为空，而是判别它们是否等于某一指定指针，如头指针或尾指针等。 　　②在单链表中，从一已知结点出发，只能访问到该结点及其后续结点，无法找到该结点之前的其它结点。而在单循环链表中，从任一结点出发都可访问到表中所有结点，这一优点使某些运算
Java实现单向环形链表
m0_52598063的博客
01-28 319
单向环形链表介绍 单向环形链表就是在单向链表（没有头节点）的基础上，让链表的最后一个节点的next指向该链表的第一个节点。如下图所示 用单向环形链表解决约瑟夫问题 1）1.约瑟夫问题 设编号为1，2，···n的n个人围坐一圈，约定编号为k（1<=k<=n）的人从1开始报数，数到m的那个人出列，它的下一位又从1开始报数，数到m的那个人又出列，依此类推，直到所有人出列为止，由此产生一个出队编号的序列。 2.提示 先构成一个有n个节点的环形链表，然后由k节点起从1开始计数，计到m时，对应的节点从链表
Java单向循环链表&解决约瑟夫环问题
ILFFQ的博客
07-20 282
Java单向循环链表以及约瑟夫环的Java链表解决
Leetcode(Java)-142. 环形链表 II
Slayer_Zhao的博客
02-10 195
给定一个链表，返回链表开始入环的第一个节点。如果链表无环，则返回null。 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。 说明：不允许修改给定的链表。 示例 1： 输入：head = [3,2,0,-4], pos = 1 输出：tail connects to node inde...
11、leetcode环形链表、最后一个单词的长度
KJ_Study的博客
09-22 226
141. 环形链表 给定一个链表，判断链表中是否有环。 如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。 如果链表中存在环，则返回 true 。 否则，返回 false 。 进阶： 你能用 O(1)（即，常量）内存解决此问题吗？ 示例 1： 输入：head = [3
Java采用循环链表结构求解约瑟夫问题
09-04
在Java中，我们可以使用循环链表数据结构来解决约瑟夫问题。循环链表是一种特殊的链表，它的最后一个节点的next指针指向链表的第一个节点，形成一个闭合的环状结构。下面详细讲解如何实现这个解决方案。 首先，我们...
java 环形链表的示例
孤舟残月梦还长存的专栏
10-15 669
环形链表是解决像约瑟夫环问题的类似问题的求解。
数据结构与算法 -- -- -- 队列 与 链表（约瑟夫问题）
qq_58293159的博客
03-19 508
队列 与链表的介绍 实现 与 思路分析 + 代码 【单链表 ，双链表 ，环形链表】的介绍
java中级开发工程师面试题，Javaweb面试问题
2401_84413420的博客
04-23 974
由于篇幅限制，小编在此截出几张知识讲解的图解《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！954)]由于篇幅限制，小编在此截出几张知识讲解的图解[外链图片转存中…(img-cKlVenTD-1713823556956)][外链图片转存中…(img-pKNR42U7-1713823556957)][外链图片转存中…(img-uwFZOR7x-1713823556958)]
Java实现环形链表
m0_57099067的博客
05-06 993
实现基本的增删改查以及约瑟夫问题 package 链表; public class CircleSingleLinkedListDemo { public static void main(String[] args) { CircleSingleLinkedList circleSingleLinkedList = new CircleSingleLinkedList(); circleSingleLinkedList.show(); Syst
环形链表（Java代码实现）
qq_45626507的博客
02-09 600
Java代码实现环形链表（约瑟夫问题）
数据结构和算法(四)Java实现环形链表
yuan_xw的专栏
02-17 756
1. 数据结构和算法(四)Java实现环形链表 1.1 约瑟夫问题 约瑟夫问题：公元66年，约瑟夫不情愿地参与领导了犹太同胞反抗罗马统治的起义，后来起义失败，他和一些宁死不降的起义者被困于一个山洞之中。罗马将军韦斯巴芗(Vespasian)派人来劝降，他主张投降，其余的人不答应，并以死相逼。最后，约瑟夫提议，与其死在自己的手上，不如死在彼此的手上。因此他便将游戏规则告知众人：N个人围成一圈，从第一...
JAVA实现环形链表（详解）
weixin_46726346的博客
09-22 3270
关于单链表和双向链表，在之前的LinkedList源码里我已经写过一次了。。。所以这次关于链表的分析就只剩环形链表了 而这一篇，主要是讲解原理以及代码实现，不涉及到解决问题。 所以接下来的重点主要在于如何用代码来实现出一个环形链表。 所谓环形链表也就是在单链表的基础上，让最后一个节点的next指向第一个节点，所以说这次我们就不能设置头节点了（不然最后一个节点会指向一个没用的节点）。。 那我们就开始写第一步，也就是最开始的一步，创建一个节点类。 public class Node { private
java环形链表_数据结构和算法(四)Java实现环形链表
weixin_39822923的博客
02-19 341
1. 数据结构和算法(四)Java实现环形链表1.1 约瑟夫问题约瑟夫问题：公元66年，约瑟夫不情愿地参与领导了犹太同胞反抗罗马统治的起义，后来起义失败，他和一些宁死不降的起义者被困于一个山洞之中。罗马将军韦斯巴芗(Vespasian)派人来劝降，他主张投降，其余的人不答应，并以死相逼。最后，约瑟夫提议，与其死在自己的手上，不如死在彼此的手上。因此他便将游戏规则告知众人：N个人围成一圈，从第一个人...
环形链表——java
最新发布
gnsbxjj的博客
04-26 381
假想「乌龟」和「兔子」在链表上移动，「兔子」跑得快，「乌龟」跑得慢。当「乌龟」和「兔子」从链表上的同一个节点开始移动时，如果该链表中没有环，那么「兔子」将一直处于「乌龟」的前方；如果该链表中有环，那么「兔子」会先于「乌龟」进入环，并且一直在环内移动。等到「乌龟」进入环时，由于「兔子」的速度快，它一定会在某个时刻与乌龟相遇，即套了「乌龟」若干圈。
java环形链表
Nabandon的博客
01-27 395
给定一个链表，判断链表中是否有环。 public boolean hasCycle(ListNode head){ if(head==null||head.next==null){ return false; } ListNode slow=head; ListNode fast=head.next; ...
JAVA实现环形链表#JAVA指针和变量
2201_75609857的博客
03-15 449
指针 #Java #变量 #idea #链表 #约瑟夫问题如果事先已经了解过Java指针可以直接调到标题二如果对链表不是很了解的话可以看我上一篇文章。
JAVA——环形链表
SwitchD的博客
02-07 1189
问题1：给你一个链表的头节点 head ，判断链表中是否有环。如果链表中存在环 ，则返回 true 或者false 。 方法：首先判断链表是否为空，以及是否只有一个结点。接下来利用快慢指针，slow走一步，fast走两步，在fast不为null以及.next不为空的情况下，若能找到fast=slow的相遇点则链表中有环。 代码： public boolean hasCycle(ListNode head) { if(head==null){ return fals
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值