ActionScript - 比较和删除复杂数组的重复项？

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，数字，字符串等。 ）或对象引用，所以如果它是通过2个阵列类似于像这样上面的例子中的工作原理：

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

导致合并数组与跟随着g值：

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

相反

，即时询问是否有可能传递函数2个复杂阵列或Vector.<Object>可以具有相同的键/值对和所得Vector.<Object>除去redundencies所有包含唯一对象。例如：

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

当然，你可以，你可以建立与任何类型为向量的类似的例子：

 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;  
    }