Question

我有多个对象，其字段名为＆＃34; num＆＃34;。 Num可以是1000000000到10000000005之间的任何数字。我想确保如果我有x个列表，所有列表需要根据＆＃34; num＆＃34;按顺序升序排列在array1中。属性。

如果我从这样的阵列开始＆＃34;

array1": [{item:23532532, num:1000000520},{item:23523, num:1000000620},{item:346346432, num:1000000620}]

我有第二个数组

"array2": [{item:23532, num:....},{item:3623, num:....}]

假设array2按＆＃34; num＆＃34;排序，是否更有效：

1）Add Then Sort Whole - 循环遍历＆＃34; array2＆＃34;并将其添加到＆＃34; array1＆＃34;的末尾，然后执行内置的javascript;排序＆＃34;功能在＆＃34; num＆＃34;整个阵列上的属性？

2）插入正确位置 - 循环遍历＆＃34; array2＆＃34;并使用＆＃34;如果＆＃34;条件检查以确定＆＃34; num＆＃34; value大于＆＃34; array2＆＃34;中的当前项，如果是，则通过＆＃34; splice＆＃34;在该索引之前插入元素。（没有使用javascript内置数组排序）

或者有更有效的方法吗？伪代码或示例代码是一个加号。

Answer 1

我在三种不同的浏览器中测量了三种不同算法的结果。

所有与绩效相关的问题都有两点：

如果您真的想知道答案，您必须在多个浏览器中测试您的特定算法才能真正回答这个问题。
许多与绩效相关的问题在使用它们的特定环境中实际上并不重要，所以担心它们直到你知道你需要担心它们只不过是时间浪费了对过早优化甚至不必要的优化。因此，在开展特定的绩效领域之前，您应该知道这很重要，并且知道值得花时间。

也就是说，这里有三种算法的测量。这假设您从两个对象数组开始，每个对象数组都由每个对象中存在的一个特定数字属性独立排序。

这是jsperf：http://jsperf.com/concat-sort-vs-insert-sort/5，它包含三种算法中的每种算法的代码。

算法1连接，然后对连接数组进行排序。在JS中，它只不过是：

var result = arr1.concat(arr2);
result.sort(sortByNum);

算法2尝试插入排序。基本思路是遍历第二个数组，并为该数组中的每个项找到将其插入第一个数组的位置。由于两个数组都已排序，我们只需要开始寻找一个位置，将下一个项插入到插入最后一个项之后的第一个数组中。

算法3是一种合并排序。这里的想法是创建一个空结果数组和两个索引，每个索引对应两个源数组。对于每个源索引处的值，您将结果推送到两个项中较低的项中，然后增加其源索引。当任一源索引耗尽时，您将推入其他数组的其余部分。我猜测它会比插入排序更有效，因为它不必将项目插入到数组的中间，只需添加到结尾，这可能是一个更快的操作。

为了运行测试，我创建了两个数组，每个数组包含100个对象。每个对象都有一个数字属性，分配一个0到100,000之间的随机数。然后对两个源阵列中的每一个进行预排序。然后在这两个源阵列上测试每个算法。

而且，结果如下：

enter image description here

以下是合并排序算法的代码：

function mergeSort(arr1, arr2) {
    var result = [];
    var index1 = 0;
    var index2 = 0;
    if (!arr1.length) {
        return arr2.slice(0);
    } else if (!arr2.length) {
        return arr1.slice(0);
    }
    while (true) {
        if (arr1[index1].num <= arr2[index2].num) {
            result.push(arr1[index1]);
            ++index1;
            // see if we reached the end of the array
            if (index1 >= arr1.length) {
                result.push.apply(result, arr2.slice(index2));
                break;
            }
        } else {
            result.push(arr2[index2]);
            ++index2;
            // see if we reached the end of the array
            if (index2 >= arr2.length) {
                result.push.apply(result, arr1.slice(index1));
                break;
            }
        }
    }
    return result;
}

工作演示：http://jsfiddle.net/jfriend00/mja1c13d/

Answer 2

内置排序可能比在大多数情况下编写自己的插入排序更有效。如果不是这样的话，那么本地Array.sort()将被写为自己做。

但是，您可能会查看其中一个例外情况，具体取决于两个阵列的大小。如果您知道两个数组中的一个已经排序，而另一个（未排序）数组很短，并且两个数组的总大小很大，那么迭代通过短数组并插入大的，排序的数组可能是更高效。

插入（假设您知道一个列表已经排序）将大约为N1 * N2;连接和排序可能类似于(N1 + N2) log (N1 + N2)。根据这两个相对大小，它可以采用任何一种方式。

但除非您的列表非常大，否则差异将低于人类明显的阈值，因此代码可维护性主张“连接和排序”。实际的实际性能测量总是优于猜测，并且性能非常依赖于数据的细节 - 因此，如果您真正关注，请同时编写并使用实际数据对其进行测试。

Answer 3

虽然我认为这不会很好地匹配您的数据，因此可能对您没用，但值得一提的是counting sort在线性时间内执行。如果您事先知道需要对数据进行排序而没有间隙，以便对于1000000000和10000000005之间的每个整数存在一个对象，并且所有整数都是唯一的，那么您可以通过进行数学计算来减少1000000000到零位置，1000000001到位置1等等......你通过从每个数字中减去1000000000得到那里，以获得从零开始的数组中的索引。

你最终得到像

这样的东西

var array = new Array(9000000005); //10000000005 - 1000000000
var obj = {"item":23532532, "num":1000000520};
var array[1000000520 - 1000000000] = obj; //goes into index 520

减法运算将线性时间复杂度提高到2n而不是n。内置的Javascript排序很可能是n log n时间复杂度。在x-y坐标图上从0到100，n log n更好，但是在x> 0时。 100，2n在性能上领先。对于90亿个项目而言，这实际上对于Javascript来说是不切实际的，你可以看到随着时间的推移差异将会大大改善。

很难捕捉到这个图表的比例，但是这给出了比较的好主意... y=x表示计数排序，y=2x表示使用减法运算计数排序。 y = x log x可能代表内置的Javascript数组排序。

enter image description here

在javascript中加入对象数组是排序还是插入更高效？

3 个答案: