数据结构与算法之约瑟夫问题

约瑟夫问题描述的是什么?

约瑟夫问题:有 N 个人围成一圈,每个人都有一个编号,编号由入圈的顺序决定,第一个入圈的人编号为 1,最后一个为 N,从第 k (1<=k<=N)个人开始报数,数到 m (1<=m<=N)的人将出圈,然后下一个人继续从 1 开始报数,直至所有人全部出圈,求依次出圈的编号。

如何存储数据

面对一道题,首先需要思考,要选用什么样的数据结构来保存数据。约瑟夫问题描述的是循环报数出圈的问题,报数始终围绕同一个方向进行,所以可以使用单向环形链表来存储。

每当有一个人入圈,就创建出一个新的节点,节点间首尾相连,代码如下:

//节点
class Node {
	//节点序号
	private Integer no;
	//指向下一个节点的引用
	private Node next;

	public Node(Integer no) {
		this.no = no;
	}

	@Override
	public String toString() {
		return "Node{" +
			"no=" + no +
			",next=" + (next == null ? "" : next.no) +
			'}';
	}
}

//单向环形链表
class SingleCycleLinkedList {
	//头引用
	private Node head;
	//尾引用
	private Node tail;
	//链表长度
	private int size;

	/**
	 * 初始化指定长度序号递增的环形链表
	 *
	 * @param size
	 */
	public SingleCycleLinkedList(int size) {
		for (int i = 1; i <= size; i++) {
			add(new Node(i));
		}
		this.size = size;
	}

	/**
	 * 插入环形链表
	 *
	 * @param node
	 */
	public void add(Node node) {
		if (node == null) {
			return;
		}

		//链表为空,直接将 head, tail 引用指向新节点
		if (size == 0) {
			head = node;
			tail = node;
			size++;
			return;
		}

		//链表不为空,将新节点放在链表最后,同时新节点的 next 引用指向 head,完成成环操作
		tail.next = node;
		tail = tail.next;
		tail.next = head;
		size++;
}

	...
}

核心逻辑在 add 方法中,需要注意的是,当链表为空时,新增的节点不能自成环,也就是 next 引用不能指向自己,所以第一次新增时,直接将 head, tail 指向新增的节点,不去操作节点的 next 引用。当链表不为空时,需要引入成环的步骤,成环步骤分解如下:

1.tail.next = node
数据结构与算法之约瑟夫问题_第1张图片
2.tail = tail.next
数据结构与算法之约瑟夫问题_第2张图片
3.tail.next = head
数据结构与算法之约瑟夫问题_第3张图片

这样即完成了成环操作。

在 main 方法中进行测试,构造长度为 10 的环形链表:

SingleCycleLinkedList singleCycleLinkedList = new SingleCycleLinkedList(10);
System.out.println(singleCycleLinkedList);

结果如下:

Node{no=1,next=2}, Node{no=2,next=3}, Node{no=3,next=4}, Node{no=4,next=5}, Node{no=5,next=6}, Node{no=6,next=7}, Node{no=7,next=8}, Node{no=8,next=9}, Node{no=9,next=10}, Node{no=10,next=1}

解决约瑟夫问题

通过上一步,完成了数据的存储,接下来需要解决如何循环报数出圈的问题。题目要求从第 k 个人开始报数,所以要先找到报数的起始位置,然后开始循环报数,数到 m 的人出圈,也就是对应的节点要移出链表。需要注意的是,单向链表的节点无法自我删除,如图所示:
数据结构与算法之约瑟夫问题_第4张图片
如果想删除编号为 2 的节点,cur 引用必须指向 1,这样才能将 1 的 next 引用从原来的 2 指向 3:
数据结构与算法之约瑟夫问题_第5张图片
所以,在找报数的起始位置时,应当从起始位置的上一个位置开始计数,这样当寻找到待移除节点时,实际上是定位到了待移除节点的上一个节点。寻找报数起始位置的代码如下(代码中 start 变量就是参数 k):

//寻找开始报数的节点(这里从 tail 开始遍历,取报数节点的上一个节点,因为单向链表的节点删除必须依赖上一个节点)
Node tmp = tail;
	int startIndex = 0;
	while (startIndex++ != size) {
		if (start == startIndex) {
			break;
		}
		tmp = tmp.next;
	}

找到了报数起始位置后,就要开始执行报数的操作,移除节点时需要注意,当链表中的节点数量只剩一个时,无需操作节点的 next 引用,直接将节点置空即可。
报数出圈的代码如下(代码中 step 变量就是参数 m):

//保存顺序出链的节点
List list = new ArrayList<>(size);

//开始计数,数到指定间隔后节点出链
int count = 1;
while (size > 1) {
	if (count == step) {
		//节点出链
		//1.定义一个引用,指向待删除节点
		Node delNode = tmp.next;
		//2.将当前节点的 next 引用指向待删除节点的下一个节点
		tmp.next = delNode.next;
		//3.链表长度-1
		size--;
		//4.置空待删除节点的 next 引用
		delNode.next = null;
		//5.保存已删除节点
		list.add(delNode);
		//6.重置计数器
		count = 1;
	} else {
		//继续循环计数
		tmp = tmp.next;
		count++;
	}
}

//链表只剩一个节点时,不需要操作next指针删除节点,直接将头尾置空
tmp.next = null;
head = null;
tail = null;
size = 0;
list.add(tmp);

注意,在移除节点后,必须要保证链表仍然成环,移除步骤分解如下(假设链表剩 3 个节点,要移出编号为 3 的节点):

1.Node delNode = tmp.next
数据结构与算法之约瑟夫问题_第6张图片
2.tmp.next = delNode.next
数据结构与算法之约瑟夫问题_第7张图片
3.delNode.next = null
数据结构与算法之约瑟夫问题_第8张图片

报数出圈的完整代码如下:

	/**
	 * 从 start 位置开始,每隔 step 后节点出链
	 *
	 * @param start 报数起始位置
	 * @param step 报数出圈间隔
	 * @return 依次出链的节点列表
	 */
	public List poll(int start, int step) {
		if (start <= 0 || start > size) {
			throw new RuntimeException("起始位置需大于0并且小于等于链表长度");
		}
		if (step <= 0 || step > size) {
			throw new RuntimeException("间隔需大于0");
		}
		if (size == 0) {
			return Collections.emptyList();
		}

		//寻找开始报数的节点(这里从 tail 开始遍历,取报数节点的上一个节点,因为单向链表的节点删除必须依赖上一个节点)
		Node tmp = tail;
		int startIndex = 0;
		while (startIndex++ != size) {
			if (start == startIndex) {
				break;
			}
			tmp = tmp.next;
		}

		//保存顺序出链的节点
		List list = new ArrayList<>(size);

		//开始计数,数到指定间隔后节点出链
		int count = 1;
		while (size > 1) {
			if (count == step) {
				//节点出链
				//1.定义一个引用,指向待删除节点
				Node delNode = tmp.next;
				//2.将当前节点的 next 引用指向待删除节点的下一个节点
				tmp.next = delNode.next;
				//3.链表长度-1
				size--;
				//4.置空待删除节点的 next 引用
				delNode.next = null;
				//5.保存已删除节点
				list.add(delNode);
				//6.重置计数器
				count = 1;
			} else {
				//继续循环计数
				tmp = tmp.next;
				count++;
			}
		}

		//链表只剩一个节点时,不需要操作next指针删除节点,直接将头尾置空
		tmp.next = null;
		head = null;
		tail = null;
		size = 0;
		list.add(tmp);

		return list;
	}

对上述代码进行测试:

//n: 圈内人数, k: 报数的起始位置, m: 报数出队的间隔
int n = 10;
int k = 2;
int m = 3;
			
List pollList = singleCycleLinkedList.poll(k, m);
System.out.printf("size: %d, start: %d, step: %d\n", n, k, m);
System.out.println(pollList.stream().map(node -> node.no).collect(Collectors.toList()));

结果如下:

size: 10, start: 2, step: 3
[4, 7, 10, 3, 8, 2, 9, 6, 1, 5]

数据验证

当 n = 10, k = 2, m = 3 时,节点移除的分解步骤如下:

完整节点:Node{no=1}, Node{no=2}, Node{no=3}, Node{no=4}, Node{no=5}, Node{no=6}, Node{no=7}, Node{no=8}, Node{no=9}, Node{no=10}

4 出圈:Node{no=1}, Node{no=2}, Node{no=3}, Node{no=5}, Node{no=6}, Node{no=7}, Node{no=8}, Node{no=9}, Node{no=10}

7 出圈:Node{no=1}, Node{no=2}, Node{no=3}, Node{no=5}, Node{no=6}, Node{no=8}, Node{no=9}, Node{no=10}

10 出圈:Node{no=1}, Node{no=2}, Node{no=3}, Node{no=5}, Node{no=6}, Node{no=8}, Node{no=9}

3 出圈:Node{no=1}, Node{no=2}, Node{no=5}, Node{no=6}, Node{no=8}, Node{no=9}

8 出圈:Node{no=1}, Node{no=2}, Node{no=5}, Node{no=6}, Node{no=9}

2 出圈:Node{no=1}, Node{no=5}, Node{no=6}, Node{no=9}

9 出圈:Node{no=1}, Node{no=5}, Node{no=6}

6 出圈:Node{no=1}, Node{no=5}

1 出圈:Node{no=5}

5 出圈

出圈顺序依次为: [4, 7, 10, 3, 8, 2, 9, 6, 1, 5]。与结果一致。

你可能感兴趣的:(数据结构与算法之约瑟夫问题)