本文探讨了如何解决一个经典的列表元素重排序问题，即从一个环形排列的元素集合中，按照固定步长依次取出元素并形成新的序列。通过详细分析其核心逻辑，我们揭示了使用模运算来处理环形遍历和列表动态缩减的关键技巧，并提供了完整的Java实现代码，帮助读者理解并掌握此类问题的解决方案。
问题描述
假设有一个圆桌上摆放着 numberOfDishes 盘菜，编号从 1 到 numberOfDishes，按升序排列。一个人希望按照以下规则品尝所有的菜肴：他将每隔 everyDishNumberToEat 个盘子吃一个，直到所有的盘子都被吃完。我们需要确定这些盘子被吃掉的顺序。
输入示例：
- numberOfDishes = 10 (总盘数)
- everyDishNumberToEat = 3 (每隔多少个盘子吃一个)
初始盘子序列：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
期望输出：[3, 6, 9, 2, 7, 1, 8, 5, 10, 4]
核心逻辑与算法分析
解决这类问题，关键在于正确处理“环形”遍历和列表元素动态移除后的索引变化。
- 初始化列表： 首先，我们需要一个可变的列表来存储所有的盘子编号。由于元素需要频繁地移除，LinkedList 是一个合适的选择，因为它在中间位置移除元素的效率较高。
- 确定步长： 如果我们说“每隔 everyDishNumberToEat 个盘子吃一个”，这意味着当前位置加上 everyDishNumberToEat - 1 才是下一个要移除的元素的索引。例如，如果 everyDishNumberToEat 是 3，从索引 0 开始，我们要吃的是索引 2 的盘子（1, 2, 3），所以步长是 3 - 1 = 2。
-
环形遍历与索引更新： 随着元素的移除，列表的尺寸会不断减小。为了模拟环形遍历，我们需要使用模运算符 (%) 来计算下一个要移除的元素的索引。每次计算新索引时，都应该基于当前列表的实时大小。
- 当前索引 i
- 步长 step = everyDishNumberToEat - 1
- 新的索引 i = (i + step) % dishes.size()
- 这里 dishes.size() 是当前列表中剩余元素的数量。
- 循环终止条件： 整个过程需要持续进行，直到所有的盘子都被吃完。因此，一个 while 循环，条件为列表不为空 (!dishes.isEmpty())，是比固定次数的 for 循环更合适的选择。在每次迭代中，我们移除一个元素并将其添加到结果列表中。
Java 实现
根据上述逻辑，我们可以构建如下的 Java 方法来实现盘子排序：
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
public class DishOrderDeterminer {
/**
* 根据指定规则确定盘子的食用顺序。
*
* @param numberOfDishes 盘子的总数量，从1开始编号。
* @param everyDishNumberToEat 每隔多少个盘子吃一个。
* @return 盘子被吃掉的顺序列表。
*/
public static List<Integer> determineDishOrder(int numberOfDishes, int everyDishNumberToEat) {
// 使用LinkedList存储待处理的盘子，便于高效移除中间元素
List<Integer> dishes = new LinkedList<>();
// 使用ArrayList存储结果，记录盘子被吃掉的顺序
List<Integer> result = new ArrayList<>();
// 初始化盘子列表，编号从1到numberOfDishes
for (int i = 1; i <= numberOfDishes; i++) {
dishes.add(i);
}
// 计算实际的步长，因为"每隔N个"意味着跳过N-1个
int step = everyDishNumberToEat - 1;
// 当前要移除的元素的起始索引
int currentIndex = 0;
// 当盘子列表不为空时，继续移除
while (!dishes.isEmpty()) {
// 计算下一个要移除的元素的索引
// (currentIndex + step) 确保了环形前进
// % dishes.size() 确保索引不会超出当前列表的范围，实现环绕
currentIndex = (currentIndex + step) % dishes.size();
// 移除当前索引处的盘子
int eatenDish = dishes.remove(currentIndex);
// 将被移除的盘子添加到结果列表中
result.add(eatenDish);
}
return result;
}
public static void main(String[] args) {
// 示例用法
int numberOfDishes = 10;
int everyDishNumberToEat = 3;
List<Integer> order = determineDishOrder(numberOfDishes, everyDishNumberToEat);
System.out.println("盘子食用顺序: " + order); // 期望输出: [3, 6, 9, 2, 7, 1, 8, 5, 10, 4]
numberOfDishes = 7;
everyDishNumberToEat = 2;
order = determineDishOrder(numberOfDishes, everyDishNumberToEat);
System.out.println("盘子食用顺序 (7, 2): " + order); // 期望输出: [2, 4, 6, 1, 5, 3, 7]
}
}运行结果
对于 numberOfDishes = 10 和 everyDishNumberToEat = 3 的输入，程序将输出：
盘子食用顺序: [3, 6, 9, 2, 7, 1, 8, 5, 10, 4]
这与我们期望的输出完全一致。
注意事项与总结
- 选择合适的数据结构： 在需要频繁进行中间元素移除操作的场景下，LinkedList 通常比 ArrayList 具有更好的性能，因为它不需要移动大量元素。
- 步长的理解： "每隔 N 个"通常意味着从当前位置开始数，第 N 个元素是目标，即索引前进 N-1。
- 模运算的重要性： 模运算符 (%) 是实现环形遍历和处理列表动态大小变化的关键。它确保了计算出的索引始终在当前列表的有效范围内。
- 循环终止条件： 确保循环在所有元素都被处理完毕后才终止，通常通过检查列表是否为空来实现。
通过掌握这些核心概念和实现技巧，您可以有效地解决此类基于环形遍历和元素移除的序列重排问题。
