【数据结构】解密约瑟夫环问题：如何找到最后幸存的人？

概述：

约瑟夫环问题是一个经典的数学问题，涉及到一个古老的故事。根据传说，该问题源自于公元1世纪时罗马历史学家约瑟夫斯（Josephus）为了避免被罗马皇帝的军队追捕而采取的逃亡策略。解决约瑟夫环问题的方法在计算机科学和数学中有广泛的应用。

问题描述：

假设有 n 个人围成一圈，从第一个人开始报数，每报数到第 k 个人就将其淘汰出局，然后下一个人继续从 1 开始报数，直到最后只剩下一个人。要解决的问题就是：在这个过程中，最后剩下的那个人初始位置是什么？

解决方案：

为了解决约瑟夫环问题，可以使用递归或迭代的方法求解。
还可以用循环链表解决。
下面我们分别介绍这几种解法。

递归解法：

递归是一种常见的解决约瑟夫环问题的方法。我们可以定义一个递归函数来表示整个过程。假设函数名为 josephus，接受两个参数：总人数 n 和报数 k。函数的返回值表示最后剩下的那个人初始位置。

在递归函数中，我们首先需要处理基本情况，即当只有一个人时直接返回其位置，即 0。否则，我们需要根据上一轮淘汰的人的位置来计算当前轮淘汰的人的位置。这可以通过公式 (josephus(n - 1, k) + k) % n 实现。然后，递归调用函数本身，传入更新后的总人数和报数 k，继续求解下一轮淘汰的人的位置。最后，将计算得到的当前位置作为函数的返回值。

// 递归函数，返回最后幸存者的位置
int josephus(int n, int k) {
    if (n == 1) {
        return 0;
    } else {
        return (josephus(n - 1, k) + k) % n;
    }
}

迭代解法：

除了使用递归，我们还可以使用迭代的方法解决约瑟夫环问题。迭代解法通常更高效，因为它避免了函数调用的开销。

迭代解法的思路是依次枚举每一轮淘汰的人的位置，从第一个人开始报数，按照规则找到下一轮淘汰的人，并更新总人数。具体步骤如下：

1. 初始化变量 survivor 为 0，表示最后剩下的人的位置。
2. 从 i = 2 到 n，依次枚举每一轮淘汰的人的位置。
3. 使用公式 survivor = (survivor + k) % i 更新 survivor 的值。
4. 返回最后计算得到的 survivor 的值。

// 迭代解法
int josephusIterative(int n, int k) {
    int survivor = 0;
    for (int i = 2; i <= n; ++i) {
        survivor = (survivor + k) % i;
    }
    return survivor;
}

使用循环链表实现约瑟夫环

思路如下：

1. 首先，我们需要创建一个链表，并将第一个节点作为头节点。
2. 由于是循环链表，我们需要将最后一个节点的 next 指针指向头节点，以形成环状结构。
3. 接下来，我们需要设置一个指针变量 toBeRemoved，用于指向当前待删除的节点。 进入循环，直到链表中只剩下一个节点为止。在每一轮循环中，我们需要进行以下操作：
4. 使用循环遍历链表，找到第 k-1 个节点（即要删除的节点的前一个节点）。

• 将 toBeRemoved 指针指向第 k 个节点，即待删除的节点。
• 将第 k-1 个节点的 next 指针指向第 k+1 个节点，删除待删除的节点。
• 输出被删除节点的值。

5. 循环结束后，链表中只剩下一个节点，返回该节点的值作为最后幸存者的位置。
6. 最后，释放链表的内存空间。

下面是使用循环链表实现约瑟夫环的完整代码：

#include <stdio.h>
#include <stdlib.h>

// 定义链表节点结构
typedef struct Node {
    int value;
    struct Node* next;
} Node;

// 创建新节点
Node* createNewNode(int value) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->value = value;
    newNode->next = NULL;
    return newNode;
}

// 删除节点并返回节点的值
int removeNode(Node** head, Node* toBeRemoved) {
    if (*head == toBeRemoved) {
        *head = toBeRemoved->next;
    }

    Node* temp = *head;
    while (temp->next != toBeRemoved) {
        temp = temp->next;
    }
    temp->next = toBeRemoved->next;

    int removedValue = toBeRemoved->value;
    free(toBeRemoved);
    return removedValue;
}

// 约瑟夫环算法，返回最后幸存者的位置
int josephus(int n, int k) {
    Node* head = createNewNode(1);  // 构建链表
    Node* currentNode = head;
    for (int i = 2; i <= n; ++i) {
        currentNode->next = createNewNode(i);
        currentNode = currentNode->next;
    }

    currentNode->next = head;    // 让链表成环
    Node* toBeRemoved = head;    // 当前待删除的节点
    while (toBeRemoved->next != toBeRemoved) {
        for (int i = 1; i < k; ++i) {
            toBeRemoved = toBeRemoved->next;
        }
        int removedValue = removeNode(&head, toBeRemoved);
        printf("%d ", removedValue);   // 输出删除的节点值
    }

    int survivor = head->value;
    free(head);  // 释放链表空间
    return survivor;
}

int main() {
    int n = 10;  // 参与游戏的人数
    int k = 3;   // 报数的数字
    int lastSurvivor = josephus(n, k);
    printf("\nThe last survivor's position is: %d\n", lastSurvivor);
    return 0;
}