建立非循环单链表的过程
建立非循环单链表的过程
因为链表是离散存储的，每一个结点之间通过指针来链接。所以要想创建一个非循环单链表，应该是先确定一个头结点（里面不存放任何有效数据），再确定一个尾结点（指针域为空，表明链表结束），然后在中间不断的用循环语句开辟一个个的新结点（用malloc 函数实现）。如下图：
我们先假定每一个结点的类型是：
Struct Node
{
Int data;
Struct Node *pNext;
};
为简单起见，我们规定结点中只存储整型数据。
现在让我们开始。
第一步：建立头结点和尾结点
因为链表创建的过程是不断的在头结点和尾结点之间插入新的结点。如果只有一个头结点的话，操作起来很不方便。
先定义两个指针变量：
然后用malloc 函数开辟一个结点。因为此时链表中只有一个结点，所以这个结点当然是头结点。
现在头结点有了，并且头指针指向了它，还需不需要另外创建一个尾结点呢？不需要。为什么呢？我们只要让头指针和尾指针同时指向这个结点就可以了。也就是说，在链表中只有一个结点的情况时，这个结点既可以看作是头结点，同时也可以看作是尾结点。当然，因为尾结点最后没有结点了，所以我们还要让尾结点的指针域为空。
好，头结点和尾结点都有了，并且都有一个指针变量指向了它们。那么现在就要开始创建新的结点了。
如何创建？当然要用循环。用for 循环或者while 循环都可以。喜欢哪样用哪样。我们就用for 循环吧。
要用循环，首先要解决两个问题。1、我要创建几个结点2、每个结点的值如何存储这些都好解决，无非是定义变量。
头结点尾结点
·····
新结点1新结点2新结点n
下面开始循环：
当然，这段代码还不够。最重要的功能还没有。我们还需要用malloc 函数动态开辟结点，并且让新开辟的结点和头结点与尾结点链接起来。下面把代码补充完整。
下面用图来解释一下这段代码：
简单起见，我们假定num=2,那for 循环就要循环两次。
第一次循环：
pHead pTail
循环之前的链表的情况是这样的，这个结点既是头结点也是尾结点
所以，第一次循环结束后，整个链表的情况是这样的：
执行完Struct Node *pNew =(Struct Node *)malloc(sizeof(Struct
Node ));语句后链表的情况（开辟了一个新结点,用pNew
指向它）
pTail pHead pNew
pHead
pTail pNew
执行完pTail->pNext=pNew;后链表的情况（把pTail 所指向的结点链接到
pNew 所指向的结点）
执行完pNew->data=val;后链表的情况，（把val 保存在pNew 所指
向的结点的数据域）pTail
pHead pNew
pHead pTail
执行完pTail=pNew;后链表的情况（把pNew 赋给pTail,即pTail
指向了pNew 所指向的结点,pTail 不再指向头结点）
执行完pNew->pNext=NULL;后链表的情况(把NULL 赋给pNew
所指向的结点的指针域,即此结点成为尾结点)
pTail pHead pNew
pHead
pTail
可以看到：头指针所指向的头结点中的pNext 成员指向了
新建的结点，新建的结点中保存了从键盘输入的val 的值，
尾指针指向了最后一个结点，尾结点的指针域为NULL.
第二次循环：
执行完pTail=pNew;后链表的情况是这样的（把pNew
赋给pTail,即pTail 指向了pNew 所指向的结点）
pHead pTail
pTail pHead
pNew 执行完pTail->pNext=pNew;后链表的情况是这样的
（把pTail 所指向的结点链接到pNew 所指向的结点）
第二次循环之前链表的情况是这样的pHead
pTail
pNew
pHead
pTail 执行完pNew->pNext=NULL;后链表的情况是这样的
(把NULL 赋给pNew 所指向的结点的指针域,即此结点
成为尾结点)
pTail pHead pNew
执行完pNew->data=val;后链表的情况是这样的（把
val 保存在pNew 所指向的结点的数据域）
pHead
pTail
pNew
执行完Struct Node *pNew =(Struct Node
*)malloc(sizeof(Struct Node ));语句后链表的情况（开
辟了一个新结点,用pNew 指向它）
所以，第二次循环结束后，整个链表的情况是这样的：
pHead pTail
可以看到，新建的结点挂到了链表的最后，成为了尾结点，并且尾指针pTail指向了它。
在整个操作过程中，pNew只是个临时变量，当把pNew所指向的结点的指针域赋值为NULL(即让它成为尾结点时)，就把pNew赋给pTail,即让pTail一直指向尾结点。
就写到这儿吧，画这么多图真的好累。完整的代码就不写了，自己去练一练吧。
实验二 链表操作实现
实验二链表操作实现 实验日期： 2017 年 3 月 16 日 实验目的及要求 1. 熟练掌握线性表的基本操作在链式存储上的实现； 2. 以线性表的各种操作（建立、插入、删除、遍历等）的实现为重点； 3. 掌握线性表的链式存储结构的定义和基本操作的实现； 4. 通过本实验加深对C语言的使用（特别是函数的参数调用、指针类型的应用）。 实验容 已知程序文件linklist.cpp已给出学生身高信息链表的类型定义和基本运算函数定义。 （1）链表类型定义 typedef struct { int xh; /*学号*/ float sg; /*身高*/ int sex; /*性别，0为男生，1为女生*/ } datatype; typedef struct node{ datatype data; /*数据域*/ struct node *next; /*指针域*/ } LinkNode, *LinkList; （2）带头结点的单链表的基本运算函数原型 LinkList initList();/*置一个空表（带头结点）*/ void createList_1(LinkList head);/*创建单链表*/ void createList_2(LinkList head);/* 创建单链表*/ void sort_xh(LinkList head);/*单链表排序*/ void reverse(LinkList head);/*对单链表进行结点倒置*/ void Error(char *s);/*自定义错误处理函数*/ void pntList(LinkList head);/*打印单链表*/ void save(LinkList head,char strname[]);/*保存单链表到文件*/
《数据结构》实验报告 设计循环单链表
《数据结构》实验报告 1、实验名称:设计循环单链表 2、实验日期: 2013-3-26 3、基本要求： 1）循环单链表的操作，包括初始化、求数据元素个数、插入、删除、取数据元素； 2）设计一个测试主函数实际运行验证所设计循环单链表的正确性。 4、测试数据： 依次输入1，2，3，4，5，6，7，8，9，10，删除5，再依次输出数据元素。 5、算法思想或算法步骤: 主函数主要是在带头结点的循环单链表中删除第i个结点，其主要思想是在循环单链表中寻找到第i-1个结点并由指针p指示，然后让指针s指向a[i]结点，并把数据元素a[i]的值赋给x，最后把a[i]结点脱链，并动态释放a[i]结点的存储空间。 6、模块划分： 1）头文件LinList.h。头文件LinList.h中包括：结点结构体定义、初始化操作、求当前数据个数、插入一个结点操作、删除一个结点操作以及取一个数据元素操作； 2）实现文件dlb.cpp。包含主函数void main(void)，其功能是测试所设计的循环单链表的正确性。
7、数据结构： 链表中的结点的结构体定义如下： typedef struct Node { DataType data; struct Node *next; }SLNode; 8、源程序： 源程序存放在两个文件中，即头文件LinList.h和实现文件dlb.cpp。//头文件LinList.h typedef struct Node { DataType data; struct Node *next; }SLNode; void ListInitiate(SLNode **head) //初始化 { *head=(SLNode *)malloc(sizeof(SLNode)); //申请头结点，由head指示其地址 (*head)->next=*head; }
C语言_双向循环链表、增删查改、判断回文、排序、论文+代码
数学与计算机学院 课程设计说明书 课程名称: 数据结构与算法A设计实践 课程代码: 6015059 题目一: 线性表的链式表示和实现 题目二: 利用栈实现表达式求解 年级/专业/班: 2011/信科/2班 学生姓名: XXX 学号: XXX 开始时间:2014 年 5 月28 日 完成时间:2014 年 6 月28 日 课程设计成绩： 指导教师签名：年月日
目录 摘要 (1) 1 引言 (2) 2 实验一 (3) 2.1整体设计思路 (3) 2.2编码 (3) 2.3程序演示 (6)
摘要 随着计算机的普遍应用与日益发展，其应用早已不局限于简单的数值运算，数据结构与算法的学习就是为以后利用计算机资源高效地开发非数值处理的计算机程序打下坚实的理论、方法和技术基础。数据结构与算法旨在分析研究计算机加工的数据对象的特性，以便选择适当的数据结构和存储结构，从而使建立在其上的解决问题的算法达到最优。 本次数据结构实践的第一个实验是线性表的链式表示和实现，要求动态地建立循环链表并实现循环链元素的插入，删除，查询；使用双向链的结构实现判断一个录入的字符串是否是回文；建立一个单向链表，实现其内元素非递减排序。 关键词：数据结构与算法线性表链式结构栈表达式求解
1 引言 1.1问题的提出 数据结构课程设计是重要地实践性教学环节。在进行了程序设计语言课和《数据结构与算法》课程教学的基础上，设计实现相关的数据结构经典问题，有助于加深对数据结构课程的认识。本课程设计是数据结构中的一个关于线性表链式表示的实现还有用栈实现表达式求解，此课程设计要求对栈存储结构和链表存储结构非常熟悉，并能熟练使用它们。 1.2C语言 C语言既有高级语言的特点，又具有汇编语言的特点；既是一个成功的系统设计语言，有时一个使用的程序设计语言；既能用来编写不依赖计算机硬件的应用程序，又能用来编写各种系统程序；是一种受欢迎、应用广泛的程序设计语言。 1.3C语言发展过程 1973年，美国贝尔实验室的D.M.RITCHIE在B语言的基础上最终设计出了一种新的语言，他取了BCPL的第二个字母作为这种语言的名字，这就是C语言。 1977年Dennis M.Ritchie 发表了不依赖于具体机器系统的C语言编译文本《可移植的C语言编译程序》。 1978年Brian W.Kernighian和Dennis M.Ritchie出版了名著《The C Programming Language》，从而使C语言成为目前世界上流行最广泛的高级程序设计语言。 1.4任务 题目一：线性表的链式表示和实现 第一个实验主要是实现一些线性表的基本操作。包括（1）动态地建立循环链表；（2）实现循环链元素的插入，删除，查询；（3）使用双向链的结构实现判断一个录入的字符串是否是回文；（4）建立一个单向链表，实现其内元素非递减排序。
实现单链表的各种基本运算
实现单链表的各种基本运算 一、实验目的 了解单链表表的结构特点及有关概念，掌握单链表的各种基本操作算法思想及其实现。 二、实验内容 编写一个程序，实现顺序表的各种基本运算： 1、初始化单链表； 2、单链表的插入； 3、单链表的输出； 4、求单链表的长度 5、判断单链表是否为空； 6、输出单链表的第i位置的元素； 7、在单链表中查找一个给定元素在表中的位置； 8、单链表的删除； 9、释放单链表 三、算法思想与算法描述简图
主函数main void InitList(LinkList*&L) 初始化单链表L void DestroyList(LinkList*&L)//释放单链表L int ListEmpty(LinkList*L)//判断单链表L是否为空集 int Listlength(LinkList*L)//返回单链表L的元素个数 void DispList(LinkListt*L)//输出单链表L int GetElem(LinkList*L,int i,char e)/*ElemType e)获 取单链表L中的第i个元素*/ int LocateEmpty(LinkList*L,char e)/*ElemType e)在单 链表L中查找元素e*/ int ListInsert(LinkList*&L,int i,char e)/*ElemType e) 在单链表中第i个位置上插入元素e*/ int ListDelete(LinkList*&L,int i,char &e)/*ElemType e)在单链表L中删除第i个元素*/
四、实验步骤与算法实现 #include
双向循环链表的建立插入与删除
创建双向循环链表的源代码： #include
L->Length ++; } } //结点的输出 void Display( DuLinkList L) { DuLinkList p; printf("双向循环链表中的结点的数据为:"); for(p=L->next ;p->next !=L;) { printf("%d",p->data); printf(" 、"); p=p->next ; } printf("%d\n",p->data ); } int main() { DuLinkList L; int n,i; InitList(&L) ; printf("你想创建几个循环节点就输入几就行啦，请输入:"); scanf("%d",&n); Create(L,n); Display(L); } 双向循环链表插入源代码： #include
数据结构课程设计单链表操作
《数据结构课程设计》报告 题目：单链表操作 专业：计算机科学与技术 班级： 单链表操作 针对带头结点的单循环链表，编写实现以下操作的算法函数。
实现要求： ⑴单链表建立函数create：先输入数据到一维数组A[M]中，然后根据一维 数组A[M]建立一个单循环链表，使链表中个元素的次序与A[M]中各元素的次序相同，要求该函数的时间复杂度为O(m)； ⑵定位查找函数Locate：在所建立的单循环链表中查找并返回值为key的 第1个元素的结点指针；若找不到，则返回NULL； ⑶求出该链表中值最大和次大的元素值，要求该算法的时间复杂度为O(m)， 最大和次大的元素值通过指针变量带回，函数不需要返回值； ⑷将链表中所有值比key(值key通过形参传入)小的结点作为值为key的结 点前驱，所有值比key大的结点作为值为key的结点后继，并尽量保持原有结点之间的顺序，要求该算法的时间复杂度为O(m); ⑸设计一个菜单，具有上述处理要求和退出系统功能。 ⒈本人完成的工作： 一、定义结构体：LNode 二、编写以下函数： （1）建立单循环链表 （2）建立定位查找函数 （3）求出链表中最大和次大值 （4）将链表中的值和输入的Key比较，小的作为key前驱结点，大的作为key 的后继结点 三、设计具有上述处理要求和退出系统菜单 ⒉所采用的数据结构：单链表 数据结构的定义： typedef struct Node //定义结点的结构体 { DataType data; //数据域 struct Node *next; //指针域
}LNode; //结点的类型 ⒊所设计的函数 （1）Create(void) LNode *Create(void) //建立单循环链表，链表头结点head作为返回值{ int i,j,n,A[M]; //建立数组A【M】 LNode *head,*p,*move; head=(LNode*)malloc(sizeof(LNode)); //创建空单循环链表head->next=head; move=head; printf("请输入数组元素的个数："); //输入数组 scanf("%d",&n); printf("请输入数组："); for(i=0;i
数据结构循环链表插入和删除源代码代码
typedef struct LNode//结点类型 { int data;//数值域 struct LNode *next;//指针域 }CrLNode,*CrLinklist; #include"Base.h" #include"construct.h" #include"circulate_operation.c" int main() { CrLinklist L; int i,choice,n,e; printf("请输入链表元素个数:"); scanf("%d",&n); L=Initlist_L(n); printf("请选择执行语句，选择输入1，执行插入操作或选择输入2，执行删除操作:"); scanf("%d",&choice); switch(choice) { case 1: { printf("请输入插入元素的位置:"); scanf("%d",&i); if(i<=0||i>n) printf("您输入的值不合法"); else printf("请输入插入元素的值："); scanf("%d",&e); L=ListInsert_L(L,i,e); printf("插入后的链表为："); printlist_L(L); };break; case 2: { printf("请输入删除元素的位置:"); scanf("%d",&i); if(i<=0||i>n) printf("您输入的值不合法"); else L=ListDelete_L(L,i); printf("删除后的链表为");
printlist_L(L); };break; } } CrLinklist Initlist_L(int n)//创建带头结点的单链表 { CrLinklist L; CrLinklist P; int i; L=(CrLinklist)malloc(sizeof(CrLNode)); L->next=L;/* 先建立一个带头结点的单链表*/ printf("请输入%d个数据\n",n); for(i=n;i>0;--i) { P=(CrLinklist)malloc(sizeof(CrLNode)); /* 生成新结点*/ scanf("%d",&P->data); /* 输入元素值*/ P->next=L->next; /* 插入到表头*/ L->next=P; } return L; } CrLinklist ListInsert_L(CrLinklist L,int i,int e)//单链表的插入 { CrLinklist P,S; int j; P=L; j=0; while(P&&j
一步一步写算法(之循环单向链表)
软件英才网软件行业驰名招聘网站 一步一步写算法（之循环单向链表） 前面的博客中，我们曾经有一篇专门讲到单向链表的内容。那么今天讨论的链表和上次讨论的链表有什么不同呢？重点就在这个"循环"上面。有了循环，意味着我们可以从任何一个链表节点开始工作，可以把root定在任何链表节点上面，可以从任意一个链表节点访问数据，这就是循环的优势。 那么在实现过程中，循环单向链表有什么不同？ 1）打印链表数据 1void print_data(const LINK_NODE* pLinkNode) 2{ 3 LINK_NODE* pIndex = NULL; 4if(NULL == pLinkNode) 5return; 6 7 printf("%d\n", pLinkNode->data); 8 pIndex = pLinkNode->next; 9while(pLinkNode != pIndex){ 10 printf("%d\n", pIndex->data); 11 pIndex = pIndex ->next; 12 } 13} 以往，我们发现打印数据的结束都是判断指针是否为NULL，这里因为是循环链表所以发生了变化。原来的条件（NULL != pLinkNode）也修改成了这里的（pLinkNode != pIndex）。同样需要修改的函数还有find函数、count统计函数。 2）插入数据 14STATUS insert_data(LINK_NODE** ppLinkNode, int data) 15{ 16 LINK_NODE* pNode; 17if(NULL == ppLinkNode) 18return FALSE; 19 20if(NULL == *ppLinkNode){ 21 pNode = create_link_node(data); 22 assert(NULL != pNode);
用双向循环链表求解约瑟夫环
用双向循环链表求解约瑟夫环 学校：东北大学 专业：计算机科学与技术
1.问题描述 Josephus排列问题定义如下：假设n个竞赛者排成一个环形。给定一个正整数m≤n，从第1人开始，沿环计数，第m人出列。这个过程一直进行到所有人都出列为止。最后出列者为优胜者。全部出列次序定义了1，2，…n的一个排列。称为（n，m）Josephus排列。例如，（7，3）Josephus排列为3,6,2,7,5,1,4。【实验要求】 设计求解Josephus排列问题程序。 （1）采用顺序表、单链表或双向循环链表等数据结构。 （2）采用双向循环链表实现Josephus排列问题，且奇数次顺时针轮转，偶数次逆时针轮转。 （3）推荐采用静态链表实现Josephus排列问题。 2.需求分析 本程序要求根据输入的人数n和给定的正整数m，求得约瑟夫排列，且奇数次顺时针轮转，偶数次逆时针轮转。故可利用双向循环链表建立存储结构，利用双向循环链表的遍历与删除操作实现功能要求。 3.概要设计 1.抽象数据类型定义： typedef struct DuLNode { int data; struct DuLNode *prior; struct DuLNode *next; }DuLNode,*DuLinkList; //定义双向循环链表 2.基本操作 int InitList_Dul(DuLinkList &L) //建立一个只含头结点的空双向循环链表 int CreateList_DuL(DuLinkList &L,int n) //建立一个带头结点的含n个元素的 双向循环链表L int ListDelete_DuL(DuLinkList &L,DuLinkList x) //删除指针x指向的结点 3.设计思路 首先建立一个双向循环链表作为存储结构，每个结点的数据域存储每个人的编号，然后根据给定的m值对整个链表进行遍历，找到所要找的结点后，输出该结点的数据域的值，并在双向循环链表中删除该结点，重复这样的操作，一直到所有的人都出列，依次输出的数列即为所求的Josephus排列。 4.详细设计 typedef struct DuLNode { int data; struct DuLNode *prior;
第三章 单链表 题目和答案
第2章自测卷答案 一、填空 1.顺序表中逻辑上相邻的元素的物理位置相互相邻。单链表中逻辑上相邻的元素的物理位置不 相邻。 2.在单链表中，除了首元结点外，任一结点的存储位置由其直接前驱结点值域指示。 3．在n个结点的单链表中要删除已知结点*p，需找到它的地址。 二、判断正误（在正确的说法后面打勾，反之打叉） 1. 链表的每个结点中都恰好包含一个指针。X 2. 链表的物理存储结构具有同链表一样的顺序。X 3. 链表的删除算法很简单，因为当删除链中某个结点后，计算机会自动地将后续的各个单元向前移动。X 4. 线性表的每个结点只能是一个简单类型，而链表的每个结点可以是一个复杂类型。Y 5. 顺序表结构适宜于进行顺序存取，而链表适宜于进行随机存取。Y 6. 顺序存储方式的优点是存储密度大，且插入、删除运算效率高。X 7. 线性表在物理存储空间中也一定是连续的。X 8. 线性表在顺序存储时，逻辑上相邻的元素未必在存储的物理位置次序上相邻。X 9. 顺序存储方式只能用于存储线性结构。X 10. 线性表的逻辑顺序与存储顺序总是一致的。X 三、单项选择题 （A）1. 链接存储的存储结构所占存储空间： （A）分两部分，一部分存放结点值，另一部分存放表示结点间关系的指针 （B）只有一部分，存放结点值 （C）只有一部分，存储表示结点间关系的指针 （D）分两部分，一部分存放结点值，另一部分存放结点所占单元数 （B）2. 链表是一种采用存储结构存储的线性表； （A）顺序（B）链式（C）星式（D）网状 （D）3. 线性表若采用链式存储结构时，要求内存中可用存储单元的地址: （A）必须是连续的（B）部分地址必须是连续的 （C）一定是不连续的（D）连续或不连续都可以 （B）4．线性表Ｌ在情况下适用于使用链式结构实现。 （Ａ）需经常修改Ｌ中的结点值（Ｂ）需不断对Ｌ进行删除插入 （Ｃ）Ｌ中含有大量的结点（Ｄ）Ｌ中结点结构复杂 （C）5．单链表的存储密度 （Ａ）大于1；（Ｂ）等于1；（Ｃ）小于1；（Ｄ）不能确定 （A）6、在单链表的一个结点中有个指针。
数据结构实验 建立双向循环链表以及插入删除操作
实验一 要求：①建立双向循环链表 ②实现链表的插入、删除 运行程序点此处Demo_1.exe 实验程序源代码： #include "stdafx.h" #include
p->next =q; q->prior=p; q->next=L; L->prior =q; p=q; L->Length ++; } } //查找元素的位置 DuLinkList GetElemP(DuLinkList h,int i) { int j; DuLinkList p=h; for(j=1;j<=i;j++) p=p->next ; return p; } //结点的插入 status Listinsert(DuLNode *m,int i,int e) { //在带头结点的双链循环线性表L中第i个位置之前插入元素e，i的合法值为1≤i≤表长 DuLinkList p,q; if(i<1||i>(m->Length)) // i值不合法 return ERROR; p=GetElemP(m,i); if(!p) return ERROR; q=(DuLinkList)malloc(sizeof(DuLNode)); if(!q) return OVERFLOW; q->data=e; q->prior=p->prior; p->prior->next=q; q->next=p; p->prior=q; m->Length++; printf("您在双向循环链表第%d个位置之前插入了一结点元素:%d\n",i,e); return OK; } //结点的删除 status ListDelete(DuLinkList L,int i) { //删除带头结点的双链循环线性表L的第i个元素，i的合法值为1≤i≤表长
单链表转换成双向循环链表
#include
int i=-1; List *p,*data1,*q,*Last; data1=(List *)malloc(sizeof(List)); p=(List *)malloc(sizeof(List)); q=(List *)malloc(sizeof(List)); data1=head->next;//记住第一个数据地址 p=head->next; while(p->next!=NULL) { q=p; //q是前一个节点 p=p->next; //p是后一个节点 p->pre=q; //后一个节点的【前继指针】指向前一个节点的地址} Last=p; //p 就是【最后一个数据】的地址 data1->pre=Last; //【第一个元素】的【前继指针】指向【最后一个元素】的地址Last->next=data1; //【最后一个元素】的【后继指针】指向【第一个元素】的地址//双向链表构成 p=Last; printf("\n\n"); while(p->data!=1) { printf("%d ",p->data); p=p->pre; } printf("%d \n",p->data); }
数据结构C语言版 循环链表表示和实现
数据结构C语言版循环链表表示和实现.txt37真诚是美酒，年份越久越醇香浓烈；真诚是焰火，在高处绽放才愈显美丽；真诚是鲜花，送之于人，手有余香。/* 数据结构C语言版循环链表表示和实现 P35 编译环境：Dev-C++ 4.9.9.2 日期：2011年2月10日 */ #include
循环单链表法实现Josephus问题
向量法求解Josephus问题 智能一班林潇 2220101468 一．实验题目描述 Josephus问题可描述如下： 设有n个人围成一个环，现从第s个人开始报数，数到第m的人出列，然后从出列的下一个人从新开始报数，数到第m的人又出列，如此重复，直至所有人均出列为止。求这些人出列的顺序。 二．实验目的 熟练掌握线性表的链表实现基本操作。 三．实现功能 以循环单链表为存储结构，求解Josephus问题。 四．算法步骤 编写一个独立的函数模块求解Josephus问题，该函数仅通过参数与外界进行数据交换，不使用其它非局部变量，实现方案应具有良好的健壮性。另编写一个主函数作为驱动，在主函数中处理数据的输入与输出。 五．程序结构描述 程序主要包括一个驱动功能的主函数，包括要排列数组元素的输入，开始报数的位置，所报数字的输入。还有一个独立函数模块来实现Josephus问题，主函数通过调用该函数来实现元素的出列，并将出列元素按顺序重新存入数组，并将出列元素按顺序输出。 六．程序代码 #define N 10 #include
int a[10]; printf("请输入Josephus环的元素"); //输入组成Josephus环的元素 for(i=0;i<10;i++) scanf("%d",&a[i]); printf("请输入开始报数位置及所报数字"); //输入开始报数位置及所报数字 scanf("%d %d",&s,&m); LinkList L;//建立单循环连的头结点 L=(LinkList)malloc(sizeof(LNode)); L->message=a[0]; L->next=NULL; Josephus(L,s,m,N,e,a); } void Josephus(LinkList L,int s,int m,int n,int e,int a[]){ LinkList p,q; int i,j; //将组成Josephus环的元素储存到单链中 for(i=n-1;i>0;i--){ p=(LinkList)malloc(sizeof(LNode)); p->message=a[i]; p->next=L->next; L->next=p; } LinkList H; H=L; for(i=0;i list是双向循环链表，，每一个元素都知道前面一个元素和后面一个元素。在STL 中，list和vector 一样，是两个常被使用的容器。和vector不一样的是，list不支持 对元素的任意存取。list中提供的成员函数与vector类似，不过list提供对表首元素的操作 push_front、pop_front，这是vector不具备的。禾口vector另一点不同的是，list的迭代器不会存在失效的情况，他不像vector会保留备份空间，在超过容量额度时重新全部分配内存，导致迭代器失效；list没有备份空间的概念，出入一个元素就申请一个元素的空间，所以它的迭代器不会失效。还是举《C++之vector》中的 例子： int data[6]={3,5,7,9,2,4}; list< int> lidata(data, data+6); lidata.push_back(6); list初始化时，申请的空间大小为6，存放下了data中的6个元素，当向lidata插入第7个元素“6”，list申请新的节点单元，插入到list链表中，数据存放结构如图1所示： 插入节点"6拆之后的list 图1 list的存储结构 list每次增加一个元素，不存在重新申请内存的情况，它的成本是恒定的。而vector每当增加关键元素的时候，都需要重新申请新的更大的内存空间，会调用元素的自身的复制构造函数，存在构造成本。在销毁旧内存的时候，会调用析构函数, 存在析构成本。所以在存储复杂类型和大量元素的情况下，list比vector更有优势！ List是一个双向链表,双链表既可以向前又向后链接他的元素。 主要的数据类型有两个带头结点的双向循环链表，这两个链表与MFC应用程序自动生成的对象类型混合使用，如下： typedef struct { //单个雨滴 COLORREF color;//雨滴颜色 bool visibility; //可见性 float radius; //半径 float x;//雨滴中心位置 x float y;//雨滴中心位置 y float xvelocity;//雨滴速率 vx float yvelocity;//雨滴速率 vy } droplet; struct dropletchain {//所有雨滴组成的链表 struct dropletchain * pre; droplet * drop; struct dropletchain * next; }; typedef struct {//单个涟漪 COLORREF color;//颜色 float xdrop;//涟漪中心 x float ydrop;//涟漪中心 y float radius;//涟漪半径 int shown;//是否绘制涟漪（这个参数在判断是否需要重绘时用到） }ripple; struct ripplechain {// 所有涟漪组成的链表 struct ripplechain * pre; ripple * aripple; struct ripplechain * next; }; 对链表的操作混杂在类CCrainDlg（mfc 的对话框类）中。 三、大致的程序流程： a) 在程序的初始化阶段定义了两个链表 struct dropletchain dc; struct ripplechain rc; 这两个都是空的链表,且 dc.drop=NULL; dc.pre=&dc; dc.next=&dc; rc.aripple=NULL; #include"iostream.h" #include"stdlib.h" #define maxsize 100//最大人数 struct Node{ int no;//第几个人 Node*next; }; class Josephring { private: Node*head; int totalnum; public: Josephring() { head=new Node; head->no=1; head->next=head; } void CreateJosephus(int n);//创建m个节点的链表 void show(); void Joseph(int k,int m);//约瑟夫环问题求解,从第k个人开始数数，数到m的人出列}; void Josephring::CreateJosephus(int n) { Node*s=head; totalnum=n; for(int i=2;i<=n;i++) { Node*w=new Node; w->no=i; w->next=head; s->next=w; s=w; } } void Josephring::show() { cout< cout< 单循环链表基本操作 /* (程序名) */ #include双向循环链表list
主要的数据类型有两个带头结点的双向循环链表
c++的循环链表实现的约瑟夫环问题
单循环链表基本操作