C++ 我应该使用哪个数据集？

标题可能有点含糊不清，但我希望能为我目前的问题提供一些想法

以下是一个数据集：

1   1/1/2013
2   1/1/2013
3   1/1/2013
1   1/2/2013
2   1/2/2013
1   1/3/2013
2   1/3/2013
3   1/3/2013

因此，我从第一条记录开始，看看列表中是否还有另外一条1。如果有，我忽略它，返回第二条记录。如果我的列表中还有2条，我会忽略它，然后返回第3条记录，依此类推

现在，我正在寻找的这个列表的期望结果是，因为在它下面不存在其他记录1

同样，在此数据集中：

1   1/1/2013
2   1/1/2013
3   1/1/2013
1   1/2/2013
2   1/2/2013
3   1/2/2013
4   1/2/2013
1   1/3/2013
2   1/3/2013
3   1/3/2013

期望的结果是，因为列表中没有其他出现的4

我的问题是，我该怎么做，我可以使用什么标准STL容器？此外，这些是查询返回的结果

---

很抱歉，我没有使用boost或任何其他库，并且希望通过std变量完成这项工作

您可以从底部进行检查，并记住每个索引的第一个（从顶部计数时的最后一个）外观。完成后（在时间O（n）内），您可以取最后一个找到的索引。

您可以从底部检查，并记住每个索引的第一个（从顶部计数时的最后一个）外观。完成后（在时间O（n）内），您可以取最后一个找到的索引。

您可以从底部检查，并记住每个索引的第一个（从顶部计数时的最后一个）外观。完成后（在时间O（n）内），您可以取最后一个找到的索引。

您可以从底部检查，并记住每个索引的第一个（从顶部计数时的最后一个）外观。完成此操作后（时间O（n）），您可以使用最后一个找到的映射。

您可以使用两个映射-一个映射存储从键（第一列）到值（第二列）的映射，另一个映射存储从键（第一列）到记录号的映射：

std::map<int, std::string> m1;
std::map<int, int> m2;

int counter = 0;
while (...)
{
  <...get record...>
  m1[record.key] = record.value;
  m2[record.key] = counter++;
}

std:：map m1；
std：：map m2；
int计数器=0；
而（…）
{
m1[记录.键]=记录.值；
m2[记录键]=计数器++；
}

然后，您需要扫描第二张地图m2，以找到具有最小位置的钥匙：

int keyMin = <...big number...>, posMin = <...big number...>;
for (std::map<int, int>::const_iterator it = m2.begin(); it != m2.end(); ++it)
{
  if (it->second < posMin)
  {
    keyMin = it->first;
    posMin = it->second;
  }
}

int-keyMin=，posMin=；
对于（std:：map:：const_迭代器it=m2.begin（）；it！=m2.end（）；+it）
{
if（it->secondfirst；
posMin=it->second；
}
}

---

结果将是第一个键，在此过程中没有使用此键的记录。使用此键和第一个贴图m1可以找到其对应的值

您可以使用两个映射—一个映射用于存储从键（第一列）到值（第二列）的映射，另一个映射用于存储从键（第一列）到记录号的映射：

std::map<int, std::string> m1;
std::map<int, int> m2;

int counter = 0;
while (...)
{
  <...get record...>
  m1[record.key] = record.value;
  m2[record.key] = counter++;
}

std:：map m1；
std：：map m2；
int计数器=0；
而（…）
{
m1[记录.键]=记录.值；
m2[记录键]=计数器++；
}

然后，您需要扫描第二张地图m2，以找到具有最小位置的钥匙：

int keyMin = <...big number...>, posMin = <...big number...>;
for (std::map<int, int>::const_iterator it = m2.begin(); it != m2.end(); ++it)
{
  if (it->second < posMin)
  {
    keyMin = it->first;
    posMin = it->second;
  }
}

int-keyMin=，posMin=；
对于（std:：map:：const_迭代器it=m2.begin（）；it！=m2.end（）；+it）
{
if（it->secondfirst；
posMin=it->second；
}
}

---

结果将是第一个键，在此过程中没有使用此键的记录。使用此键和第一个贴图m1可以找到其对应的值

您可以使用两个映射—一个映射用于存储从键（第一列）到值（第二列）的映射，另一个映射用于存储从键（第一列）到记录号的映射：

std::map<int, std::string> m1;
std::map<int, int> m2;

int counter = 0;
while (...)
{
  <...get record...>
  m1[record.key] = record.value;
  m2[record.key] = counter++;
}

std:：map m1；
std：：map m2；
int计数器=0；
而（…）
{
m1[记录.键]=记录.值；
m2[记录键]=计数器++；
}

然后，您需要扫描第二张地图m2，以找到具有最小位置的钥匙：

int keyMin = <...big number...>, posMin = <...big number...>;
for (std::map<int, int>::const_iterator it = m2.begin(); it != m2.end(); ++it)
{
  if (it->second < posMin)
  {
    keyMin = it->first;
    posMin = it->second;
  }
}

int-keyMin=，posMin=；
对于（std:：map:：const_迭代器it=m2.begin（）；it！=m2.end（）；+it）
{
if（it->secondfirst；
posMin=it->second；
}
}

---

结果将是第一个键，在此过程中没有使用此键的记录。使用此键和第一个贴图m1可以找到其对应的值

您可以使用两个映射—一个映射用于存储从键（第一列）到值（第二列）的映射，另一个映射用于存储从键（第一列）到记录号的映射：

std::map<int, std::string> m1;
std::map<int, int> m2;

int counter = 0;
while (...)
{
  <...get record...>
  m1[record.key] = record.value;
  m2[record.key] = counter++;
}

std:：map m1；
std：：map m2；
int计数器=0；
而（…）
{
m1[记录.键]=记录.值；
m2[记录键]=计数器++；
}

然后，您需要扫描第二张地图m2，以找到具有最小位置的钥匙：

int keyMin = <...big number...>, posMin = <...big number...>;
for (std::map<int, int>::const_iterator it = m2.begin(); it != m2.end(); ++it)
{
  if (it->second < posMin)
  {
    keyMin = it->first;
    posMin = it->second;
  }
}

int-keyMin=，posMin=；
对于（std:：map:：const_迭代器it=m2.begin（）；it！=m2.end（）；+it）
{
if（it->secondfirst；
posMin=it->second；
}
}

---

结果将是第一个键，在此过程中没有使用此键的记录。使用此键和第一个贴图m1可以找到其对应的值

查询返回什么？如果返回已知结构，则可以选择

std:：vector

；如果返回字符串列表，则可以选择

std:：vector

。

---

然后从底部开始，记住您看到的所有唯一ID，您就能够在o（n）时间和o（n）内存中获得最后一个正确的值。

查询返回什么？如果返回已知结构，则可以选择

std:：vector

；如果返回字符串列表，则可以选择

std:：vector

。

---

然后从底部开始，记住您看到的所有唯一ID，您就能够在o（n）时间和o（n）内存中获得最后一个正确的值。

查询返回什么？如果返回已知结构，则可以选择

std:：vector

；如果返回字符串列表，则可以选择

std:：vector

。 然后从底部开始，记住所有你看到的唯一ID，你就能得到o（n）中的最后一个好值