约瑟夫问题循环链表

循环链表的运算与单链表的运算基本一致，所不同的有以下几点：

（1）在建立一个循环链表时，必须使其最后一个节点的指针指向表头节点，而不是像单链表那样置为NULL。此种情况适用于在最后一个节点后插入一个新节点。

（2）判断是否到表尾采用判断该节点链域的值是否是表头节点的方法，当链域值等于表头指针时，说明已到表尾，而不是像单链表那样判断链域值是否为NULL。

约瑟夫问题：编号为1～N的N个人按顺时针方向围坐一圈，每人持有一个密码（正整数），开始人选一个正整数作为报数上限值M，从第一个人按顺时针方向自1开始顺序报数，报道M时停止报数。报M的人出列，将他的密码作为新的M值，从他顺时针方向上的下一个人开始从1报数，如此下去，直至所有人全部出列为止。

这种题目是以前参加ACM时，当作练习的题目，以前都是用数组来做，但现在用循环链表解答。

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

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

//建立循环链表方法1 
node *create_node(int n) 
{ 
node *pRet = NULL; 

if(0 != n) 
{ 
int n_idx = 1; 
node *p_node = NULL; 

p_node = new node[n]; //构造n个node 
if(NULL == p_node) 
{ 
return NULL; 
} 
else 
{ 
memset(p_node, 0, n * sizeof(node)); //初始化内存 
} 
pRet = p_node; 
while(n_idx < n) 
{ 
p_node->data = n_idx; 
p_node->next = p_node + 1; //指针往后移一位 
//cout<<p_node->data<<endl; 
p_node = p_node->next; 
n_idx++; 
} 
p_node->data = n; 
p_node->next = pRet; 
} 

return pRet; 
} 
//建立循环链表方法2 
node *create_node1(int n) 
{ 
node *head = (node *)malloc(sizeof(node)); 
node *before = NULL; 
node *New_node = NULL; 
int n_idx = 1; 

if(NULL == head) 
{ 
return NULL; 
} 
head->data = n_idx; 
head->next = NULL; 
before = head; 

n_idx++; 
while(n_idx <= n) 
{ 
New_node = (node *)malloc(sizeof(node)); 
if(NULL == New_node) 
{ 
return NULL; 
} 
New_node->data = n_idx; 
New_node->next = NULL; 
before->next = New_node; 
before = New_node; 
n_idx++; 
} 
New_node->next = head; //链表尾指针指向头指针。 

return head; 
} 

int main() 
{ 
node *pList = NULL; 
node *pIter = NULL; 
int n = 20; 
int m = 6; 

pList = create_node(n); 

pIter = pList; 
m %= n; //防止m > n 
while(pIter != pIter->next) 
{ 
int i = 1; 
for(; i<m-1; i++) 
{ 
pIter = pIter->next; 
} 
printf("%d ", pIter->next->data); //输出第m个节点的值 

pIter->next = pIter->next->next; //从链表中删除第m个节点 
pIter = pIter->next; //从下一个节点开始 
} 
printf("%d\n", pIter->data); 

delete []pList; 

return 0; 
}