Question

比较简单数组时，我使用类似下面的函数来连接和删除重复数据：

//Merge
public function merge(a1:Array, a2:Array):Array
{
    var result:Array = a1.concat(a2);

    var dictionary:Dictionary = new Dictionary();

    for each    (var item:Object in result)
                dictionary[item] = true;

    result = new Array();

    for (var key:Object in dictionary)
        result.push(key);

    dictionary = null;

    return result;
}

但是，这种方法不适用于复杂的数组。

是否有一个众所周知的算法，或者甚至可以编写一个可以将Vector.<Object>与另一个进行比较的递归函数？即使被比较的某些对象具有额外的键/值对，它也会一直有效吗？

[编辑]

更清楚一点，使用字典来确定简单数组中的项是否仅适用于原始数据类型（int，number，string等）或对象引用，因此上面的示例在它传递2个数组类似时有效像这样的东西：

var arr1:Array = new Array(1, 2, 3, 4, 5);
var arr2:Array = new Array(8, 7, 6, 5, 4);

导致合并数组具有以下值：

1, 2, 3, 8, 7, 6, 5, 4

相比之下，我问是否可以传递函数2复数数组或Vector.<Object>都包含可能具有相同键/值对的唯一对象，并在结果Vector.<Object>中删除冗余。例如：

var vec1:Vector.<Object> = new Vector.<Object>();
vec1.push({city:"Montreal", country:"Canada"});
vec1.push({city:"Halifax", country:"Canada"});

var vec2:Vector.<Object> = new Vector.<Object>();
vec2.push({city:"Halifax", country:"Canada"});
vec2.push({city:"Toronto", country:"Canada"});

合并上述2个矢量对象将通过确定和删除具有相同键/值对的对象来生成以下矢量：

{city:"Montreal", country:"Canada"}
{city:"Halifax", country:"Canada"}
{city:"Toronto", country:"Canada"}

我正在搜索一种算法，该算法可以处理这些类似对象的删除，而无需知道它们的特定键/值名称或对象中有多少键/值对。

Answer 1

当然可以，您可以使用任何类型的Vector构建类似的示例：

     public function mergeObjectVectors(v1:Vector.<Object>,                      
                                        v2:Vector.<Object>):Vector.<Object>
     {
        var dictionary:Dictionary = new Dictionary();
        var concat:Vector.<Object> = v1.concat(v2);
        var result:Vector.<Object> = new Vector.<Object>();

        for each(var i:Object in concat)
        {
            if (!dictionary[i])
            {
                dictionary[i] = true;
                result.push(i);
            }
        }           

        return result;
    }

但是，如果你计划接受任何类型的向量，那就不同了：

        public function testing():void
        {
             var v1:Vector.<Object> = new Vector.<Object>();
             v1.push({name:"Object 1"});
             v1.push({name:"Object 2"});

             // Vector w duplicates
             var v2:Vector.<Object> = new Vector.<Object>();
             var o:Object = {name:"Object 3"};                 
             v2.push(o);
             v2.push(o);
             v2.push(o);

             var resultVector:Vector.<Object> = mergeAnything(v1, v2, Class(Vector.<Object>));
             var resultArray:Array = mergeAnything(v1, v2, Array);
             var resultObject:Object = mergeAnything(v1, v2, Object);
        }


        public function mergeAnything(o1:Object, o2:Object, resultClass:Class):*
        {

            var dictionary:Dictionary = new Dictionary();
            var result:Object = new resultClass();

            var i:int;
            for each(var o:Object in o1)
            {
               if (!dictionary[o])
               {
                  dictionary[o] = true;
                  result[i++] = o;
               }
            }   

            for each(o in o2)
            {
               if (!dictionary[o])
               {
                  dictionary[o] = true;
                  result[i++] = o;
               }
            }

            return result;
        }

第一个例子将更具资源效率。

编辑：这应该这样做，试试你的例子：

     public function mergeObjectVectors(v1:Vector.<Object>, v2:Vector.<Object>):Vector.<Object>
    {
        var concat:Vector.<Object> = v1.concat(v2);
        var result:Vector.<Object> = new Vector.<Object>();

        var n:int = concat.length;
        loop:for (var i:int = 0; i < n; i++)
        {   
            var objectToAdd:Object = concat[i];

            var m:int = result.length;
            for (var j:int = 0; j < m; j++)
            {
                var addedObject:Object = result[j];
                if (this.areObjectsIdentical(objectToAdd, addedObject))
                {
                    continue loop;
                }
            }
            result.push(objectToAdd);
        }           

        return result;
    } 

    private function areObjectsIdentical(o1:Object, o2:Object):Boolean
    {
        var numComparisons:int = 0;

        for (var s:String in o1)
        {
            numComparisons++;
            if (o1[s] != o2[s])
            {
                return false;
            }
        }                   
        for (s in o2)
        {
            numComparisons--;
        }

        return !numComparisons;     
    }

ActionScript - 比较＆amp;删除复杂数组的副本？

1 个答案: