C++ 瓶颈c++；分类功能Wi-Fi信号

目前，我正在制作一个程序，使用RSSI估计WiFi设备坐标。该程序包含一个瓶颈

我尝试用其他函数替换字符串比较。那没有

全部功能：

std::list<std::list<wSignal*>> SignalGrouper::groupByMac (std::list<wSignal*> signals)
{
    std::list<std::list<wSignal*>> groupedSignals;
    std::list<wSignal*> doneSignals;
    for (std::list<wSignal*>::iterator it1=signals.begin(); it1 != signals.end(); ++it1) //take first signal
    {
        if(DoesSignalExist(doneSignals, *it1) == false) //check if signal is already been grouped
        {
            std::list<wSignal*> group;
            for (std::list<wSignal*>::iterator it2=signals.begin(); it2 != signals.end(); ++it2)
            {
                if(DoesSignalExist(doneSignals, *it2) == false)
                {
                    if(boost::iequals((*it2)->MAC, (*it1)->MAC))
                    {
                        group.push_back(*it2);
                        doneSignals.push_back(*it2);
                    }
                }
            }
            groupedSignals.push_back(group);
        }
    }
    return groupedSignals;
}

std:：list SignalGrouper:：groupByMac（std:：list signals）
{
std：：列出分组信号；
std：：列出doneSignals；
for（std:：list:：iterator it1=signals.begin（）；it1！=signals.end（）；++it1）//获取第一个信号
{
if（DoesSignalExist（doneSignals，*it1）=false）//检查信号是否已经分组
{
std：：列表组；
对于（std:：list:：iterator it2=signals.begin（）；it2！=signals.end（）；++it2）
{
if（DoesSignalExist（doneSignals，*it2）=false）
{
if（boost:：iequals（（*it2）->MAC，（*it1）->MAC））
{
组。推回（*it2）；
doneSignals.推回（*it2）；
}
}
}
分组信号。推回（组）；
}
}
返回分组信号；
}

试试看

试一试

---

我还怀疑字符串比较是否是真正的问题。但如果您坚持使用更快的方法来比较MAC字符串，您可以尝试反向比较，因为前缀（OUI）由IEEE提供给供应商，因此对于同一供应商总是相同的。

我也怀疑字符串比较是否是真正的问题。但是，如果您坚持使用更快的方法来比较MAC字符串，您可以尝试反向比较，因为前缀（OUI）由IEEE提供给供应商，因此对于同一供应商总是相同的。

不，没有更快的方法来直接比较两个任意字符串。内置方法是最快的方法

与当前的

O（n^2）

算法不同，您可以先在

O（n log n）

中对MAC列表进行排序（例如，将它们放入

std:：vector

中，然后使用

std:：sort

），然后在排序后的向量上运行一次迭代，将相邻的相等元素聚合成一个组列表（即

O（n）

，总体复杂度为

O（n log n）

）

---

由于要对大量Mac进行分组，像这样的算法复杂度变化很可能会导致比优化这一行更大的性能提高。

不，没有更快的方法直接比较两个任意字符串。内置方法是最快的方法

与当前的

O（n^2）

算法不同，您可以先在

O（n log n）

中对MAC列表进行排序（例如，将它们放入

std:：vector

中，然后使用

std:：sort

），然后在排序后的向量上运行一次迭代，将相邻的相等元素聚合成一个组列表（即

O（n）

，总体复杂度为

O（n log n）

）

---

由于要对大量Mac进行分组，像这样的算法复杂性变化很可能会导致比试图优化这一行更大的性能提升。

是否必须返回std:：list？否则，您可以使用如下std:：map来减少迭代步骤：

std::map<MAC, std::list<wSignal*>> SignalGrouper::groupByMac (std::list<wSignal*> signals)
{
    std::map<MAC, std::list<wSignal*>> groupedSignals;
    for (std::list<wSignal*>::iterator it1 = signals.begin(); it1 != signals.end(); ++it1) //take first signal
    {
        std::map<MAC, std::list<wSignal*>>::iterator it2 = groupedSignals.find((*it1)->MAC);
        if(it2 != groupedSignals.end()) {
            it->second.push_back(*it1);
        } else {
            groupedSignals[(*it1)->MAC] = (*it1);
        }
    }
    return groupedSignals;
}

std:：map SignalGrouper:：groupByMac（std:：list signals）
{
std:：map-groupedSignals；
for（std:：list:：iterator it1=signals.begin（）；it1！=signals.end（）；++it1）//获取第一个信号
{
std:：map:：iterator it2=groupedSignals.find（（*it1）->MAC）；
if（it2！=groupedSignals.end（））{
它->秒。推回（*it1）；
}否则{
分组信号[（*it1）->MAC]=（*it1）；
}
}
返回分组信号；
}

---

未测试，但应该可以这样工作。

必须返回std:：list吗？否则，您可以使用如下std:：map来减少迭代步骤：

std::map<MAC, std::list<wSignal*>> SignalGrouper::groupByMac (std::list<wSignal*> signals)
{
    std::map<MAC, std::list<wSignal*>> groupedSignals;
    for (std::list<wSignal*>::iterator it1 = signals.begin(); it1 != signals.end(); ++it1) //take first signal
    {
        std::map<MAC, std::list<wSignal*>>::iterator it2 = groupedSignals.find((*it1)->MAC);
        if(it2 != groupedSignals.end()) {
            it->second.push_back(*it1);
        } else {
            groupedSignals[(*it1)->MAC] = (*it1);
        }
    }
    return groupedSignals;
}

std:：map SignalGrouper:：groupByMac（std:：list signals）
{
std:：map-groupedSignals；
for（std:：list:：iterator it1=signals.begin（）；it1！=signals.end（）；++it1）//获取第一个信号
{
std:：map:：iterator it2=groupedSignals.find（（*it1）->MAC）；
if（it2！=groupedSignals.end（））{
它->秒。推回（*it1）；
}否则{
分组信号[（*it1）->MAC]=（*it1）；
}
}
返回分组信号；
}

---

未经测试，但应能正常工作。

您如何确定这是瓶颈？是堆栈跟踪的统计采样吗？因为如果有数十亿个字符串，那么代码自然会在

（*it2）->MAC==（*it1）->MAC

中花费大量时间。你没有比专用功能更高效的了。你一份一份地传递你的列表？！您可以通过MAC对信号进行

排序

，将算法复杂性从O（N²）降低到

O（N logN）

。链表是最高估的数据结构。由于MAC地址正好是6个字节，您可以使用

uint64\u t

来存储和比较项目。您如何确定它是瓶颈？是堆栈跟踪的统计采样吗？因为如果有数十亿个字符串，那么代码自然会在

（*it2）->MAC==（*it1）->MAC

中花费大量时间。你没有比专用功能更高效的了。你一份一份地传递你的列表？！您可以通过MAC对信号进行

排序

以将算法的复杂性从O（N²）降低到

O（N logN）

。链表是最高估的数据结构。由于MAC地址正好是6个字节，您可以使用

uint64\u t

来存储和比较项目。像这样改进字符串比较是行不通的。有没有其他的瓶颈可能在哪里的建议？在这个函数中，我试图将一个std:：list排序为更小的std:：list，其中所有信号都具有相同的MAC。我希望这些较小的列表包含在一个列表中：std:：list这样改进字符串比较是行不通的。还有其他建议吗

std::map<MAC, std::list<wSignal*>> SignalGrouper::groupByMac (std::list<wSignal*> signals)
{
    std::map<MAC, std::list<wSignal*>> groupedSignals;
    for (std::list<wSignal*>::iterator it1 = signals.begin(); it1 != signals.end(); ++it1) //take first signal
    {
        std::map<MAC, std::list<wSignal*>>::iterator it2 = groupedSignals.find((*it1)->MAC);
        if(it2 != groupedSignals.end()) {
            it->second.push_back(*it1);
        } else {
            groupedSignals[(*it1)->MAC] = (*it1);
        }
    }
    return groupedSignals;
}