反向约瑟夫环

 今天，工作不是很忙，闲暇的时候突然想起小时候玩的一个小游戏：一种花色的13张扑克牌，叠放在一起，隔一张取一张，取出的牌按顺序A-K排列，那原来的牌该按什么顺序叠放呢？想了想，跟约瑟夫环差不多，只是逆向的，要从结果反推。

 

// ReveseJosephson.cpp : 定义控制台应用程序的入口点。
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <malloc.h>

/* 结构体和函数声明 */
typedef struct _node_t
{
	int             n_num;
	struct _node_t *next;
} node_t;

/* 功能函数实现 */

/*
*  name: node_t_create
*  params:
*    n         [in]        输入要构造的链表的个数
*  return:
*    返回构造成功的环形单向链表指针
*  notes:
*    构造节点数量为 n 的环形单向链表
*
*/
node_t * node_t_create(int n)
{
	node_t *p_ret   = NULL;

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

		/* 构造 n 个 node_t */
		p_node = (node_t *) malloc(n * sizeof(node_t));
		if (NULL == p_node)
			return NULL;
		else
			memset(p_node, 0, n * sizeof(node_t));

		/* 内存空间申请成功 */
		p_ret = p_node;
		for (; n_idx < n; n_idx++)
		{
			p_node->n_num = n_idx;
			p_node->next = p_node + 1;
			p_node = p_node->next;
		}
		p_node->n_num = n;
		p_node->next = p_ret;
	}

	return p_ret;
}

/*
*  name: main
*  params:
*    none
*  return:
*    int
*  notes:
*    main function
*/
int main()
{
	int     n, m, k;
	node_t *p_list, *p_iter;
	int result_list[13];
	memset(result_list,0,sizeof(result_list));

	n = 13; m = 1; k=1;

	/* 构造环形单向链表 */
	p_list = node_t_create(n);

	/* Josephus 循环取数 */
	p_iter = p_list;
	m %= n;
	while (p_iter != p_iter->next)
	{
		int i   = 1;

		/* 取到第 m-1 个节点 */
		for (; i < m - 1; i++)
		{
			p_iter = p_iter->next;
		}

		/* 输出第 m 个节点的值 */
		//printf("%d\n", p_iter->next->n_num);

		result_list[p_iter->next->n_num-1]=k++;

		/* 从链表中删除第 m 个节点 */
		p_iter->next = p_iter->next->next;
		p_iter = p_iter->next;
	}
	//printf("%d\n", p_iter->n_num);
	result_list[p_iter->n_num-1]=k;

	for (int i=0;i<13;i++)
	{
		printf("%d\n",result_list[i]);
	}

	/* 释放申请的空间 */
	free(p_list);
}

上面的代码，也借用了http://blog.csdn.net/jianzhibeihang/article/details/4952947中约瑟夫环的实现，只是加了点东西，改了改，满足我的需要，希望借用不会介意，谢谢，呵呵