c语言josephus问题循环链表,循环单链表（C语言，无头节点，附约瑟夫杀人问题）...

最新推荐文章于 2022-09-06 08:08:29 发布
最新推荐文章于 2022-09-06 08:08:29 发布
阅读量204 收藏 1
点赞数
文章标签： c语言josephus问题循环链表

实现以下操作

init 初始化

traverse 遍历

head_add 头追加()，尾追加(尾插法)只需要注释掉函数最后一行的头指针赋值

len 长度

insert 指定位置插入

search 正、反向查找数据，返回第1次匹配的位置，找不到返回-1

get 获取指定位置的数据

delete 删除指定位置的数据

clear 清空链表

(注：使用头节点实现更好操作一些)

代码

#include

#include

#include

typedef struct node {

int data;

struct node *pNext;

}NODE, *PNODE;

void init(PNODE *);

void traverse(PNODE);

void head_add(PNODE *, int);

int len(PNODE);

bool insert(PNODE *, int, int);

int search(PNODE, int, bool);

bool get(PNODE, int, int *);

bool delete(PNODE *, int, int *);

void clear(PNODE *);

void clear(PNODE *pHead)

{

printf("clear...");

PNODE q, head;

head = *pHead;

do {

q = *pHead;

*pHead = (*pHead)->pNext;

free(q);

} while (*pHead != head );

*pHead = NULL;

printf("success!\n");

}

bool delete(PNODE *pHead, int pos, int *pVal)

{

printf("尝试删除节点 %d ", pos);

PNODE p = *pHead, q;

int i = 1;

if (! p || pos < 1 || pos > len(p)) {

printf("失败\n");

return false;

}

if(pos == 1) {

while (p->pNext != *pHead) {

p = p->pNext;

}

// 保存节点1的数据

*pVal = (*pHead)->data;

// 尾节点指向头节点后面的节点

p->pNext = (*pHead)->pNext;

q = *pHead;

// 更新头指针

*pHead = p->pNext;

// 释放节点1

free(q);

}

else {

while (i < pos-1) {

p = p->pNext;

++i;

}

*pVal = p->pNext->data;

// 保存指向被删除节点的指针

q = p->pNext;

p->pNext = p->pNext->pNext;

free(q);

}

printf("成功, 值为 %d\n", *pVal);

return true;

}

bool get(PNODE head, int pos, int *pVal)

{

printf("尝试get %d ", pos);

PNODE p = head;

int i = 1;

if (! head || pos < 1 || pos > len(head)) {

printf("失败\n");

return false;

}

while (i < pos) {

p = p->pNext;

++i;

}

*pVal = p->data;

printf("成功, 值为 %d\n", *pVal);

return true;

}

int search(PNODE head, int val, bool forward)

{

PNODE p = head;

int i = 1, last = -1;

if (!head)

return -1;

if (forward) {

while (p->pNext != head && p->data != val) {

p = p->pNext;

++i;

}

if (p->data == val)

last = i;

}

else {

while (p->pNext != head) {

if (p->data == val) {

last = i;

}

p = p->pNext;

++i;

}

if (p->data == val)

last = i;

}

return last;

}

bool insert(PNODE *pHead, int pos, int val)

{

PNODE tmp, p;

int i = 1;

printf("尝试插入位置 %d 数值 %d: ", pos, val);

if (pos < 1 || pos > len(*pHead)+1) {

printf(" 无效的插入位置\n");

return false;

}

tmp = (PNODE)malloc(sizeof(NODE));

tmp->data = val;

if (! *pHead) {

*pHead = tmp;

tmp->pNext = *pHead;

printf(", 空链表的第1个节点");

}

else if (pos == 1) {

p = (*pHead)->pNext;

while (p->pNext != (*pHead)) {

p = p->pNext;

}

p->pNext = tmp;

tmp->pNext = *pHead;

// 更新头指针指向(不加下面这行则实现了尾插法)

*pHead = tmp;

}

else {

p = *pHead;

while (i < pos-1) {

p = p->pNext;

i++;

}

tmp->pNext = p->pNext;

p->pNext = tmp;

}

printf(", 成功\n");

return true;

}

int len(PNODE head)

{

PNODE p = head;

int i = 1;

if (!head)

return 0;

while (p->pNext != head) {

p = p->pNext;

++i;

}

return i;

}

void head_add(PNODE *pHead, int val)

{

printf("head_add node value: %d\n", val);

PNODE tmp, p;

if (*pHead == NULL) {

*pHead = (PNODE)malloc(sizeof(NODE));

if (! *pHead) {

printf("内存分配失败!\n");

return;

}

(*pHead)->data = val;

(*pHead)->pNext = *pHead;

}

else {

tmp = (PNODE)malloc(sizeof(NODE));

if (! tmp) {

printf("内存分配失败!\n");

return;

}

tmp->data = val;

p = (*pHead)->pNext;

while (p->pNext != (*pHead)) {

p = p->pNext;

}

p->pNext = tmp;

tmp->pNext = *pHead;

// 更新头指针指向(不加下面这行则实现了尾插法)

*pHead = tmp;

}

}

void traverse(PNODE head)

{

printf("遍历结果:\n");

PNODE p = head;

int i = 1;

if (! head) {

printf("链表为空!\n");

return;

}

do {

printf("第 %d 个节点, self %p, data %d, pNext %p\n", i, p, p->data, p->pNext);

p = p->pNext;

++i;

} while (p != head);

}

void init(PNODE *pHead)

{

PNODE tmp, p;

int val, i=1;

while (1) {

printf("请输入节点 %d 的值，结束初始化请输入负数: ", i);

scanf("%d", &val);

if (val < 0)

break;

if (*pHead == NULL) {

*pHead = (PNODE)malloc(sizeof(NODE));

if (! *pHead) {

printf("内存分配失败!\n");

return;

}

(*pHead)->data = val;

(*pHead)->pNext = *pHead;

printf("初始化头节点:self %p, data %d, pNext %p\n", *pHead, (*pHead)->data, (*pHead)->pNext);

}

else {

tmp = (PNODE)malloc(sizeof(NODE));

if (! tmp) {

printf("内存分配失败!\n");

return;

}

tmp->data = val;

tmp->pNext = *pHead;

p = (*pHead)->pNext;

while (p->pNext != (*pHead)) {

p = p->pNext;

}

p->pNext = tmp;

}

++i;

}

}

int main(void)

{

PNODE head;

int val;

traverse(head);

printf("len:%d\n", len(head));

init(&head);

traverse(head);

head_add(&head, 10);

head_add(&head, 9);

traverse(head);

printf("len:%d\n", len(head));

insert(&head, 1, 8);

insert(&head, 1, 6);

insert(&head, 2, 7);

traverse(head);

printf("len:%d\n", len(head));

insert(&head, 2, 11);

traverse(head);

printf("正向查找 5 所在节点:%d\n", search(head, 5, true));

printf("正向查找 11 所在节点:%d\n", search(head, 11, true));

printf("反向查找 11 所在节点:%d\n", search(head, 11, false));

printf("正向查找 13 所在节点:%d\n", search(head, 13, true));

printf("正向查找 133 所在节点:%d\n", search(head, 133, true));

printf("反向查找 133 所在节点:%d\n", search(head, 133, false));

// test get

get(head, 1, &val);

get(head, 5, &val);

get(head, 15, &val);

// test delete

delete(&head, 0, &val);

delete(&head, 1, &val);

traverse(head);

delete(&head, 1, &val);

traverse(head);

delete(&head, 2, &val);

traverse(head);

delete(&head, 3, &val);

traverse(head);

delete(&head, 100, &val);

clear(&head);

traverse(head);

return 0;

}

output

[root@8be225462e66 c]# gcc circular_linklist.c && ./a.out

遍历结果:

链表为空!

len:0

请输入节点 1 的值，结束初始化请输入负数: 11

初始化头节点:self 0x1dc7ac0, data 11, pNext 0x1dc7ac0

请输入节点 2 的值，结束初始化请输入负数: 12

请输入节点 3 的值，结束初始化请输入负数: 13

请输入节点 4 的值，结束初始化请输入负数: -1

遍历结果:

第 1 个节点, self 0x1dc7ac0, data 11, pNext 0x1dc7ae0

第 2 个节点, self 0x1dc7ae0, data 12, pNext 0x1dc7b00

第 3 个节点, self 0x1dc7b00, data 13, pNext 0x1dc7ac0

head_add node value: 10

head_add node value: 9

遍历结果:

第 1 个节点, self 0x1dc7b40, data 9, pNext 0x1dc7b20

第 2 个节点, self 0x1dc7b20, data 10, pNext 0x1dc7ac0

第 3 个节点, self 0x1dc7ac0, data 11, pNext 0x1dc7ae0

第 4 个节点, self 0x1dc7ae0, data 12, pNext 0x1dc7b00

第 5 个节点, self 0x1dc7b00, data 13, pNext 0x1dc7b40

len:5

尝试插入位置 1 数值 8: , 成功

尝试插入位置 1 数值 6: , 成功

尝试插入位置 2 数值 7: , 成功

遍历结果:

第 1 个节点, self 0x1dc7b80, data 6, pNext 0x1dc7ba0

第 2 个节点, self 0x1dc7ba0, data 7, pNext 0x1dc7b60

第 3 个节点, self 0x1dc7b60, data 8, pNext 0x1dc7b40

第 4 个节点, self 0x1dc7b40, data 9, pNext 0x1dc7b20

第 5 个节点, self 0x1dc7b20, data 10, pNext 0x1dc7ac0

第 6 个节点, self 0x1dc7ac0, data 11, pNext 0x1dc7ae0

第 7 个节点, self 0x1dc7ae0, data 12, pNext 0x1dc7b00

第 8 个节点, self 0x1dc7b00, data 13, pNext 0x1dc7b80

len:8

尝试插入位置 2 数值 11: , 成功

遍历结果:

第 1 个节点, self 0x1dc7b80, data 6, pNext 0x1dc7bc0

第 2 个节点, self 0x1dc7bc0, data 11, pNext 0x1dc7ba0

第 3 个节点, self 0x1dc7ba0, data 7, pNext 0x1dc7b60

第 4 个节点, self 0x1dc7b60, data 8, pNext 0x1dc7b40

第 5 个节点, self 0x1dc7b40, data 9, pNext 0x1dc7b20

第 6 个节点, self 0x1dc7b20, data 10, pNext 0x1dc7ac0

第 7 个节点, self 0x1dc7ac0, data 11, pNext 0x1dc7ae0

第 8 个节点, self 0x1dc7ae0, data 12, pNext 0x1dc7b00

第 9 个节点, self 0x1dc7b00, data 13, pNext 0x1dc7b80

正向查找 5 所在节点:-1

正向查找 11 所在节点:2

反向查找 11 所在节点:7

正向查找 13 所在节点:9

正向查找 133 所在节点:-1

反向查找 133 所在节点:-1

尝试get 1 成功, 值为 6

尝试get 5 成功, 值为 9

尝试get 15 失败

尝试删除节点 0 失败

尝试删除节点 1 成功, 值为 6

遍历结果:

第 1 个节点, self 0x1dc7bc0, data 11, pNext 0x1dc7ba0

第 2 个节点, self 0x1dc7ba0, data 7, pNext 0x1dc7b60

第 3 个节点, self 0x1dc7b60, data 8, pNext 0x1dc7b40

第 4 个节点, self 0x1dc7b40, data 9, pNext 0x1dc7b20

第 5 个节点, self 0x1dc7b20, data 10, pNext 0x1dc7ac0

第 6 个节点, self 0x1dc7ac0, data 11, pNext 0x1dc7ae0

第 7 个节点, self 0x1dc7ae0, data 12, pNext 0x1dc7b00

第 8 个节点, self 0x1dc7b00, data 13, pNext 0x1dc7bc0

尝试删除节点 1 成功, 值为 11

遍历结果:

第 1 个节点, self 0x1dc7ba0, data 7, pNext 0x1dc7b60

第 2 个节点, self 0x1dc7b60, data 8, pNext 0x1dc7b40

第 3 个节点, self 0x1dc7b40, data 9, pNext 0x1dc7b20

第 4 个节点, self 0x1dc7b20, data 10, pNext 0x1dc7ac0

第 5 个节点, self 0x1dc7ac0, data 11, pNext 0x1dc7ae0

第 6 个节点, self 0x1dc7ae0, data 12, pNext 0x1dc7b00

第 7 个节点, self 0x1dc7b00, data 13, pNext 0x1dc7ba0

尝试删除节点 2 成功, 值为 8

遍历结果:

第 1 个节点, self 0x1dc7ba0, data 7, pNext 0x1dc7b40

第 2 个节点, self 0x1dc7b40, data 9, pNext 0x1dc7b20

第 3 个节点, self 0x1dc7b20, data 10, pNext 0x1dc7ac0

第 4 个节点, self 0x1dc7ac0, data 11, pNext 0x1dc7ae0

第 5 个节点, self 0x1dc7ae0, data 12, pNext 0x1dc7b00

第 6 个节点, self 0x1dc7b00, data 13, pNext 0x1dc7ba0

尝试删除节点 3 成功, 值为 10

遍历结果:

第 1 个节点, self 0x1dc7ba0, data 7, pNext 0x1dc7b40

第 2 个节点, self 0x1dc7b40, data 9, pNext 0x1dc7ac0

第 3 个节点, self 0x1dc7ac0, data 11, pNext 0x1dc7ae0

第 4 个节点, self 0x1dc7ae0, data 12, pNext 0x1dc7b00

第 5 个节点, self 0x1dc7b00, data 13, pNext 0x1dc7ba0

尝试删除节点 100 失败

clear...success!

遍历结果:

链表为空!

[root@8be225462e66 c]#

约瑟夫杀人问题核心代码

注：其它函数使用上面的，最后结果为16，31

void kill(PNODE *);

void kill(PNODE *pHead)

{

int val;

PNODE p;

while (len(*pHead) >= 3) {

delete(pHead, 3, &val);

*pHead = (*pHead)->pNext->pNext;

}

}

output:

[root@8be225462e66 c]# gcc joseph.c && ./a.out

剩下的活人:

链表为空!

tail_add node value: 1

tail_add node value: 2

tail_add node value: 3

tail_add node value: 4

tail_add node value: 5

tail_add node value: 6

tail_add node value: 7

tail_add node value: 8

tail_add node value: 9

tail_add node value: 10

tail_add node value: 11

tail_add node value: 12

tail_add node value: 13

tail_add node value: 14

tail_add node value: 15

tail_add node value: 16

tail_add node value: 17

tail_add node value: 18

tail_add node value: 19

tail_add node value: 20

tail_add node value: 21

tail_add node value: 22

tail_add node value: 23

tail_add node value: 24

tail_add node value: 25

tail_add node value: 26

tail_add node value: 27

tail_add node value: 28

tail_add node value: 29

tail_add node value: 30

tail_add node value: 31

tail_add node value: 32

tail_add node value: 33

tail_add node value: 34

tail_add node value: 35

tail_add node value: 36

tail_add node value: 37

tail_add node value: 38

tail_add node value: 39

tail_add node value: 40

tail_add node value: 41

第 3 个人自杀, 编号为 3

第 3 个人自杀, 编号为 6

第 3 个人自杀, 编号为 9

第 3 个人自杀, 编号为 12

第 3 个人自杀, 编号为 15

第 3 个人自杀, 编号为 18

第 3 个人自杀, 编号为 21

第 3 个人自杀, 编号为 24

第 3 个人自杀, 编号为 27

第 3 个人自杀, 编号为 30

第 3 个人自杀, 编号为 33

第 3 个人自杀, 编号为 36

第 3 个人自杀, 编号为 39

第 3 个人自杀, 编号为 1

第 3 个人自杀, 编号为 5

第 3 个人自杀, 编号为 10

第 3 个人自杀, 编号为 14

第 3 个人自杀, 编号为 19

第 3 个人自杀, 编号为 23

第 3 个人自杀, 编号为 28

第 3 个人自杀, 编号为 32

第 3 个人自杀, 编号为 37

第 3 个人自杀, 编号为 41

第 3 个人自杀, 编号为 7

第 3 个人自杀, 编号为 13

第 3 个人自杀, 编号为 20

第 3 个人自杀, 编号为 26

第 3 个人自杀, 编号为 34

第 3 个人自杀, 编号为 40

第 3 个人自杀, 编号为 8

第 3 个人自杀, 编号为 17

第 3 个人自杀, 编号为 29

第 3 个人自杀, 编号为 38

第 3 个人自杀, 编号为 11

第 3 个人自杀, 编号为 25

第 3 个人自杀, 编号为 2

第 3 个人自杀, 编号为 22

第 3 个人自杀, 编号为 4

第 3 个人自杀, 编号为 35

剩下的活人:

编号为 16

编号为 31

[root@8be225462e66 c]

许来西
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C语言利用循环单链表解决约瑟夫问题
Xenoverse的博客
12-12 1521
Description  编号是1,2,……,n的n个人按照顺时针方向围坐一圈,每个人持有一个密码(正整数)。一开始任选一个正整数作为报数上限值m,从第一个仍开始顺时针方向自1开始顺序报数,报到m时停止报数。报m的人出列,将他的密码作为新的m值,从他的顺时针方向的下一个人开始重新从1报数,如此下去,直到所有人全部出列为止。请设计一个程序输出出列顺序。 提示：存储结构采用不带头结点的循环单链表，...
约瑟夫环问题（循环链表）C语言
这里才是21世纪最伟大的程序员的博客
04-25 1280
约瑟夫环问题（循环链表）C语言 问题描述 约瑟夫环问题是由古罗马的史学家约瑟夫提出的，他参加并记录了公元66—70年犹太人反抗罗马的起义。约瑟夫作为一个将军，设法守住了裘达伯特城达47天之久，在城市沦陷之后，他和40名死硬的将士在附近的一个洞穴中避难。在那里，这些叛乱者表决说“要投降毋宁死”。于是，约瑟夫建议每个人轮流杀死他旁边的人，而这个顺序是由抽签决定的。 规则： 在一间房间总共有m个人，只能...
【数据结构】应用循环链表解决约瑟夫问题（无头节点）
好吃的爆米花
07-19 982
什么是约瑟夫问题？ 首先我们先看个故事： 据说著名犹太历史学家Josephus有过以下的故事：在罗马人占领乔塔帕特后，39 个犹太人与Josephus及他的朋友躲到一个洞中，39个犹太人决定宁愿死也不要被敌人抓到，于是决定了一个自杀方式，41个人排成一个圆圈，由第1个人开始报数，每报数到第3人该人就必须自杀，然后再由下一个重新报数，直到所有人都自杀身亡为止。然而Josephus 和他的朋友并不想遵从。首先从一个人开始，越过k-2个人（因为第一个人已经被越过），并杀掉第k个人。接着，再越过k-1个人，并杀掉
C语言循环链表实现约瑟夫环问题
qq_55227591的博客
11-09 2772
问题描述 约瑟夫环问题 （1）问题描述 设有编号为1,2,…,n的n（n＞0）个人围成一个圈，每个人持有一个密码m。从第一个人开始报数，报到m时停止报数，报m的人出圈，再从他的下一个人起重新报数，报到m时停止报数，报m的出圈，……，如此下去，直到所有人全部出圈为止。当任意给定n和m后，设计算法求n个人出圈的次序。 （2）基本要求 建立模型，确定存储结构。 对任意n个人，密码为m，实现约瑟夫环问题。 出圈的顺序可以依次输出，也可以用一个数组存储。 （3）设计思想 首先，设计实现约瑟夫环问题的存储结构。由
C语言循环链表（不带头结点）解约瑟夫问题的一种变形
kalakalabala的博客
10-26 1193
约瑟夫(Joseph)问题的一种描述是：编号为 1，2，…,n 的 n 个人按顺时针方向围坐一圈，每人持有一个密码（正整数），一开始任选一个整数作为报数上限 m,从第一人开始按顺时针方向从自 1 开始顺序报数，报到 m 时停止报数。报 m 的人出列，将他的密码作为新的 m 值，从他的顺时针方向上的下一个人开始重新从 1 报数，如此下去，直至所有人全部出列为止，设计一个程序求出出列顺序
约瑟夫josephus问题C++
two_orion的博客
09-15 3438
约瑟夫josephus问题C++ 一、实验内容： 一群小孩围成一圈，假定一个任意数m，从第k个小孩起，顺时针方向数，每数到第k个小孩时，该小孩便离开，圈子不断缩小。最后剩下的一个小孩便是胜利者。josephus问题是，胜利者究竟是第几个小孩？ 二、思路与步骤 ，首先这个问题是要将参加游戏的小孩围成一个圆圈，我们选用链表来存储这个圆圈， ...
C语言单向循环链表解决约瑟夫问题
Android Fans
12-19 3213
据说著名犹太历史学家 Josephus有过以下的故事：在罗马人占领乔塔帕特后，39 个犹太人与Josephus及他的朋友躲到一个洞中，39个犹太人决定宁愿死也不要被敌人抓到，于是决定了一个自杀方式，41个人排成一个圆圈，由第1个人开始报数，每报数到第3人该人就必须自杀，然后再由下一个重新报数，直到所有人都自杀身亡为止。然而Josephus 和他的朋友并不想遵从。首先从一个人开始，越过k-2个人（因
链表-使用C语言实现循环链表应用之解决约瑟夫问题.zip
最新发布
03-13
本项目专注于使用C语言实现循环链表，并将其应用于解决著名的约瑟夫问题。 约瑟夫问题（Josephus Problem）源于一个古老的故事，它涉及到在圆形排列的人群中，按照一定的间隔（通常为3或4）剔除一个人，直到剩下...
Josephus问题C语言单循环链表.doc
07-02
Josephus问题C语言单循环链表实现 本文档介绍了使用C语言实现的Josephus问题单循环链表算法。该算法使用链表数据结构来存储元素，并使用循环链表来实现Josephus问题的解决方案。 链表数据结构 在该算法中，我们...
用循环单链表解决josephus问题的算法.rar_循环单链表
09-23
在解决Josephus问题时，我们可以创建一个循环单链表，链表的节点代表参与游戏的人。初始时，链表的长度为N，每个节点代表一个参与者，节点中存储着该人的编号。接着，我们从第一个节点开始，每报数M次就将当前节点...
Josephus问题C++单循环链表实现
09-22
这个完全符合课本上习题的要求，我作业交的就是这个，我自己还在里面做了详细的注释
单向和双向循环链表实例（Josephus环问题）
04-13
Josephus问题可以描述为如下的一个游戏：N个人编号从1到N，围坐成一个圆圈，从1号开始传递一个热土豆，经过M次传递后拿着土豆的人离开圈子，由坐在离开的人的后面的人拿起热土豆继续进行游戏，直到圈子只剩下最后一个人。例如：M=0，N=5，则游戏人依次被清除，5号最后留下；如果M=1，N=5，那么被清除的人的顺序是2,4,1,5，最后剩下的是3号。
VC++2012编程演练数据结构《2》单循环链表与约瑟夫问题
11-19
VC++2012编程演练数据结构《2》单循环链表与约瑟夫问题
Josephus约瑟夫问题的循环链表实现.cpp
04-20
Josephus约瑟夫问题的循环链表实现.cpp
约瑟夫问题-基于C++的约瑟夫循环问题题解.zip
02-11
这个问题可以用来探讨循环链表、数组、递归等数据结构和算法的应用。 在C++中解决约瑟夫问题，通常有两种常见方法：一种是使用链表，另一种是使用循环数组。这里我们主要探讨基于C++的循环数组实现。 首先，我们...
约瑟夫(Joseph)问题（链表）C++
allen565的博客
10-05 980
约瑟夫(Joseph)问题的一种描述是：编号为 1，2，…,n 的 n 个人按顺时针方向围坐一圈， 每人持有一个密码（正整数），一开始任选一个整数作为报数上限 m,从第一人开始按顺时针方 向从自 1 开始顺序报数，报到 m 时停止报数。报 m 的人出列，将他的密码作为新的 m 值，从 他的顺时针方向上的下一个人开始重新从 1 报数，如此下去，直至所有人全部出列为止，设计 一个程序求出出列顺序。 # include<iostream> using namespace std; typ.
约瑟夫问题——链表实现
Mastli's Blog
05-28 1248
据说著名犹太历史学家 Josephus有过以下的故事：在罗马人占领乔塔帕特后，39 个犹太人与Josephus及他的朋友躲到一个洞中，39个犹太人决定宁愿死也不要被敌人抓到，于是决定了一个自杀方式，41个人排成一个圆圈，由第1个人开始报数，每报数到第3人该人就必须自杀，然后再由下一个重新报数，直到所有人都自杀身亡为止。然而Josephus 和他的朋友并不想遵从。首先从一个人开始，越过k-2个人（因
约瑟夫（Josephus）环问题（c++单向循环链表实现）
hhyer的博客
03-14 1872
约瑟夫（Josephus）环问题： 编号为1,2,3,…,n的n个人按顺时针方向围坐一圈，每人持有一个密码（正整数）。一开始任选一个正整数作为报数的上限值m，从第一个人开始按顺时针方向自1开始顺序报数,报到m时停止。报m的人出列，将他的密码作为新的m值，从他在顺时针方向上的下一人开始重新从1报数，如此下去，直到所有人全部出列为止。建立n个人的单循环链表存储结构，运行结束后，输出依次出队的人的序号。 思路 将n个人的password依次输入，将每个人的id，password，next写入一个结构体，形成链表的
约瑟夫问题 | c++ | 链表基础应用
m0_70241024的博客
09-06 688
约瑟夫问题是一个经典的问题。已知 n 个人（不妨分别以编号 1，2 ，3，…，n 代表 ）围坐在一张圆桌周围，从编号为 k 的人开始，从1开始顺时针报数 1, 2, 3, ...，顺时针数到m 的那个人，出列并输出。然后从出列的下一个人开始，从1开始继续顺时针报数，数到 m的那个人，出列并输出，…
c语言约瑟夫问题循环链表
10-16
好的，约瑟夫问题是一个经典的问题，可以使用循环链表来解决。具体思路是：先构建一个循环链表，然后从头节点开始，每次数到第 m 个节点就将其删除，直到链表中只剩下一个节点为止。下面是 C 语言的代码实现： ```c...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值