C++ 用于存储和搜索比赛结果的数据结构

有100名玩家p1，p2。。。。。。p100，每个玩家对其他玩家进行一场比赛。您必须存储每个组合（Pi，Pj）的获胜者的匹配结果

---

< >我应该用什么样的数据结构来有效地存储和搜索结果？

你考虑了二维数组吗？如果你只需要存储结果，那么我认为这将是最好的选择。

< P>你考虑了二维数组吗？如果您只需要存储结果，那么我认为它将是最佳选择。

请查看关联容器，例如。这些允许您使用对数查找时间存储键值对。你可以考虑一个索引对类对象的映射，这样你就可以搜索结果：

int result = myMap[PairLikeType(i,j)];

其中，

i

和

j

是两个参与者的指数

std:：map

实现为二进制搜索树，但也有基于哈希表的映射，例如C++11（可在

tr1/unordered_-map

中获得，至少在gcc上），或

boost:：hash_-map

您可以通过定义自己的索引对（或使用

std:：pair

，其中提供了小于比较）作为映射的键来实现这一点，并且可以使用允许您检查的访问器方法将其封装在类中，给定一对索引：

struct ResultMap {
  int winnerID(int playerID1, int playerID2)
  {
    return m_map[std::make_pair(playerID1, playerID2)]; // or use map::find
                                                        // of you want to handle
                                                        // non-existent keys specially
  }
 private:
  std::map<std::pair<int,int>, int> m_map;
};

struct ResultMap{
int winnerID（int playerID1，int playerID2）
{
返回m_map[std:：make_pair（playerID1，playerID2）]；//或使用map:：find
//你想处理什么
//不存在的密钥
}
私人：
std：：map mu map；
};

---

您可以使用

std:：unordered_map

实现上述功能，但是您必须为

std:：pair

提供自己的哈希函数。请查看关联容器，例如。这些允许您使用对数查找时间存储键值对。你可以考虑一个索引对类对象的映射，这样你就可以搜索结果：

int result = myMap[PairLikeType(i,j)];

其中，

i

和

j

是两个参与者的指数

std:：map

实现为二进制搜索树，但也有基于哈希表的映射，例如C++11（可在

tr1/unordered_-map

中获得，至少在gcc上），或

boost:：hash_-map

您可以通过定义自己的索引对（或使用

std:：pair

，其中提供了小于比较）作为映射的键来实现这一点，并且可以使用允许您检查的访问器方法将其封装在类中，给定一对索引：

struct ResultMap {
  int winnerID(int playerID1, int playerID2)
  {
    return m_map[std::make_pair(playerID1, playerID2)]; // or use map::find
                                                        // of you want to handle
                                                        // non-existent keys specially
  }
 private:
  std::map<std::pair<int,int>, int> m_map;
};

struct ResultMap{
int winnerID（int playerID1，int playerID2）
{
返回m_map[std:：make_pair（playerID1，playerID2）]；//或使用map:：find
//你想处理什么
//不存在的密钥
}
私人：
std：：map mu map；
};

您可以使用

std:：unordered_map

实现上述功能，但您必须为

std:：pair

提供自己的哈希函数，以100x100数组为例

在每个位置存储赢家

    p1 p2 p3  
 p1 0  p2 p1  
 p2 p2 0  p3 
 p3 p1 p3 0

空间复杂度O（n^2）

存储和查询O（1）的时间复杂性以100x100阵列为例

在每个位置存储赢家

    p1 p2 p3  
 p1 0  p2 p1  
 p2 p2 0  p3 
 p3 p1 p3 0

空间复杂度O（n^2）

---

存储和查询O（1）的时间复杂度

我会使用具有智能函数的一维数组来计算索引

我将把数组构造为数据包数组：

0 
1  0
2  0 1
3  0 1 2
4  0 1 2 3 
//and so on

其中第一列对应于

i

player。raw对应于可以玩i的

j

玩家

以下是阵列在内存中的外观：

|0 | 01 | 01 | 01 | 01 | 01 |

/0,1-bool结果

下面是计算索引的函数。（它会犯一些错误，比如必须在某个索引中添加1，但通常是正确的）

intindex（inti，intj）//i=[0,99]，j=[0,99]
{
断言（i！=j）；
if（i

在这种情况下，除了所需的数据（4950项）外，没有其他存储内容

---

此解决方案的思想类似于2d数组，但不存储重复项和带有self结果的self。

我将使用具有智能函数的一维数组来计算索引

我将把数组构造为数据包数组：

0 
1  0
2  0 1
3  0 1 2
4  0 1 2 3 
//and so on

其中第一列对应于

i

player。raw对应于可以玩i的

j

玩家

以下是阵列在内存中的外观：

|0 | 01 | 01 | 01 | 01 | 01 |

/0,1-bool结果

下面是计算索引的函数。（它会犯一些错误，比如必须在某个索引中添加1，但通常是正确的）

intindex（inti，intj）//i=[0,99]，j=[0,99]
{
断言（i！=j）；
if（i

在这种情况下，除了所需的数据（4950项）外，没有其他存储内容

---

此解决方案的思想类似于2d数组，但不存储重复项和带有自我结果的自我。

您将使用什么数据结构？@Andrew我正在考虑某种散列方法，以便在访问我要查找的元素时，至少必须通过n/10（这里的n是4950）或更少的元素。使用p的映射