So suchen Sie einen String im String-Array

Ich muss einen String im String-Array suchen. Ich möchte keine zum Schleifen verwenden

string [] arr = {"One","Two","Three"};

string theString = "One"

Ich muss überprüfen, ob die Variable String in arr vorhanden ist.

Jede zuvor erwähnte Methode führt eine interne oder externe Schleife durch, daher ist es nicht wirklich wichtig, wie sie implementiert wird. Hier ein weiteres Beispiel zum Finden aller Referenzen der Zielzeichenfolge

       string [] arr = {"One","Two","Three"};
       var target = "One";
       var results = Array.FindAll(arr, s => s.Equals(target));

Nun, es muss etwas aussehen, und das Schleifen ist effizienter als die Rekursion (da die Rekursion am Ende nicht vollständig implementiert ist). Wenn Sie sich also einfach nicht selbst schleifen möchten, dann ist eine der folgenden Methoden:

bool has = arr.Contains(var); // .NET 3.5

oder

bool has = Array.IndexOf(arr, var) >= 0;

Zur Information: Vermeiden Sie Namen wie var - dies ist ein Schlüsselwort in C # 3.0.

Muss es ein String sein []? Eine Liste <String> würde Ihnen geben, was Sie brauchen.

List<String> testing = new List<String>();
testing.Add("One");
testing.Add("Two");
testing.Add("Three");
testing.Add("Mouse");
bool inList = testing.Contains("Mouse");

bool exists = arr.Contains("One");

Ich denke, es ist besser, Array.Exists als Array.FindAll zu verwenden .

Es ist ziemlich einfach. Ich benutze diesen Code immer, um Zeichenfolgen aus einem Zeichenfolgenarray zu suchen

string[] stringArray = { "text1", "text2", "text3", "text4" };
string value = "text3";
int pos = Array.IndexOf(stringArray, value);
if (pos > -1)
{
    return true;
}
else
{
    return false;
}

Wenn das Array sortiert ist, können Sie BinarySearch verwenden . Dies ist eine O (log n) -Operation, daher ist sie schneller als eine Schleife. Wenn Sie mehrere Suchvorgänge durchführen müssen und die Geschwindigkeit ein Problem darstellt, können Sie sie (oder eine Kopie) sortieren, bevor Sie sie verwenden.

Jede Klasse, die IList implementiert, verfügt über eine Methode Contains (Objektwert) . Und System.Array auch.

Warum das Verbot "Ich möchte keine Schleifen verwenden"? Das ist die naheliegendste Lösung. Wenn Sie die Chance haben, offensichtlich zu sein, nehmen Sie es!

Beachten Sie, dass Anrufe wie arr.Contains(...)immer noch eine Schleife ausführen. Sie sind es einfach nicht, die die Schleife geschrieben haben.

Haben Sie eine alternative Darstellung in Betracht gezogen, die für die Suche besser geeignet ist?

• Eine gute Set-Implementierung würde gut funktionieren. (HashSet, TreeSet oder das lokale Äquivalent).
• Wenn Sie sicher sein können, dass dies arrsortiert ist, können Sie die binäre Suche verwenden (die rekursiv oder wiederholt werden müsste, jedoch nicht so oft wie eine gerade lineare Suche).

Auf den ersten Blick könnte ich mir so etwas einfallen lassen (aber es ist Pseudocode und vorausgesetzt, Sie können keine in .NET integrierten Bibliotheken verwenden). Könnte ein bisschen Optimieren und Überdenken erfordern, sollte aber vielleicht gut genug für einen Vorsprung sein?

int findString(String var, String[] stringArray, int currentIndex, int stringMaxIndex)
    {
    if currentIndex > stringMaxIndex 
       return (-stringMaxIndex-1);
    else if var==arr[currentIndex] //or use any string comparison op or function
       return 0;
    else 
       return findString(var, stringArray, currentIndex++, stringMaxIndex) + 1 ;
    }



    //calling code
    int index = findString(var, arr, 0, getMaxIndex(arr));

    if index == -1 printOnScreen("Not found");
    else printOnScreen("Found on index: " + index);

Wenn Sie in C # eine ArrayList verwenden können, können Sie die Contains-Methode verwenden, die einen Booleschen Wert zurückgibt:

if MyArrayList.Contains("One")

Sie können die Find- Methode vom Typ Array verwenden. Ab .NET 3.5 und höher.

public static T Find<T>(
    T[] array,
    Predicate<T> match
)

Hier einige Beispiele:

// we search an array of strings for a name containing the letter “a”:
static void Main()
{
  string[] names = { "Rodney", "Jack", "Jill" };
  string match = Array.Find (names, ContainsA);
  Console.WriteLine (match);     // Jack
}
static bool ContainsA (string name) { return name.Contains ("a"); }

Hier ist derselbe Code, der mit einer anonymen Methode gekürzt wurde:

string[] names = { "Rodney", "Jack", "Jill" };
string match = Array.Find (names, delegate (string name)
  { return name.Contains ("a"); } ); // Jack

Ein Lambda-Ausdruck verkürzt es weiter:

string[] names = { "Rodney", "Jack", "Jill" };
string match = Array.Find (names, n => n.Contains ("a"));     // Jack

Sie können die Elementexistenz durch überprüfen

arr.Any(x => x == "One")

es ist alt, aber so mache ich es,

enter code herevar result = Array.Find (Namen, Element => Element == "Eins");

Ich bin überrascht, dass niemand die Verwendung von Array.IndexOfMethod vorgeschlagen hat.

In der Tat Array.IndexOfhat zwei Vorteile:

• Es ermöglicht die Suche, ob ein Element in einem Array enthalten ist.
• Gleichzeitig wird der Index in das Array aufgenommen.

int stringIndex = Array.IndexOf(arr, theString);
if (stringIndex >= 0)
{
    // theString has been found
}

Inline-Version:

if (Array.IndexOf(arr, theString) >= 0)
{
    // theString has been found
}