时间戳

首页 > 解决方案 > 递归列表处理似乎正在更改更高级别的列表

c# - 递归列表处理似乎正在更改更高级别的列表

问题描述

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

所以我们有一个球员名单

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

从列表中删除

发送剩余列表以再次处理

如果最后一对不能玩，递归应该展开并且第一个玩家与下一个他们没有玩过的玩家匹配，然后我们再去。

似乎正在发生的事情是原始列表（玩家）与通过递归调用发送的截断列表一起改变大小。

因此，当递归展开时，列表参与者减少到 2 个项目，而不是预期的 4 或 6 个。这就像列表是通过引用而不是通过值传递的。

有什么想法吗？

编辑***

与其说是通过引用传递的列表，不如说是每次调用程序时都会更改列表（玩家），所以我们最终使用了递归展开时 2 名玩家 ***

我把整个代码推到了这里（连同测试列表设置代码）

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;
        }
    }
}

标签： c#recursiontail-recursion

解决方案

这是你的问题：

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];

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

推荐阅读