递归列表处理似乎正在更高级别上更改列表

Question

我正在尝试编写一个竞争配对算法，以避免与同一玩家玩两次

所以我们有一份球员名单

我们先拿第一个玩家，然后是他们没有玩过的第一个玩家

从列表中删除

发送要再次处理的剩余列表

如果最后一对不能上场，递归应该展开，第一个球员与下一个他们没有上场的球员匹配，然后我们再离开。

似乎正在发生的是，原始列表(播放器(的大小随着通过递归调用发送的截断列表而变化。

因此，当重新分配取消时，列表玩家将减少到2项，而不是预期的4或6项。这就像列表是通过引用而不是通过值传递的。

有什么想法吗？

编辑***

与其说列表是通过引用传递的，不如说列表(参与者(在每次调用过程时都会发生变化，所以当递归解开***时，我们最终会使用2个参与者的列表来完成过程的第一次迭代(应该有6个参与者的表表(

我把整个代码放在这里(连同测试列表设置代码(

using System;
using System.Collections.Generic;
using System.Runtime.ConstrainedExecution;
namespace CPair
{
class Program
{
static void Main(string[] args)
{
//create players
List<int> alist = new List<int>() { 2 };
var a = new Player(1, "a", "wk", alist, 10);
List<int> blist = new List<int>() { 1 };
var b = new Player(2, "b", "wa", blist, 9);
List<int> clist = new List<int>() {  };
var c = new Player(3, "c", "bc", clist, 8);
List<int> dlist = new List<int>() {  };
var d = new Player(4, "d", "wk", dlist, 7);
List<int> elist = new List<int>() {  };
var e = new Player(5, "e", "bc", elist, 5);
List<int> flist = new List<int>() {  };
var f = new Player(6, "f", "ab", flist, 3);
List<Player> PlayList = new List<Player>();
PlayList.Add(a);
PlayList.Add(b);
PlayList.Add(c);
PlayList.Add(d);
PlayList.Add(e);
PlayList.Add(f);
PlayList.Sort((p, q) => p.Points.CompareTo(q.Points));
foreach (Player p in PlayList)
{
Console.WriteLine(p.PlayerName);
}
List<Player> paired = new List<Player>();
paired = pairing(PlayList);
foreach (Player r in paired)
{
Console.WriteLine(r.PlayerName);
}
}
static List<Player> pairing(List<Player> players)
{
List<Player> pairingList = new List<Player>();
int n = 1;
bool failed = true;
List<Player> returnedList = new List<Player>();
while ((failed) && n <= players.Count - 1)
{
if (PairIsGood(players[0], players[n], 0))
{
Player p1 = new Player();
p1 = players[0];
Player p2 = new Player();
p2 = players[n];
if (players.Count <= 2)
{
returnedList.Add(p1);
returnedList.Add(p2);
failed = false;
}
else
{
List<Player> nextPairs = new List<Player>();
nextPairs = players;
nextPairs.RemoveAt(0);
nextPairs.RemoveAt(n-1);
returnedList = pairing(nextPairs);
Console.WriteLine(players.Count.ToString());
Console.WriteLine(nextPairs.Count.ToString());
if (returnedList.Count == 0)
{
failed = true;
n++;
}
else
{
returnedList.Add(p1);
returnedList.Add(p2);
failed = false;
}
}
}
else
{
n++;
}
} 
return returnedList;
}
static bool PairIsGood(Player p1, Player p2, int round)
{
bool good = true;
foreach (int op in p1.OpList)
{
if (op == p2.PlayerID)
{
good = false;
}
}
return good;
}
}
}

Answer 1

这是您的问题：

List<Player> nextPairs = new List<Player>();
nextPairs = players;
nextPairs.RemoveAt(0);
nextPairs.RemoveAt(n-1);

您创建一个新的List<Player>并将其分配给nextPairs

然后，您可以有效地丢弃新列表，而将nextPairs分配给players。

nextPairs和players现在都引用相同的列表，从nextPairs中删除也将从players中删除，因为它们是相同的列表。

如果您想要一个真正独立的副本，请查看Array.Copy()。

顺便说一句，我看到你在这里做同样的冗余创建模式：

Player p1 = new Player();
p1 = players[0];
Player p2 = new Player();
p2 = players[n];

这应该只是

Player p1 = players[0];
Player p2 = players[n];

我怀疑你需要阅读一些关于对象和引用以及它们是如何工作的。