Porównanie elementów tablic - najszybciej?

Witam.
Szukam najszybszego / wydajnego sposobu porównywania wartości dwóch tablic.

Dla przykładu korzystam z.

    string[] stringlist_L       = new string[300000];
    string[] stringlist_R       = new string[300000];

           try
             {
                 for (ulong i = 0; i < stringlist_L.Length; i++)
                 {
                     for (ulong z = 0; z < stringlist_R.Length; z++)
                     {
                         if (stringlist_L[i].Equals(stringlist_R[z]) )
                         {
                                    ....
                         }
                     }
                 }
            }

Oczywiście zależy mi na wyciągnieciu poszczególnych elementów przy porównaniu.

ktos ma jakies pomysly? ;) nawet namniejsze i najdrobniejsze usprawnienia mile widziane.

Witam,

MrMUCHA napisał(a)

Oczywiście zależy mi na wyciągnieciu poszczególnych elementów przy porównaniu.
ktos ma jakies pomysly? ;) nawet namniejsze i najdrobniejsze usprawnienia mile widziane.

Chcesz sprawdzić czy elementy w obu tablicach są takie same, nie koniecznie w tej samej kolejności ??
Czyli:

string[] tab1 = new string[2];
string[] tab2 = new string[2];
tab1[0] = "Wilk";tab1[1] = "Mysz";
tab1[0] = "Mysz";tab1[1] = "Wilk";
//tab1 jest rowna tab2 !


tab1[0] = "Wilk";tab1[1] = "Mysz";
tab1[0] = "Wilk";tab1[1] = "Masz";
//tab1 i tab2 sa rozne

O to Ci chodzi ??

using System.Linq

...

Zobacz funkcje:

Distinct()
Except()
Intersect()

MrMucha miał na myśli raczej najwydajniejsze rozwiązanie, a nie najszybsze do implementacji ;)

Witam,
skoro mamy porównywać tablice czy są równe(czy zawierają te same elementy) to może wyliczymy
hashCode dla dwóch tablic i porównamy je. Pomyślałem sobie że można by napisać swoją klasę tablic,
która umożliwiałaby szybkie porównanie.
Zaimplementowałem sobie rozszerzenie tablicy:

    public class ArrayExtension<T> where T : class
    {
        private T[] mTable;
        private int mHashCode;

        public ArrayExtension(int lenght)
        {
            if (lenght <= 0)
                throw new ArgumentException("Dlugosc nie moze byc mniejsza rowna zero !");
            this.mTable = new T[lenght];
        }

        public T this[int index]
        {
            get
            {
                if (index >= 0 && index < this.mTable.Length)
                    return this.mTable[index];
                else
                    throw new IndexOutOfRangeException("Indeks wykracza poza rozmiar tablicy !");
            }
            set
            {
                if (index >= 0 && index < this.mTable.Length)
                {
                    this.mHashCode += value.GetHashCode();
                    this.mTable[index] = value;
                }
                else
                    throw new IndexOutOfRangeException("Indeks wykracza poza rozmiar tablicy !");
            }
        }

        public override int GetHashCode()
        {
            return this.mHashCode;
        }
    }

Przy dodawaniu elementów obliczany jest hashCode, jeśli tablice mają te same elementy to
porównanie czy obie są równe sprowadza się do porównania hashCode.
Oczywiście zakładamy że każdy typ obiektu ma dobrze zaimplementowaną metodę GetHashCode()
Przykład dla klasy String:

            int lenght = 2;
            ArrayExtension<string> array1 = new ArrayExtension<string>(lenght);
            ArrayExtension<string> array2 = new ArrayExtension<string>(lenght);
            array1[0] = "Wilk";
            array1[1] = "Mysz";
            array2[0] = "Mysz";
            array2[1] = "Wilk";
            Console.WriteLine(String.Format("Tablice sa rowne: {0}", array1.GetHashCode() ==  array2.GetHashCode() ? "TAK" : "NIE"));
            array1[0] = "Wilk";
            array1[1] = "Mysz";
            array2[0] = "Wilk";
            array2[1] = "Masz";
            Console.WriteLine(String.Format("Tablice sa rowne: {0}", array1.GetHashCode() == array2.GetHashCode() ? "TAK" : "NIE"));

wynik porównania:

Tablice sa rowne: TAK
Tablice sa rowne: NIE

Nie jest to może najefektywniejszy sposób, ale co tam ;) Zawsze jakiś pomysł ;)

Pozdrawiam

No tak, w C++ to by można było zrobić w ten sposob:

1. Podpiąć koniec pierwszej tablicy pod początek drugiej - w ten sposób otrzymamy jedną tabelicę ze wszystkimi elementami
2. Użyć szybkiego algorytmu sortowania (np. QuickSort) do posortowania uzyskanej tablicy
3. Iterować po kolejnych elementach tablicy i jeżeli dwa następne elementy są takie same to oznacza, że się powtarzają.

Założenia: w każdej z tablic każdy ciąg znaków jest unikalny.