约瑟夫环-两种实现方法，两种时间复杂度
已知n个人（以编号1，2，3...n分别表示）围坐在一张圆桌周围。从编号为r的人开始报数，数到m的那个人出列；他的下一个人又从1开始报数，数到m的那个人又出列；依此规律重复下去，直到圆桌周围的人全部出列。求最后出列的人的编号。
第一种方法就是使用循环链表的方法，因为这种方法在删除一个节点后，对于其他节点的位置改动不用太大。这是一种很浪费时间的方法，每次都删除第m个数字（注意题意包含摸的概念），也就是说，每次删除，都要用O(m)的时间，一共有n个数字，想要剩下一个，其余都要删除，那么就得用(n-1)*O(m)的时间，故算法的时间复杂度为O(mn).下面贴上两种代码的实现，分别为c和c++，之后给出另一种时间复杂度的算法。
c:
#include
#include
typedef struct node{
int data;
struct node *next;
}LinkNode, *LinkList;
LinkNode* get_last_num(int n, int k, int m) {
LinkList head = NULL;
LinkNode *temp = NULL;
LinkNode *p = NULL;
int i;
for(i=1; i <= n; i++) {//create list
p = (LinkNode*)malloc(sizeof(LinkNode));
p->data = i;
p->next = NULL;
if(head == NULL) {
head = p;
} else {
temp->next = p;
}
temp = p;
}
// link from last node to first node to a circle
p->next = head;
p= head;
// move k-1 step to k
i = 1;
while(i < k) {
p = p->next;
i++;
}
while(p->next != p) {
for(i = 1; i < (m-1); i++){ // move to node before destinated one
p = p->next;
}
temp = p->next; // get the aimed one
printf("%d\t", temp->data);
p->next = temp->next;
p = p->next; // point to node next deleted p node
free(temp);
temp = NULL;
}
return p;
}
void main() {
LinkNode *result = get_last_num(9, 1, 5);
printf("%d\t", result->data);
free(result);
} c++:
#include
#include
using namespace std;
int get_last_num(int n, int k, int m) {
list ilist;
for(size_t i = 1; i != (n+1); i++)
ilist.push_back(i);
list::iterator it = ilist.begin();
for(i = 1; i < k; i++)
++it;
while(ilist.size() > 1) {
for(i = 1; i < m; i++) {
if(it == ilist.end())
it = ilist.begin();
++it;
}
if(it == ilist.end())
it = ilist.begin();
cout << *it << endl;
it = ilist.erase(it);
if(it == ilist.end())
it = ilist.begin();
}
return *it;
}
void main() {
int result = get_last_num(9, 1, 5);
cout << result << endl;
}
第二种时间复杂度的算法，要涉及到一些数学知识。假设给定的数列为1,2,3,...,n-1,n的形式，从第1人开始报数到m，假设每次报数到m的人的编号为m，然后这个人出列。剩下的人的编号分别是m+1,m+2,...n-1,n,1,2,...,m-1.设定数列 1,2,3,...,n-1,n根据约瑟夫规则剩下的数字为与m，n有关的方程式：f(n,m),设定 f'(n-1,m)为数列m+1,m+2,...n-1,n,1,2,...,m-1根绝约瑟夫规则最后剩下的数字。可以看出，f(n,m),f'(m,n)表示的最后数字对应的序列式不一样的，第一个是以升序排列，而第二个是先升序，后降序。可以根映射将在序列二种的数字转化为对应序列一种的形式，
m+1 -> 1
m+2 -> 2
…
n-1 -> n-m-1
0 -> n-m
…
m-1 -> n-1
转换方程式为p(x)=(x + n - m) % n,x属于序列二，逆向的转换方式为 p'(x) = (x + m) % n,其中x属于第一种序列。 f'(n-1,m)表示的第二个序列的最后一个数和序列一经过 p'(x)转后序列的最后一个数字相同。 f'(n-1,m) = [f(n-1,m) + m] % n。
0 n=1
f(n,m)={
[f(n-1,m)+m]%n n>1
注意，这个方程式是一个递归的形式。
#include
#include
using namespace std;
int get_last_num(int n, int m){
int last_num = 0;
for(int i = 2; i <= n; i++)
last_num = (last_num + m) % i;
return last_num;
}
void main() {
int result = get_last_num(9, 5);
cout << result << endl;
}