利用链表解决约瑟夫问题

山西大学计算机与信息技术学院

实验报告

姓名学号专业班级

课程名称数据结构实验日期2015.5.13

成绩指导教师批改日期实验名称

一、实验目的：

利用链表解决约瑟夫问题。

二、实验内容:

1、概要设计

使用CreateList函数创建一个线性链表，其中链表长度由输入数据指定，输入数据由自然数按顺序组成，其对应密码由时间随机给出。使用Length函数计算线性表长度。使用Locate函数顺序遍历线性链表并返回当前结点对应的密码。由Delete函数删除链表中指定结点。在主函数中依次调用，并根据数据关系，在主函数中写出如下函数体便可。

LinkList L;

int x,k,j;

printf("Please enter an integer to be SQList length ----\n ");

CreateList(L);

k=Length(L);

printf("Please enter an random number m ---- \n");

scanf("%d",&x);

while(k>0){

while(x>k)x=x-k;

j=Locate(L,x);

Delete(L,x);

x=j-k+x;

k=k-1;

if(x<=0)x=x+k;

2、详细设计

#include

#include

#include

#include

#include

const int MAX_N=100;

typedef struct LNode{

int data;

int password;

LNode *next;

}LNode, *LinkList;

int Length(LinkList L){

LNode *p=L; int j=0;

if(!p) {printf("No head node!\n"); return 0;}

while(p->next){p=p->next;j++;}

return j;

}

void CreateList(LinkList &L){

L=(LinkList)malloc(sizeof(LNode));

L->next=NULL;

srand((unsigned)time(NULL));

LNode *p=L, *s;

int j;

int x =1;

scanf("%d",&j);

while(x!=j){

s=(LinkList)malloc(sizeof(LNode));

if(!s) {printf("OVERFLOW!\n"); return;}

s->data=x;

s->password= rand()%j+1;

s->next=p->next;

p->next=s;

p=s; //设尾指针

x=x+1;

}

p=L->next;

printf("SQList element and password----- \n" );

while(p){printf("element:%3d password:%3d \n", p->data,p->password); p=p->next;} printf("\n");

return;

}

int Locate(LinkList L, int x){//带头结点

LNode* p=L; int j=0;

while(p&&(j!=x)) {p=p->next; j++;}

if(!p) {printf("(L)No such Element %4d\n", x); return 0;}

return p->password;

}

void Delete(LinkList L,int x){

LNode* p=L; int j=0;

while(p&&(j!=x-1)) {p=p->next; j++;}

if(!p) printf("(D)No such Element %4d\n", x);

printf("Delete number %d \n",p->next->data);

p->next=p->next->next;

}

int main(){

LinkList L;

int x,k,j;

printf("Please enter an integer to be SQList length ----\n ");

CreateList(L);

k=Length(L);

printf("Please enter an random number m ---- \n");

scanf("%d",&x);

while(k>0){

while(x>k)x=x-k;

j=Locate(L,x);

Delete(L,x);

x=j-k+x;

k=k-1;

if(x<=0)x=x+k;

}

printf("\Program ends!\n"); }

三、实验结果:

四、结果分析:

运算结果完全正确。

线性表的顺序存储及解决约瑟夫问题

线性表的顺序存储 一、实验目的 1.掌握线性表的顺序存储结构。 2.能熟练地利用顺序存储结构实现线性表的基本操作。 3.能熟练地掌握顺序存储结构中算法的实现。 二、实验内容 1.建立含有若干个元素的顺序表，并将结果在屏幕上输出。 2.对刚建立的顺序表实现插入、删除、修改、查找，并将结果在屏幕上输出。 3.解决约瑟夫问题：假设有n个人按1、2、3、…、n的顺序围成一圈，现在，从第s 个人开始按1、2、3、…、m的顺序报数，数到m的人出圈，接着从出圈的下一个人开始重复此过程，直到所有人出圈为止。试用顺序表解决这个问题。 三、算法描述 1.第1题、第2题的算法提示 对第1题，先定义顺序表的数据类型，然后以1～n的序号建立顺序表，将输出结果单独定义成一个函数，以便后面反复使用它。对第2题，为操作方便，将插入、删除、修改、查找等操作都定义成单独的子函数形式。为查看这些操作的效果，可以在调用前后分别输出表的结果。 2.第3题的算法提示 对于第3题，可以将n个人的编号存入一个一维数组中，表的长度就是人数n，因此，就可以用一维数组来代替顺序表。算法的思想是：先求出出圈人的编号，用一个临时单元保存它，然后从出圈人的后一个开始，直到最后一个，都按顺序向前移动一个位置，再将临时单元中的出圈人编号存入最后。当这个重复步骤完成后，数组中存放的是出圈人的逆序列。本题中，围圈的人数n、出圈的报数号m、开始报数的位置s在程序中预先给定为10、3、2。当然，也可以从键盘临时输入。 四、源程序 第1、2题的源程序及程序清单 #include using namespace std; const int MaxSize=100; class List{ public: List(){length=0;} // 建立一个空表 List(int a[], int n); //建立一个长度为n的顺序表 ~List(){} int Length(){return length;} //求线性表的长度

c语言链表解析

c语言链表解析 编程思想： 链表由一系列不必在内存中相连的结构组成。每一个结构均含有表元素和指向包含该元素后继元的结构指针。我们称之为next指针。最后一个单元的next指针指向NULL；该值由C定义并且不能与其它指针混淆。ANSI C规定NULL为零。 指针变量是包含存储另外某个数据的地址的变量。因此，如果P被声明为指向一个结构的指针，那么存储在P中的值就被解释为内存中的一个位置，在该位置能够找到一个结构。该结构的一个域可以通过P->FileName访问，其中FileName是我们要考察的域的名字。如图1所示，这个表含有五个结构，恰好在内存中分配给它们的位置分别是1000，800,712,992和692。第一个结构的指针含有值800，它提供了第二个结构所在的位置。其余每个结构也都有一个指针用于类似的目的。当然，为了访问该表，我们需要知道在哪里能够找到第一个单元。 图1 为了执行打印表PrinList（L）或查找表Find（L，key），只要将一个指针传递到该表的第一个元素，然后用一些Next指针穿越该表即可。 删除命令可以通过修改一个指针来实现。图2给出在原表中删除第三个元素的结果。 图2 插入命令需要使用一次malloc调用从系统得到一个新单元并在此后执行两次指针调整。想法通过图3给出，其中虚线表示原来的指针。 图3

程序设计： 上面的描述实际上足以使每一部分都能正常工作，但还是有几处地方可能会出问题： 1、并不存在从所给定义出发在表的前面插入元素的真正显性的方法。 2、从表的前面实行删除是一个特殊情况，因为它改变了表的起始端；编程的疏忽将会造成表的丢失。 3、在执行删除命令时，要求我们记住被删除元素前面的表元。 事实上，稍作一个简单的变化就能够解决所有这三个问题。做一个标志节点——表头（header）。图4表示一个带头头结点的链表。 图4 为了避免删除操作相关的一些问题，我们需要编写一个FindPrevious函数，它将返回我们要删除的表元的前驱元的位置。如果我们使用表头，那么当删除表的第一个元素时，FindPrevious将返回表头的位置。 代码实现： 按照C的约定，作为类型的List（表）和Position（位置）以及函数的原型都列在所谓的.h 头文件中。具体的Node（节点）声明则在.c文件中。 代码1、链表的类型声明 #ifndef _List_H struct Node; typedef struct Node *PtrToNode; typedef PtrToNode List; typedef PtrToNode Posotion; List MakeEmpty(List L); int IsEmpty(List L); int IsLast（Position P， List L）； Position Find(ElementType X, List L); void Delete(ElementType X, List L); Position FindPrevious(ElementType X, List L); void Insert(ElementType X, List L, Position P); void DeleteList(List L); struct Node { ElementType Elment; Position Next; } 代码2、测试一个链表是否是空表的函数。（头结点的Next指向NULL时为空链表）

C++课程设计单链表——学生信息管理系统

学生信息管理系统设计文档 一、设计任务描述 为了实现学籍管理的简单化，我们基于Visual C++集成开发环境编写了“学生信息管 理系统”软件，该软件适用于所有win dows操作系统，面向广大用户， 界面简洁，操作简单。此软件主要是实现对学生学籍信息进行系统化的管理，可 以对学生基本信息进行添加、删除、查找、修改以及对学生成绩的管理，主要是根据学生的学号及其姓名进行操作的。该软件可以更加方便管理者管理学生学籍信息。 二、功能需求说明 该系统所需要的功能有：1链表的建立； 2、学生信息的插入； 3、学生信息的查询； 4、学生信息的输出； 5、学生信息的修改； 6、学生信息的删除； 7、良好的欢迎选择界面。 三、总体方案设计 一、实现任务的方法 1、在欢迎选择界面中，使用Switch这一选择结构来连接程序的执行和用户的命令; 2、在从学生信息的建立直到删除，都是使用链表的相关知识； 3、在定义学生信息时，建立一个Inform类；在定义学生课程成绩时，自定义了一个achieve结构体；

ST rucr acnieve { int nunber : char nane [10] [10]; float achieveiaent [13]： float xuefen [10]: float 0 : float average ; achieve C): float count average (); struct Inform {chai name[10]: char num[20]: string sex: string: id; string bir; string adr : string tel, achieve ach; void achinput 0 : void achprint 0 ; }; 三、模块划分 （1）链表的建立。 （2）对链表信息的插入。 （3）对链表信息的查找。 （4）对链表信息的输出。 （5）对链表信息的删除。 （6）对链表信息的修改。 课程成绩信息作为附加信息，穿插于各个模块中 三、数据结构说明 一、自定义的数据结构： 1、achieve （课程成绩）用于存放课程成绩信息包括课程数、课程名、 成绩、学分、总分和平均分。 "谍稈数 〃课程容（最參课稈数为nn "成绩 "学专 "总分 "平均分 "默认枸隆雷教 "计算该学生课程的加权平均分（总咸绩/总学分） "元素类型 "姓名 〃学号 〃性别 "身份证号 //出生年月曰 〃家庭地址 "电话号码 "课程咸绩 "谍程成绩输入 "遥程成缢输出 3、结点结构-Nodetype,定义了数据域inform和指针域next; 2、inform （学生基本信息）用于存放学生基本信息，包括姓名、学号、性别等。

约瑟夫问题求解

约瑟夫问题求解 一、问题描述。 1、实验题目 约瑟夫(Joseph)问题的一种描述是:编号为1,2,..., n 的n 个人按顺时针方向围坐一圈, 每人持有一个密码(正整数)。一开始选任一个正整数作为报数上限值m，从第一个人开始按顺时针方向自1开始顺序报数，报到m时停止报数。报m的人出列，将它的密码作为新的m值，再从下个人开始新一轮报数，如此反复，直到剩下最后一人则为获胜者。试设计一个程序求出出列顺序。 2、实验要求 利用单向循环链表存储结构模拟此过程，按照出列的顺序印出各人的编号。 3、测试数据 n=7，7 个人的密码依次为：3，1，7，2，4，8，4 。m的初值为20，则正确的出列顺序应为6，1，4，7，2，3，5。 4、输入输出 输入数据：建立输入处理输入数据，输入n输入以及每个人的密码；m的初值。输出形式：建立一个输出函数，输出正确的序列。 二、需求分析 1、本程序实现求解约瑟夫问题， 2、程序运行后，要求用户指定初始报数上限值，然后读取个人密码。 输入数据：建立输入处理输入数据，输入m的初值，n,输入每个人的密码，建立单循环链表。 输出形式：建立一个输出函数，将正确的序列输出。 三、概要设计 定义的抽象数据类型： 栈的抽象数据类型定义： ADT Stack{ 数据对象：D={ai|ai∈ElemSet,i=1,2,...,n, n≥0,ElemSet为元素集合} 数据关系：R={|ai-1,ai ∈D,i=1,2,...,n} 基本操作： InitStack(&S); //构造空栈 DestroyStack(&S); //销毁栈 ClearStack(&S); //将栈置空 StackEmpty(S); //检查栈是否为空 StackLength(S); //返回栈中元素个数

C语言链表专题复习

链表专题复习 数组作为存放同类数据的集合，给我们在程序设计时带来很多的方便，增加了灵活性。但数组也同样存在一些弊病。如数组的大小在定义时要事先规定，不能在程序中进行调整，这样一来，在程序设计中针对不同问题有时需要3 0个元素大小的数组，有时需要5 0个数组元素的大小，难于统一。我们只能够根据可能的最大需求来定义数组，常常会造成一定存储空间的浪费。 我们希望构造动态的数组，随时可以调整数组的大小，以满足不同问题的需要。链表就是我们需要的动态数组。它是在程序的执行过程中根据需要有数据存储就向系统要求申请存储空间，决不构成对存储区的浪费。 链表是一种复杂的数据结构，其数据之间的相互关系使链表分成三种：单链表、循环链表、双向链表，下面只介绍单向链表。 7.4.1 单链表 图7 - 3是单链表的结构。 单链表有一个头节点h e a d，指向链表在内存的首地址。链表中的每一个节点的数据类型为结构体类型，节点有两个成员：整型成员（实际需要保存的数据）和指向下一个结构体类型节点的指针即下一个节点的地址（事实上，此单链表是用于存放整型数据的动态数组）。链表按此结构对各节点的访问需从链表的头找起，后续节点的地址由当前节点给出。无论在表中访问那一个节点，都需要从链表的头开始，顺序向后查找。链表的尾节点由于无后续节点，其指针域为空，写作为N U L L。 图7 - 3还给出这样一层含义，链表中的各节点在内存的存储地址不是连续的，其各节点的地址是在需要时向系统申请分配的，系统根据内存的当前情况，既可以连续分配地址，也可以跳跃式分配地址。 看一下链表节点的数据结构定义： struct node { int num; struct node *p; } ; 在链表节点的定义中，除一个整型的成员外，成员p是指向与节点类型完全相同的指针。 在链表节点的数据结构中，非常特殊的一点就是结构体内的指针域的数据类型使用了未定义成功的数据类型。这是在C中唯一规定可以先使用后定义的数据结构。 ?单链表的创建过程有以下几步： 1 ) 定义链表的数据结构。 2 ) 创建一个空表。 3 ) 利用m a l l o c ( )函数向系统申请分配一个节点。

C语言链表功能实现

#include #define MaxSize 10 #define error 0 typedef int ElemType; typedef struct{ ElemType elem[MaxSize]; int last; }SeqList; void Input(SeqList *L);//Input the list void Output(SeqList L);//Output the list void Search(SeqList L);//Search element void Insert(SeqList *L); void Delete(SeqList *L); void Sort(SeqList *L); void bubblesort(SeqList *L); void selectsort(SeqList *L); void Function(); int main(){ int i,flag=1,k; ElemType e; SeqList L; https://www.wendangku.net/doc/6a12265590.html,st=0; Function(); printf("Please pick an option: "); scanf("%d",&k); while(flag){ switch(k){ case 0:{ flag=0; break; } case 1:{ Input(&L); break; } case 2:{ Output(L); break; } case 3:{ Insert(&L); break; } case 4:{

Search(L); break; } case 5:{ Delete(&L); break; } case 6:{ bubblesort(&L); break; } case 7:{ selectsort(&L); break; } default :{ printf("\nOption is useless.Please input again."); break; } } if(flag){ printf("\nPlease pick an option: "); scanf("%d",&k); } } return 0; } void Input(SeqList *L){ int i,n; printf("Please input the sum of elements:\n"); scanf("%d",&n); while(n>MaxSize){ printf("Sum is bigger than MaxSize,please input again\n"); scanf("%d",&n); } printf("Input the elements of list:\n"); for(i=0;ielem[i]); L->last++; } } void Output(SeqList L){

约瑟夫问题

一问题描述 1 题目内容：约瑟夫(Joseph)问题的一种描述是:编号为1,2,..., n的n 个人按顺时针方向围坐一圈, 每人持有一个密码(正整数)。一开始选任一个正整数作为报数上限值m，从第一个人开始按顺时针方向自1开始顺序报数，报到m时停止报数。报m的人出列，将它的密码作为新的m值。试设计一个程序求出出列顺序。 2 基本要求：利用单项循环链表存储结构模拟此过程，按照出列的顺序印出各人的编号。 3 测试数据：m的初值为20；n=7，7个人的密码依次为：3，1，7，2，4，8，4（正确的出列顺序应为6，1，4，7，2，3，5）。 二需求分析 程序运行后，首先要求用户指定初始报数上限值，然后读取个人的密码。输入数据：建立输入处理输入数据，输入m的初值，n ，输入每个人的密码，建立单循环链表。输出形式：建立一个输出函数，将正确的输出序列 三概要设计 利用单项循环链表存储结构模拟此过程 1 循环链表的抽象数据类型 循环链表是单链表的一种变化形式，把单链表的最后一个节点的next指针指向第一个节点，整个链表就形成了一个环。

2 循环链表的基本操作（仅列出用在本程序的） creat(n) 操作结果：构造一个长度为n的无头节点的循环链表,并返回指向最后一个节点的指针 find(m,s) 初始条件：循环链表存在 操作结果：找到当前元素（即s）后面第m个元素 print(&m,&n,&s) 初始条件：循环链表存在 操作结果：从s中删除约舍夫问题中下一个被删除的元素，并将此元素显示在屏幕上 3 本程序包括4个模块： 主程序模块； 创建循环链表模块； 找节点模块； 删节点模块； 各模块调用关系如下图所示：

用链表与文件实现学生成绩管理系统

#include #include #include #include #include using namespace std; struct Class { int Chinese; int Math; int English; }; class Student { public: Student(); void Ofile(ofstream &of); void Infile(ifstream &f); void Out(); void Set(char *name,int no,Class score); char *GetName(); int GetNo(); Student *Next; protected: char Name[20]; int No; Class Score; }; Student::Student():Next(0){} char *Student::GetName() { return Name; } int Student::GetNo() {return No;} void Student::Set(char *name,int no,Class score) { strcpy(Name,name); No=no; Score=score; } void Student::Infile(ifstream &f) { f>>Name>>No>>Score.Chinese>>Score.Math>>Score.English; //将数据输入到文

约 瑟 夫 环 问 题 的 三 种 解 法 ( 2 0 2 0 )

约瑟夫问题(数学解法及数组模拟) 约瑟夫问题（有时也称为约瑟夫斯置换，是一个出现在计算机科学和数学中的问题。在计算机编程的算法中，类似问题又称为约瑟夫环。又称“丢手绢问题”.）据说著名犹太历史学家 Josephus有过以下的故事：在罗马人占领乔塔帕特后，39 个犹太人与Josephus及他的朋友躲到一个洞中，39个犹太人决定宁愿死也不要被敌人抓到，于是决定了一个自杀方式，41个人排成一个圆圈，由第1个人开始报数，每报数到第3人该人就必须自杀，然后再由下一个重新报数，直到所有人都自杀身亡为止。然而Josephus 和他的朋友并不想遵从。首先从一个人开始，越过k-2个人（因为第一个人已经被越过），并杀掉第k个人。接着，再越过k-1个人，并杀掉第k个人。这个过程沿着圆圈一直进行，直到最终只剩下一个人留下，这个人就可以继续活着。问题是，给定了和，一开始要站在什么地方才能避免被处决？Josephus要他的朋友先假装遵从，他将朋友与自己安排在第16个与第31个位置，于是逃过了这场死亡游戏。 ? 以上来自百度百科约瑟夫【导师实操追-女视频】问题是个很有名的问题：N个人围成一个圈，从第一个人开始报数，第M个人会被杀掉，最后一个人则为幸存者【Ｑ】，其余人都将被杀掉。例如N=6，M=5，被杀掉的顺序是：5【１】，4，6，2，3，1。 约瑟夫【０】问题其实并不难，但求解的方法多种多样；题目的

变化形式【⒈】也很多。接下来我们来对约瑟夫问题进行讨论。 1.模拟【б】解法优点 : 思维简单。?缺点：时间复杂度高达O(m*【9】n) 当n和m的值较大时，无法短时间内得到答案。 为了叙述【５】的方便我们将n个人编号为：1- n ，用一个数组vis【２】来标记是否存活：1表示死亡 0表示存活 s代表当前死亡的人【６】数? cnt 代表当前报了数的人数用t来枚举每一个位置(当tn时 t=1将人首尾相连)? 那么我们不难得出核心代码如下：bool vis[1000]; --标记当前位置的人的存活状态 int t = 0; --模拟位置 int s = 0; --死亡人数 int cnt = 0; --计数器 if(t n) t = 1; if(!vis[t]) cnt++; --如果这里有人,计数器+1 if(cnt == m) --如果此时已经等于m,这这个人死去 cnt = 0; --计数器清零 s++; --死亡人数+1 vis[t] = 1 --标记这个位置的人已经死去 coutt" "; --输出这个位置的编号 }while(s != n); 接下来我们来看另一种更为高效快速的解法数学解法 我们将这n个人按顺时针编号为0~n-1，则每次报数到m-1的人死去，剩下的人又继续从0开始报数，不断重复，求最后幸存的人最

单链表的学生成绩管理系统设计与实现

长春建筑学院《数据结构》课程设计（论文） 基于单链表的学生成绩管理系统设计与实现 Design and implementation of the system of student performance management based on single table 年级: 12级 学号: 121500103 姓名: 徐文辉 专业:计算机科学与技术 指导老师: 常大俊 二零一三年十二月

摘要 学生成绩管理系统是典型的信息管理系统,是学校教务管理的重要组成部分，其处理信息量很大。本课程设计是用C++实现对学生的成绩管理作一个简单的模拟，实质是建立学生成绩单链表，每条记录由姓名、学号与成绩组成，即链表中每个结点由4个域组成，分别为：学号、、成绩、存放下一个结点地址的next域。用菜单选择操作方式完成五项功能分别写成五个函数，插入学生成绩对应建立学生单链表的功能，输出全部学生成绩记录，后三个功能分别对应单链表的查询、修改与删除三大基本操作。该系统中的数据采用线性表中的链式存储结构即单链表来存储，用结构体类型和类类型定义每个学生记录并采用外部文件方式记录数据简便数据的读取与保存。 关键词：数据结构，单链表，C语言，学生成绩管理

Abstract Student achievement management system is a typical management information system, is an important part of the school educational administration management, the large amount of information. The curriculum design is used to achieve C++ performance management for the students to make a simplesimulation, the essence is to establish students report list, each recordconsists of name,and grade, namely the linked list in each node iscomposed of 4 domains, respectively: next domain name, student number,grade, put down a node address the. Complete the five functions were written in five function menu to select the mode of operation, into the student achievement established a single list of the output function of students, allstudents record, after the three functions corresponding to single table query,modify and delete the three basic operations. The system data in the linked storage structure of linear table is a single linked list to store, use the structure types and class types define each student records and the use of an external file to read and save data and simple data record.

约瑟夫问题算法及数据结构课程设计报告

线性表的操作及其应用 一、问题描述 线性表、队列是一种常用的数据结构，有顺序和链式两种存储结构，在实际中应用十分广泛，而链表又分为单链表和循环链表，队列又分为链式队列和循环队列。这些数据结构都可用来解决约瑟夫环问题。约瑟夫环问题是算法设计中的一个经典问题，是顺序编号的一组n个人围坐一圈，从第1个人按一定方向顺序报数，在报到m时该人出列，然后按相同方法继续报数，直到所有人出列。设计算法求约瑟夫环中人员的出列顺序。 二、基本要求 1、选择合适的存储结构，建立线性表； 2、利用顺序存储结构求解约瑟夫环问题； 3、利用单链表和循环链表分别求解约瑟夫环问题； 4、利用队列求解约瑟夫环问题。 三、测试数据 约瑟夫环的测试数据为7，报数为1至3。 四、算法思想 由于用到四种不同的存储结构，它们的算法思想依次是： 1、首先建立一个顺序表模拟整个约瑟夫环，手动输入顺序表长（即参加约瑟夫循环的人数）和循环的次数和表元素。用已经输出总人数和顺序表长作比较，作为外层循环条件。并对每一个输出后的元素重新赋值以为标记。对于每次循环，首先检查顺序表此次是不是我们设立的标记，如果不是则循环次数加1，当达到要求的循环次数时就将循环次数设置为0，输出该元素到屏幕并将总输出元素加1。每次外循环我们都会移到表的下一个位置，作为新的判断条件，每次报到表尾的时候，我们都将重新设置到表尾，作为下次循环的表元素。 2、首先采用链式循环链表建立整个约瑟夫环，手动输入第一次的循环次数和每个人所持下一个循环次数。设立判断指针指向表头，并将该指针是否为空作为外层循环条件。做一个内层循环，将判断指针移动到循环要输出的数，并设立一个前指针指向该指针的前一个位置，输出该元素后，将循环次数重新赋值成该元素。接着判断前指针和判断指针比较，如果相等说明整个表已经输出完毕，否则将删除该位置的元素。 3、用链式队列建立循环约瑟夫环，手动输入人数，第一次的循环次数和每个人所持下一个循环次数。并将每一个元素依次入队列，根据第一次循环次数，建立一个for循环，每一次循环都出队列，如果达到要求的循环次数就输出，否则进队列，这样这个数字就出现在队尾。第一个数输出后，以队列的非空作为循环条件，判断方式如上。 4、用循环队列建立约瑟夫环，将1-7个元素依次进入循环队列，以队列的长度作为与已输出的元素作为判断条件，对每一个输出后的元素重新赋值以为标记。对于每次循环，首先检查该该位置的元素是不是我们设立的标记-1，如果不是则循环次数加1，将队首指针移

约 瑟 夫 环 问 题 的 三 种 解 法

约瑟夫环问题python解法 约瑟夫环问题：已知n个人（以编号1，2，3.n分别表示）围坐在一张圆桌周围。从编号为k的人开始报数，数到k的那个人被杀掉；他的下一个人又从1开始报数，数到k的那个人又被杀掉；依此规律重复下去，直到圆桌周围的人只剩最后一个。 思路是：当k是1的时候，存活的是最后一个人，当k=2的时候，构造一个n个元素的循环链表，然后依次杀掉第k个人，留下的最后一个是可以存活的人。代码如下： class Node(): def __init__(self,value,next=None): self.value=value self.next=next def createLink(n): return False if n==1: return Node(1) root=Node(1) tmp=root for i in range(2,n+1): tmp.next=Node(i) tmp=tmp.next

tmp.next=root return root def showLink(root): tmp=root while True: print(tmp.value) tmp=tmp.next if tmp==None or tmp==root: def josephus(n,k): if k==1: print('survive:',n) root=createLink(n) tmp=root while True: for i in range(k-2): tmp=tmp.next print('kill:',tmp.next.value) tmp.next=tmp.next.next tmp=tmp.next if tmp.next==tmp: print('survive:',tmp.value) if __name__=='__main__':

C语言写的学生成绩管理系统(链表)

#include #include #include struct stud{ long num; char name[20]; float sx; float dx; float ts; float dl; float cx; float zf; float pj; }; struct studcode{ struct stud student; struct studcode *next; }; void menu(); void input(struct studcode **); void output(struct studcode *); void binsearch(struct studcode *); void insert(struct studcode **); void delet(struct studcode **); void good(struct studcode *); void fail(struct studcode *); void sort(struct studcode *); void back(); void main() { char choose; int flag=1; struct studcode *head; head=NULL; printf("请先录入学生成绩信息\n"); printf("输入学生学号姓名高数、英语读写、英语听说、计算机导论和程序设计的成绩\n"); input(&head); while (flag)

{ system("cls"); menu(); printf("请选择:"); getchar(); choose=getchar(); switch(choose) { case '1': output(head); back(); break; case '2': binsearch(head); back(); break; case '3': insert(&head); output(head); back(); break; case '4': delet(&head); output(head); back(); break; case '5': good(head); back(); break; case '6': fail(head); back(); break; case '7': sort(head); output(head); back(); break; case '0': flag=0; printf("\n *** The End! ***\n"); printf("\n ####感谢使用，欢迎再次登录，拜拜！####\n");

约瑟夫问题及变种

“约瑟夫”问题及若干变种 例1、约瑟夫问题(Josephus) [问题描述] M只猴子要选大王，选举办法如下：所有猴子按1…M编号围坐一圈，从第1号开始按顺序1，2，…，N 报数，凡报到N的猴子退出到圈外，再从下一个猴子开始继续1~ N报数，如此循环，直到圈内只剩下一只猴子时，这只猴子就是大王。 M和N由键盘输入，1≤N,M≤10000，打印出最后剩下的那只猴子的编号。 例如，输入8 3，输出：7。 [问题分析1] 这个例题是由古罗马著名史学家Josephus提出的问题演变而来的，所以通常称为Josephus(约瑟夫)问题。 在确定程序设计方法之前首先来考虑如何组织数据，由于要记录m只猴子的状态，可利用含m个元素的数组monkey来实现。利用元素下标代表猴子的编号，元素的值表示猴子的状态，用monkey[k]=1表示第k只猴子仍在圈中，monkey[k]=0则表示第k只猴子已经出圈。 程序采用模拟选举过程的方法，设变量count表示计数器，开始报数前将count置为0，设变量current 表示当前报数的猴子编号，初始时也置为0，设变量out记录出圈猴子数，初始时也置为0。每次报数都把monkey[current]的值加到count上，这样做的好处是直接避开了已出圈的猴子（因为它们对应的monkey[current]值为0），当count=n时，就对当前报数的猴子作出圈处理，即：monkey[current]：=0，count：=0，out：=out+1。然后继续往下报数，直到圈中只剩一只猴子为止（即out=m-1）。参考程序如下： program josephus1a {模拟法，用数组下标表示猴子的编号} const maxm=10000; var m,n,count,current,out,i:integer; monkey:array [1..maxm] of integer; begin write('Input m,n:'); readln(m,n); for i:=1 to m do monkey[i]:=1; out:=0; count:=0; current:=0; while out

抽杀问题 约瑟夫问题

[阅读材料]世界名题与小升初之： 抽杀问题（約瑟夫问题） --马到成功老师 在各类竞赛中，各类小升初考试中相关的世界名题出现的概率极高，这是由小升初与数学竞赛的特点决定，这特点便是：知识性，趣味性，思想性相结合。 先给大家介绍这一问题的由来。 据说著名犹太历史学家Josephus有过以下的故事：在罗马人占领乔塔帕特後，39 個犹太人与Josephus及他的朋友躲到一個洞中，39個犹太人決定宁愿死也不要被人抓到，于是決定了一个自杀方式，41個人排成一个圆圈，由第1個人开始报数，每报数到第3人该人就必須自杀，然后再由下一个重新报数，直到所有人都自杀身亡为止。 然而Josephus 和他的朋友并不想遵从，Josephus要他的朋友先假装遵从，他將朋友与自己安排在第16個与第31個位置，于是逃过了这场死亡游戏。 解法 約瑟夫问题可用代数分析來求解，将这个问题扩大好了，假设现在您与m个朋友不幸参与了这个游戏，您要如何保护您的朋友？只要画两个圆圈就可以让自己与朋友免于死亡游戏，这两个圆内圈是排列顺序，而外圈是自杀顺序，如下图所示： 使用程式来求解的话，只要将阵列当作环状来处理就可以了，在陈列中由计数1开始，每找到三个无资料区就填入一个计数，直接计数來求解的話，只要將阵列当作环状来处理就可以了，在阵列中由計数1开始，每找到三个无资料区就填入一个計数，直而計数达41为止，然后將阵列由索引1开始列出，就可以得知每个位置的自杀順序，这就是約瑟夫排列，41個人报数3的約瑟夫排列如下所示： 14 36 1 38 15 2 24 30 3 16 34 4 25 17 5 40 31 6 18 26 7 37 19 8 35 27 9 20 32 10 41 21 11 28 39 12 22 33 13 29 23

C++课程设计 单链表——学生信息管理系统

C++课程设计单链表——学生信息管理系统

学生信息管理系统设计文档 一、设计任务描述 为了实现学籍管理的简单化，我们基于Visual C++集成开发环境编写了“学生信息管理系统”软件，该软件适用于所有windows操作系统，面向广大用户，界面简洁，操作简单。此软件主要是实现对学生学籍信息进行系统化的管理，可以对学生基本信息进行添加、删除、查找、修改以及对学生成绩的管理，主要是根据学生的学号及其姓名进行操作的。该软件可以更加方便管理者管理学生学籍信息。 二、功能需求说明 该系统所需要的功能有：1、链表的建立； 2、学生信息的插入； 3、学生信息的查询； 4、学生信息的输出； 5、学生信息的修改； 6、学生信息的删除； 7、良好的欢迎选择界面。 三、总体方案设计 一、实现任务的方法 1、在欢迎选择界面中，使用Switch 这一选择结构来连接程序的执行和用户的命令； 2、在从学生信息的建立直到删除，都是使用链表的相关知识； 3、在定义学生信息时，建立一个Inform 类；在定义学生课程成绩时，自定义了一个achieve 结构体； 二、总体结构

三、模块划分 （1）链表的建立。 （2）对链表信息的插入。 （3）对链表信息的查找。 （4）对链表信息的输出。 （5）对链表信息的删除。 （6）对链表信息的修改。 课程成绩信息作为附加信息，穿插于各个模块中。 三、数据结构说明 一、自定义的数据结构： 1、achieve（课程成绩）用于存放课程成绩信息包括课程数、课程名、成绩、学分、总分和平均分。 2、inform（学生基本信息）用于存放学生基本信息，包括姓名、学号、性别等。 3、结点结构-Nodetype,定义了数据域inform和指针域next;

C语言版用链表实现通讯录

C语言版用链表实现通讯录 “标头.h” #include #include #include #define Len sizeof(Lnode) int seat;//全局变量，用于存储通讯录成员信息typedef struct Lnode { int number; //学号 char name[20];//名字 double telenum;//电话 struct Lnode *next;//定义一个指向下一个节点的指针} Lnode,*LinkList;//把struct Lnode*重定义为LinkList LinkList creatIncreLink(); void deleteElem(LinkList l,int i); int delName(LinkList l,char name[]); int delNum(LinkList l,int n); void insertYouxu(LinkList l,LinkList Elem); void printList(LinkList l); LinkList prior(LinkList l,LinkList p); int searchName(LinkList l,char name[]); int searchNum(LinkList l,int n);

#include #include"标头.h" LinkList creatIncreLink() { LinkList p; int num=1,number; double telenum; char name[20],temp; LinkList L,P; L=(LinkList)malloc(Len); //创建头结点 L->next = NULL; printf("请输入学生学号、姓名和电话号码，建立通讯录，以'-1'为输入结果标志\n"); printf("请输入学号 %d："); scanf("%d",&number); printf("请输入姓名 %d:"); temp=getchar(); gets(name); printf("请输入电话号码 %d:"); scanf("%lf",&telenum); while (number >= 0) { p = (LinkList)malloc(Len); //新分配结点 p->number = number; p->telenum = telenum; strcpy(p->name,name); insertYouxu(L,p); //有序地插入新结点 num++; printf("请输入学号 %d：",&num); scanf("%d",&number); printf("请输入姓名 %d:",num); temp=getchar(); gets(name); printf("请输入电话号码 %d:",num); scanf("%lf",&telenum); }

约瑟夫环问题

约瑟夫环问题 问题描述： 有n个人围成一个环，然后给从某个人开始顺时针从1开始报数，每报到m时，将此人出环杀死(当然不杀死也可以啊)，然后从下一个人继续从1报数，直到最后只剩下一个人，求这个唯一剩下的存活的人是谁？ 分析： 首先，我们要标示这n个人，别小看这一步，其实蛮重要的。第一种标示方法是从0开始，将n个人标示为0~n-1，第二种方法是从1开始标示，将这n个人标示为1~n。当然会有人说了，那我从x(x>=2)开始，将此n个数标示为x~x+n-1，其实我们可以把这种情况都归到第二种从1开始标示的情况，为什么可以，我们稍后分析。 第一种情况从0开始编号： 编号为k的人拖出去杀死之后，下一个要拖出去受死的人的编号为：(k+m)%n (假设当前有n个人还活在环中)。 第二种情况从1开始编号： 编号为k的人拖出去杀死之后，下一个要拖出去受死的人的编号为：(k+m-1)%n+1，于是我们就可以回答上面的问题了，如果从x开始编号的话，下一个拖出去受死的人的编号就应该是：(k+m-x)%n+x了。 其实，上面的这两种情况是完全可以在合并的，编号只是一个识别，就像名字一样，叫什么都没关系，从某个人开始出环，不管他们怎么编号，n个人出环的先后顺序都是一样的，最后该哪个人活下来是确定的，不会因为编号而改变，所以不管从几开始编号，都可以归纳为从0开始编号，其他的编号就是一个从0编号情况的一个偏移而已，从x编号的情况就相当于从0开始编号的情况下每个人的编号都+x，大小先后顺序不变~ 于是，下面的讨论都是从0开始编号的~ 怎么解决这个问题呢？ 最简单的方法是模拟，模拟这个出环过程，可以使用链表也可以使用数组，时间复杂度都是O(n*m).当然，这种解法时间复杂度太高，不可取~ 我们有O(n)的算法~ 假设从编号为0的人开始报数，当然从编号为k的人开始报数的情况也是也可以解决的，只要稍微转化就可以，至于怎么解决？我们讲完从编号为0的人开始报数的情况就明白啦~ 我们从0编号开始报数，第一个出环的人m%n-1，剩下的n-1个人组成一个新的约瑟夫环，接下来从m%n开始报数，令k=m%n，新环表示为： k, k+1, k+2, ……n-1, 0, 1, 2, …..., k-2 我们对此环重新编号，根据上面的分析，编号并不会影响实际结果。 k → 0 k+1 → 1 k+2 → 2 ... k-2 → n-2 对应关系为：x’ = (x+k)%n (其中，x’是左侧的，x是右侧重新编号的)