actionscript 3 - ventajas - ¿Combinar dos matrices de manera limpia en ActionScript(3.0)?

as3 lenguaje

Question

¿Cuál es una buena manera de fusionar dos matrices ordenadas en ActionScript (específicamente ActionScript 3.0)? La matriz resultante debe ser ordenada y sin duplicados.

Answer 1

Para fusionar (concatenar) matrices, use .concat() .

A continuación hay dos ejemplos de cómo puede concatenar matrices y eliminar duplicados al mismo tiempo.

ArrayUtil.createUniqueCopy() más conveniente: (puede usar ArrayUtil.createUniqueCopy() desde as3corelib )

// from as3corelib:
import com.adobe.utils.ArrayUtil;
var a1:Array = ["a", "b", "c"];
var a2:Array = ["c", "b", "x", "y"];
var c:Array = ArrayUtil.createUniqueCopy(a1.concat(a2)); // result: ["a", "b", "c", "x", "y"]

Un poco más rápido: (puede recorrer las matrices usted mismo y usar Array.indexOf() para buscar duplicados)

var a1:Array = ["a", "b", "c"];
var a2:Array = ["c", "b", "x", "y"];
var a3:Array = ["a", "x", "x", "y", "z"];
var c:Array = arrConcatUnique(a1, a2, a3); // result: ["a", "b", "c", "x", "y", "z"]
private function arrConcatUnique(...args):Array
{
var retArr:Array = new Array();
for each (var arg:* in args)
{
if (arg is Array)
{
for each (var value:* in arg)
{
if (retArr.indexOf(value) == -1)
retArr.push(value);
}
}
}
return retArr;
}

Answer 2

Este es un tipo de algoritmo simple para escribir. Me sorprendería si hubiera una manera más directa de hacer esto en Actionscript.

function merge(a1:Array, a2:Array):Array {
var result:Array = [];
var i1:int = 0, i2:int = 0;
while (i1 < a1.length && i2 < a2.length) {
if (a1[i1] < a2[i2]) {
result.push(a1[i1]);
i1++;
} else if (a2[i2] < a1[i1]) {
result.push(a2[i2]);
i2++;
} else {
result.push(a1[i1]);
i1++;
i2++;
}
}
while (i1 < a1.length) result.push(a1[i1++]);
while (i2 < a2.length) result.push(a2[i2++]);
return result;
}

Answer 3

function remDuplicates(_array:Array):void{
for (var i:int = 0; i < _array.length;++i) {
var index:int = _array.indexOf(_array[i]);
if (index != -1 && index != i) {
_array.splice(i--, 1);
}
}
}

Luego, para la "combinación" usa concat. ejemplo:

var testArray:Array = [1, 1, 1, 5, 4, 5, 5, 4, 7, 2, 3, 3, 6, 5, 8, 5, 4, 2, 4, 5, 1, 2, 3, 65, 5, 5, 5, 5, 8, 4, 7];
var testArray2:Array = [1, 1, 1, 5, 4, 5, 5, 4, 7, 2, 3, 3, 6, 5, 8, 5, 4, 2, 4, 5, 1, 2, 3, 65, 5, 5, 5, 5, 8, 4, 7];
testArray.concat(testArray2);
trace(testArray);
remDuplicates(testArray);
trace(testArray);

Answer 4

Usar Array.indexOf para detectar duplicados va a ser extremadamente lento si tiene una Lista que contiene una gran cantidad de elementos; una forma mucho más rápida de eliminar duplicados sería arrojar los contenidos de la matriz en un conjunto después de concatenarlos.

// Combine the two Arrays.
const combined : Array = a.concat(b);
// Convert them to a Set; this will knock out all duplicates.
const set : Object = {}; // use a Dictionary if combined contains complex types.
const len : uint = combined.length;
for (var i : uint = 0; i < len; i++) {
set[combined[i]] = true;
}
// Extract all values from the Set to produce the final result.
const result : Array = [];
for (var prop : * in set) {
result.push[prop];
}

Si su programa hace un uso intensivo de las colecciones, entonces puede ser prudente utilizar uno de los muchos marcos de colecciones AS3 que ofrecen una interfaz simple para manipular datos y siempre tendrá el enfoque óptimo cuando se trata de la implementación.

• Colecciones AS3Commons
• DS poligonal

Answer 5

Por favor, siga el siguiente paso para obtener su respuesta:

1. Concat dos matriz utilizando "Concat" Methos.
2. Nueva ordenación (ordenada) ordenada mediante el método "Ordenar" que se proporcionó como API en Array Class
3. Haga que la función definida por el usuario elimine los duplicados (vea las funciones a continuación)
4. > función removeDuplicates (p_arr: Array): Array {

    var ansArr:Array = new Array();
   var len:uint = p_arr.length;
   var i:uint = 0;
   var j:uint = 0;
   ansArr[j] = p_arr[i];
   i++;
   j++;
   while(i<len)
   {
   if(ansArr[j] != p_arr[i])
   {
   ansArr[j] = p_arr[i];
   j++;
   }
   i++;
   }
   return ansArr;

   }

El "ansArr" devuelto se ordenará y no se combinarán dos matrices combinadas duplicadas.