Javascript 防止两名球员在瑞士式锦标赛中两次对决

我目前正试图设计一个简单的生成器，作为一种使用jquery并满足我自己好奇心的方法。然而，我遇到了一些障碍

我已经建立了一个算法，可以在回合结束时根据赢、平和输的数量对玩家进行排序，但是我需要一些方法来防止玩家与同一个对手进行两次比赛

目前，玩家存储在一个数组中，偶数玩家与奇数玩家匹配（例如，

playersarray[0]

vs

playersarray[1]

，

playersarray[2]

vs

playersarray[3]

等）。数组中的每个玩家都是和具有以下属性的对象：

name

、

win

、

draw

、

loss

、

lostGame

（用于确定谁输了，两个都输了是draw>），以及

hasplay

（存储他们已按姓名匹配的人）

这是我目前的排序算法：

//---SORTING ARRAYS----
//Danish Style (Players can play the same Player twice)
//Sort loss to bottom
playersArray.sort(function(a,b){
    return parseFloat(a.loss) - parseFloat(b.loss);    
});
//Sort Draw to top
playersArray.sort(function(a,b){
    return parseFloat(b.draw) - parseFloat(a.draw);    
});
//Sort with wins on top
playersArray.sort(function(a,b){
    return parseFloat(b.win) - parseFloat(a.win);    
});
//Swiss Style (make it so Players can't play the same opponet twice)
for(var j = 0; j < playersArray.length; j +=2){
    if($.inArray(playersArray[j].name, playersArray[j+1].haveplayed) != -1){
        var tempI = playersArray[j];
        playersArray[j] = playersArray[j-1];
        playersArray[j-1] = tempI;
        console.log("Matched!");

    }
}

/---排序数组----
//丹麦风格（玩家可以同一玩家玩两次）
//将损失分类到底
playerArray.sort（函数（a，b）{
返回parseFloat（a.损失）-parseFloat（b.损失）；
});
//排序到顶部
playerArray.sort（函数（a，b）{
返回parseFloat（b.draw）-parseFloat（a.draw）；
});
//以胜利为先进行排序
playerArray.sort（函数（a，b）{
返回parseFloat（b.win）-parseFloat（a.win）；
});
//瑞士风格（让玩家不能玩同一个对手两次）
对于（变量j=0；j

我现在的解决方案非常糟糕，因为它只是把玩家换成一个，如果位置0和1的玩家匹配，它就不起作用了

---

如果能了解我如何解决这个问题，我将不胜感激，因为这对我来说似乎是一个很大的难题。

首先，我不一定要比较赢/平/输计数，而是比较一个总体分数：

赢+1，平局+0，输-1

一般分数还有一个好处，即在检查“结束分数”规则时，您可以更轻松地完成以下操作：

在随后的几轮比赛中，每个参赛者面对一个累积得分相同或几乎相同的对手

接下来，我会把代码分解一下，但这是我个人的偏好。如果你有一个快速的小算法总是很好的，但是从长远来看，它会损害可读性并使事情复杂化。为什么不在玩家实例中存储过去的比赛，并检查两个玩家是否已经进行过比赛（甚至存储结果）

我写了一个小例子，把它分解成更清晰的部分（比赛和球员）。当然，这可以进一步优化和缩短，但它主要是以这种方式写出来的，让您对每一步都有一个清晰的了解。它基于提供的wiki页面上的规则

同时，

while（…）

循环贯穿了锦标赛的每一轮：每一轮，所有玩家都会相互检查，直到我们达到一个点，即不允许任何玩家与任何其他玩家比赛。比赛到此结束，我们可以根据得分对球员进行排序

编辑（2）：只是为了更好地可视化我用

继续

和

中断

关键字的解释，因为在注释中很难做到：（请记住，这只是用于演示目的的伪代码。）

继续

for( loop A ) {
    for( loop B ) {
         continue; // just skip to the end of loop B, and go through loop B again!

         ... this stuff is skipped by continue ...

         END OF LOOP <- continue gets us here! loop A is unaffected
    }
}

for（循环A）{
for（循环B）{
continue；//只需跳到循环B的末尾，然后再次通过循环B！
…此内容被“继续”跳过。。。
循环结束首先，我不一定要比较赢/平/输计数，而是比较一般分数：

赢+1，平局+0，输-1

一般分数还有一个好处，即在检查“结束分数”规则时，您可以更轻松地完成以下操作：

在随后的几轮比赛中，每个参赛者面对一个累积得分相同或几乎相同的对手

接下来，我将对代码进行一点分解-但这是个人偏好。如果你有一个快速的小算法，这总是很好的，但从长远来看，它会损害可读性并使事情复杂化。为什么不将过去的匹配存储在玩家实例中，并检查两个玩家是否已经进行了匹配（甚至存储了结果）

我写了一个小例子，将其分解为更清晰的组件（比赛和球员）。当然，这可以进一步优化和缩短，但它主要是以这种方式编写的，让您对每一步都有一个清晰的了解。它基于提供的wiki页面上的规则


同时，
while（…）
循环会在锦标赛的每一轮中进行：每一轮，所有玩家都会相互检查，直到我们达到一个不允许任何玩家与任何其他玩家比赛的点。此时锦标赛结束，我们可以根据分数对玩家列表进行排序

编辑（2）：只是为了更好地可视化我用
继续
和
中断
关键字的解释，因为在注释中很难做到：（请记住，这只是用于演示目的的伪代码。）

继续

for( loop A ) {
    for( loop B ) {
         continue; // just skip to the end of loop B, and go through loop B again!

         ... this stuff is skipped by continue ...

         END OF LOOP <- continue gets us here! loop A is unaffected
    }
}

for（循环A）{
for（循环B）{
continue；//只需跳到循环B的末尾，然后再次通过循环B！
…此内容被“继续”跳过。。。
循环结束首先，我不一定要比较赢/平/输计数，而是比较一般分数：

赢+1，平局+0，输-1

一般分数还有一个好处，即在检查“结束分数”规则时，您可以更轻松地完成以下操作：

在随后的几轮比赛中，每个选手都面对一个对手
for( loop A ) {
    for( loop B ) {
         continue; // just skip to the end of loop B, and go through loop B again!

         ... this stuff is skipped by continue ...

         END OF LOOP <- continue gets us here! loop A is unaffected
    }
}

for( loop A ) {
    for( loop B ) {
         break; // completly jump out of loop B!

         ... this stuff is skipped by break ...
    }
    <- break gets us here! loop B is broken out of, we just continue with the code in loop A

    ... stuff that is NOT skipped by break! ...
}