Question

我对此有疑问;

我有一个类似的课程

class myCLass {
    private:
        string name;
        float value;
    public:
        float getValue();
};

我有超过1,000,000个对象，我必须根据其值对这些项进行排序。所以我创建了指针列表;

list<myClass *> objectList;

然后用超过1.000.000个对象填充它。现在你可以说矢量是最好的方法，如果你的对象小于30-40位，那绝对是真的，那么我就创造了它;

bool ec(myClass *s1, myClass *s2) 
{
    return (s1->getValue() < s2->getValue());
}

然后在main函数中;

time = clock();
objectList.sort(ec);    // Sort with STL.
time = clock() - time;
cout << ((float)time)/CLOCKS_PER_SEC << "\t:time to sort" << endl;

只需1.2秒！这对我来说是不可思议的，并记住它是列表容器，这是最慢的方式可能是矢量可以更有效:)无论如何我的问题是我写了一个insertSort和mergeSort算法，如果有人使用我的排序算法，如果他/他想要缩短100万个对象需要3个小时，是3小时:)我想知道为什么它更多。并且我使用通用算法进行合并和插入并不是不同的东西，他们计算真实的结果。例如我的insertSort（）就像那样;

void sort::insertionSort(list<myClass *> &normalList, list<myClass *> &sortedList){

    list<myClass*>::iterator sortedIterator;

    sortedList.clear();
    iter = normalList.begin(); // iter describing on constructor
    sortedList.push_back(*iter);
    iter++;

    for(; iter != normalList.end(); iter++){

        sortedIterator = (--sortedList.end());

        while( (*iter)->getValue() < (*sortedIterator)->getValue() && sortedIterator!=(--sortedList.begin() ) ){
        sortedIterator--;
        }
        sortedList.insert(++sortedIterator,*iter);
    }
}

我的insertionSort（）;

的基准表

n=10      => 0      second;
n=100     => 0      second;
n=1.000   => 0      second;
n=10.000  => 0.96   second;
n=20.000  => 4.73   seconds;
n=50.000  => 34.22  seconds;
n=100.000 => 306.62 seconds

我无法控制超过100.000：）

这是正常还是我有错？

注意：我尝试使用vector进行插入排序，而n = 100.000时间是50秒，所以尽管n = 100.000不是1.000.000仍然无法达到1.29秒：）

注2：这是mergeSort（）;

的基准

n=10      => 0      second;
n=100     => 0      second;
n=1.000   => 0.02      second;
n=10.000  => 0.8   second;
n=20.000  => 3.07   seconds;
n=50.000  => 21.7  seconds;
n=100.000 => 106.73 seconds

Answer 1

插入排序渐远比内置算法慢。虽然插入排序的复杂度为O(n^2)，但内置算法的标准复杂度为O(n*log(n))。因此，与内置排序算法相比，您拥有的元素越多，算法就越慢。

实现自己的排序算法几乎不值得，因为内置实现已经非常优化。

Answer 2

算法理论告诉您插入排序的复杂度为 O（n ²），而快速排序的复杂度为 O（n log（n））< / strong>即可。对于大型数据集，这是一个重大差异;松散地说，你的算法将 n / log（n）慢一点。

当你考虑采用数字的对数的效果时，这种差异会变得巨大：如果你以宇宙中粒子数的对数10为基数，那么答案就是87.

Answer 3

您的版本基本上是将排序列表构建为新的名单。虽然你只是复制指针，但你仍然在做每个节点的新分配等。大概是会员函数排序永远不会创建或删除节点;它运作更改现有节点之间的指针。（而且当然，没有插入排序;这将是一个纯粹的合并排序。）

列表排序（）与自己的排序（）时差

3 个答案: