写一个约瑟夫环代码，用C++语言

好的，以下是一个约瑟夫环的 C 语言代码：

#include <stdio.h>

int josephus(int n, int k) {
if (n == 1) {
return 1;
} else {
return (josephus(n - 1, k) + k - 1) % n + 1;
}
}

int main() {
int n, k;
printf("请输入总人数n和出圈数字k：\n");
scanf("%d %d", &n, &k);
printf("最后留下的人的编号是：%d\n", josephus(n, k));
return ;
}

这个代码实现了一个约瑟夫环，输入总人数和出圈数字，输出最后留下的人的编号。

相关问题

使用C++顺序表解决约瑟夫环问题

约瑟夫环问题是一个经典的问题，可以使用顺序表来解决。

具体思路是：将约瑟夫环中的人员编号依次存入顺序表中，然后按照约瑟夫环的规则，依次删除表中的元素，直到表中只剩下一个元素为止。

以下是使用 C 语言实现约瑟夫环问题的代码：

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

#define MaxSize 100

typedef struct {
    int data[MaxSize];
    int length;
} SeqList;

void InitList(SeqList *list) {
    list->length = 0;
}

void InsertList(SeqList *list, int num) {
    if (list->length >= MaxSize) {
        printf("List is full.\n");
        exit(1);
    }
    list->data[list->length++] = num;
}

void Josephus(SeqList *list, int k, int m) {
    int i, j;
    for (i = k; list->length > 1; i = (i + m - 1) % list->length) {
        printf("Delete: %d\n", list->data[i]);
        for (j = i; j < list->length - 1; j++) {
            list->data[j] = list->data[j + 1];
        }
        list->length--;
    }
    printf("The last one is: %d\n", list->data[0]);
}

int main() {
    SeqList list;
    InitList(&list);
    int i;
    for (i = 1; i <= 10; i++) {
        InsertList(&list, i);
    }
    Josephus(&list, 0, 3);
    return 0;
}

在该代码中，我们首先定义了一个顺序表结构体，包含一个长度为 MaxSize 的数组和当前表的长度。然后我们定义了三个函数：InitList 用于初始化表，InsertList 用于在表中插入元素，Josephus 用于解决约瑟夫环问题。

在 Josephus 函数中，我们使用了一个循环，每次循环中，我们按照约瑟夫环的规则计算出下一个要删除的元素的下标 i，然后将该元素从表中删除。最后循环结束时，表中只剩下一个元素，即为约瑟夫环的最后一个人。

在 main 函数中，我们首先初始化了一个长度为 10 的顺序表，并且依次插入了数字 1 到 10。然后我们调用 Josephus 函数，传入参数 k = 0 和 m = 3，即从第 0 个人开始，每次删除第三个人。最后程序输出最后一个人的编号，即为解决约瑟夫环问题的答案。

c++链表解决约瑟夫环

约瑟夫环是一个经典的问题，可以使用链表来解决。以下是使用 C 语言实现的代码：

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

typedef struct node {
    int data;
    struct node* next;
} Node;

Node* createList(int n) {
    Node* head = (Node*)malloc(sizeof(Node));
    head->data = 1;
    head->next = NULL;
    Node* tail = head;
    for (int i = 2; i <= n; i++) {
        Node* newNode = (Node*)malloc(sizeof(Node));
        newNode->data = i;
        newNode->next = NULL;
        tail->next = newNode;
        tail = newNode;
    }
    tail->next = head;
    return head;
}

void josephus(int n, int m) {
    Node* head = createList(n);
    Node* p = head;
    while (n > 1) {
        for (int i = 1; i < m; i++) {
            p = p->next;
        }
        Node* tmp = p->next;
        p->next = tmp->next;
        free(tmp);
        n--;
    }
    printf("The winner is: %d\n", p->data);
    free(p);
}

int main() {
    josephus(10, 3);
    return 0;
}

在这个代码中，我们先定义了一个 `Node` 结构体表示链表节点，其中包含了节点的数据和指向下一个节点的指针。

然后，我们使用 `createList` 函数创建一个包含 `n` 个节点的循环链表。在创建过程中，我们先创建头节点 `head`，然后依次创建剩余的 `n-1` 个节点，并将它们链接在一起形成循环链表。

最后，我们使用 `josephus` 函数来模拟约瑟夫环的过程。在每一轮中，我们先找到第 `m` 个节点，然后将它从链表中删除。直到链表中只剩下一个节点为止，这个节点就是胜利者。

最后，我们释放掉所有的节点内存，程序结束。