Sauber zwei Arrays in ActionScript (3.0) zusammenführen?

Question

Was ist eine schöne Möglichkeit, zwei sortierte Arrays in ActionScript (speziell ActionScript 3.0) zu mergen? Das resultierende Array sollte sortiert sein und keine Duplikate enthalten.

Answer 1

Um Arrays zu verbinden (zu konkatenieren), verwenden Sie .concat().

Im Folgenden sind zwei Beispiele dafür, wie Sie Arrays konkatenieren und gleichzeitig Duplikate entfernen können.

Bequemere Methode: (Sie können ArrayUtil.createUniqueCopy() aus as3corelib verwenden)

// aus 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)); // Ergebnis: ["a", "b", "c", "x", "y"]

Etwas schnellere Methode: (Sie können die Arrays selbst durchlaufen und [Array.indexOf()](http://livedocs.adobe.com/flex/3/langref/Array.html#indexOf()) verwenden, um nach Duplikaten zu suchen)

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); // Ergebnis: ["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

Dies ist eine Art einfacher Algorithmus zu schreiben. Ich würde überrascht sein, wenn es einen direkteren Weg gäbe, dies in Actionscript zu tun.

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

Die Verwendung von Array.indexOf zur Erkennung von Duplikaten wird äußerst langsam sein, wenn Sie eine Liste mit einer großen Anzahl von Elementen haben; eine viel schnellere Möglichkeit, Duplikate zu entfernen, besteht darin, die Inhalte des Arrays nach der Verkettung in ein Set zu werfen.

// Kombinieren Sie die beiden Arrays.
const combined : Array = a.concat(b);

// Konvertieren Sie sie in ein Set; dadurch werden alle Duplikate entfernt.
const set : Object = {};  // Verwenden Sie ein Dictionary, wenn das kombinierte Array komplexe Typen enthält.

const len : uint = combined.length;
for (var i : uint = 0; i < len; i++) {
    set[combined[i]] = true;
}

// Extrahieren Sie alle Werte aus dem Set, um das endgültige Ergebnis zu erzeugen.
const result : Array = [];
for (var prop : * in set) {
    result.push[prop];
}

Wenn Ihr Programm intensiv Collections verwendet, wäre es ratsam, eines der vielen AS3-Collections-Frameworks zu nutzen, die eine einfache Schnittstelle zur Manipulation von Daten bieten und immer den optimalen Ansatz bei der Implementierung wählen.

• AS3Commons Collections
• Polygonal DS

Answer 4

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

Dann für das "merge" verwenden Sie concat. beispiel :

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 5

Bitte befolgen Sie die unten stehenden Schritte, um Ihre Antwort zu erhalten:

1. Zwei Arrays mit der Methode "Concat" zusammenfügen.
2. Das neue Array (zusammengefügt) mit der Methode "Sort" sortieren, die als API in der Array-Klasse bereitgestellt wird.
3. Benutzerdefinierte Funktion zum Entfernen von Duplikaten erstellen (siehe untenstehende Funktionen).

4. function 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

   `

   }

   `

`

Das zurückgegebene "ansArr" wird sortiert und ohne Duplikate zu einem fusionierten Array der beiden Arrays.

`