n个人围成一圈，从第一个人开始报数,数到m的人出列，再由下一个人重新从1开始报数，数到m的人再出圈，依次类推，直到所有的人都出圈，请输出依次出圈人的编号。

这是经典的约瑟夫问题，可以使用循环链表来模拟这个过程，具体实现如下：

def josephus(n, m):
    # 创建循环链表
    circle = [i+1 for i in range(n)]
    curr = 0  # 当前报数的人的索引
    for i in range(n):
        curr = (curr + m - 1) % len(circle)  # 计算出列的人的索引
        yield circle.pop(curr)  # 将出列的人从链表中删除并返回

使用示例：

for i in josephus(7, 3):
    print(i, end=' ')
# 输出：3 6 2 7 5 1 4

在这个示例中，7个人围成一圈，从第一个人开始报数，每次数到第3个人出列，直到所有人都出列，最终输出依次出列的人的编号。

相关问题

n 个人围成一圈，从第一个人开始报数,数到 m 的人出列，再由下一个人重新从 1开始报数，数到 m的人再出圈，依次类推，直到所有的人都出圈，请输出依次出圈人的编号。 备注：1≤m,n≤100

题意：有n个人围成一圈，从第一个人开始报数，报到m的人出列，然后由下一个人从1开始报数，报到m的人出列，以此类推，直到所有的人都出列。请输出依次出列的人的编号。

答案: 根据题意，可以使用循环链表来模拟这个过程。首先将所有人的编号放入循环链表中，在循环链表的基础上模拟出圈的过程。具体实现过程可以借鉴数据结构中的约瑟夫问题。

以下是一个Python的代码示例：

n, m = 10, 3

class Node(object):
def __init__(self, data=None):
self.data = data
self.next = None

head = Node()
cur = head
for i in range(1, n+1):
new_node = Node(i)
cur.next = new_node
cur = new_node
cur.next = head.next

cur = head.next
while cur.next != cur:
for i in range(1, m-1):
cur = cur.next
print(cur.next.data, end=' ')
cur.next = cur.next.next
cur = cur.next
print(cur.data) # 最后一个出列的人的编号

n个人围成一圈，从第一个人开始报数,数到 � m的人出列，再由下一个人重新从 1 1开始报数，数到 � m的人再出圈，依次类推，直到所有的人都出圈，请输出依次出圈人的编号。

这是经典的约瑟夫问题，可以用循环链表来解决。

具体步骤如下：

1. 首先创建一个循环链表，节点表示每个人，节点编号为1~n。

2. 从第一个节点开始，依次报数，每报到第m个人，就将该节点从链表中删除。

3. 然后从被删除节点的下一个节点重新开始报数，重复第二步，直到所有节点都被删除。

4. 每次删除一个节点，就将该节点的编号输出，即为依次出圈的人的编号。

代码实现如下：

class Node:
    def __init__(self, value):
        self.value = value
        self.next = None

def josephus(n, m):
    # 创建循环链表
    head = Node(1)
    cur = head
    for i in range(2, n+1):
        cur.next = Node(i)
        cur = cur.next
    cur.next = head  # 将尾节点指向头节点，形成循环链表

    # 开始报数并出圈
    cur = head
    while n > 0:
        for i in range(m-1):
            cur = cur.next
        print(cur.next.value)  # 输出出圈人的编号
        cur.next = cur.next.next  # 将出圈人的节点从链表中删除
        n -= 1

josephus(7, 3)  # 输出：3 6 2 7 5 1 4

以上代码中，josephus函数的参数n表示总人数，m表示报数的间隔。执行josephus(7, 3)后，程序会输出依次出圈人的编号。