Duplikate in Go entfernen (Duplikate aus Slice entfernen)

Duplikate In Go Entfernen Duplikate Aus Slice Entfernen



Slices sind eine grundlegende Datenstruktur in Go, da sie es uns ermöglichen, mit einer Sammlung von Elementen zu arbeiten.

Eine der häufigsten Aufgaben beim Arbeiten mit Slices ist das Entfernen doppelter Elemente. In diesem Tutorial führen wir Sie durch die Methoden, die Sie zur Bewältigung dieser Aufgabe verwenden können.

Golang-Scheiben

Bevor wir uns mit dem Entfernen der Duplikate aus einem Slice befassen, lassen Sie uns die Grundlagen von Slices erkunden, falls Sie nicht damit vertraut sind.







Was ist ein Slice?

In Go ist ein Slice eine flexible Ansicht in einem zugrunde liegenden Array mit dynamischer Größe. Es ist eine vielseitigere Alternative zu Arrays, da es je nach Bedarf vergrößert oder verkleinert werden kann, ohne dass wir eine feste Größe angeben müssen.



Wir können die Slices verwenden, um die Sequenzen von Daten wie Listen, Sammlungen oder Arrays mit dynamischen Größen darzustellen.



Ein Slice besteht in Go aus drei Hauptkomponenten:





  1. Zeiger auf das zugrunde liegende Array
  2. Länge (Anzahl der Elemente im Slice)
  3. Kapazität (maximale Anzahl von Elementen, die das Slice aufnehmen kann, ohne dass die Größe des zugrunde liegenden Arrays geändert wird)

Das Folgende zeigt die grundlegende Syntax zum Deklarieren eines Slice in Go:

War Slice-Name [] Typ

Grundlagen von Slices in Go

Die erste und gebräuchlichste Methode zum Erstellen eines Slice in Go ist die Verwendung der Literaldefinition, wie im folgenden Beispiel gezeigt:



Datenbanken := [] Zeichenfolge { „MySQL“ , „PostgreSQL“ , „Redis“ }

Wir können auch die Funktion „make“ verwenden, um ein neues Slice zu deklarieren, wie im folgenden Beispiel gezeigt:

Datenbanken := machen ([] Zeichenfolge , 3 , 5 )

Dadurch sollte ein Ganzzahlsegment mit der Länge 3 und einer Kapazität von 5 erstellt werden.

Wir können ein Slice auch erstellen, indem wir ein vorhandenes Array wie folgt in Slices aufteilen:

arr := [ 5 ] int { 1 , 2 , 3 , 4 , 5 }
Scheibe := arr [ 1 : 4 ]

Dadurch sollte ein neues Slice aus dem zweiten und vierten Element des Arrays erstellt werden.

Elemente zum Slice hinzufügen

In Go können wir die Elemente mit der Funktion append() zu einem vorhandenen Slice hinzufügen, wie im folgenden Beispiel gezeigt:

Datenbanken := [] Zeichenfolge { „MySQL“ , „PostgreSQL“ }
Datenbanken = anhängen ( Datenbanken , „Redis“ )

In der „Append“-Funktion müssen wir das vorhandene Slice und die neuen Elemente übergeben, die wir dem Slice hinzufügen möchten.

Zugriff auf die Elemente

Wir können über den Elementindex auf die Slice-Elemente zugreifen, wie im folgenden Beispiel gezeigt:

ich := Datenbanken [ 0 ]

Dies sollte das erste Element im Slice zurückgeben.

Iterieren über ein Slice

Wir können eine einfache „for“-Schleife verwenden, um die Elemente eines Slice zu durchlaufen, wie im folgenden Beispiel gezeigt:

für ich , db := Reichweite Datenbanken {

fmt . Druckenf ( „Index: %d, Wert: %s \N ' , ich , db )

}

Entfernen Sie ein Duplikat aus einem Slice

Kommen wir zum Kern des Tutorials und lernen die Methoden kennen, mit denen wir die doppelten Elemente aus einem Slice entfernen können.

Methode 1: Verwenden einer Schleife

Die einfachste Methode zum Entfernen der Duplikate aus einem Slice besteht darin, über die Elemente zu iterieren und alle doppelten Werte zu entfernen. Aus den restlichen Elementen können wir dann wie folgt ein neues Slice erstellen:

Paket hauptsächlich
importieren „fmt“
Funktion hauptsächlich () {
Scheibe := [] int { 1 , 2 , 2 , 3 , 4 , 4 , 5 }
einzigartig := [] int {}
für _ , Auf eins := Reichweite Scheibe {
gefunden := FALSCH
für _ , In := Reichweite einzigartig {
Wenn Auf eins == In {
gefunden = WAHR
brechen
}
}
Wenn ! gefunden {
einzigartig = anhängen ( einzigartig , Auf eins )
}
}
fmt . Druckenln ( einzigartig )
}

Bei dieser Methode werden mehrere Schleifen verschachtelt, um die doppelten Elemente zu iterieren und aus dem Slice zu entfernen.

Daher weist es eine Komplexierung von O(n^2) auf, was es in großen Datensätzen sehr ineffizient macht.

Methode 2: Verwenden einer Karte

Für einen effizienteren Ansatz können wir die Karte nutzen, um den Überblick über einzigartige Elemente zu behalten. Betrachten Sie das folgende Beispiel:

Paket hauptsächlich
importieren „fmt“

Funktion hauptsächlich () {
Scheibe := [] int { 1 , 2 , 2 , 3 , 4 , 4 , 5 }
einzigartig := Karte [ int ] bool {}
Ergebnis := [] int {}
für _ , Auf eins := Reichweite Scheibe {
Wenn ! einzigartig [ Auf eins ] {
einzigartig [ Auf eins ] = WAHR
Ergebnis = anhängen ( Ergebnis , Auf eins )
}
}
fmt . Druckenln ( Ergebnis )
}

Im Gegensatz zum Ansatz mit verschachtelten „for“-Schleifen weist dieser Ansatz eine zeitlich konstante Komplexität auf, was ihn äußerst effizient macht.

Mit dieser Methode können Sie auch die Reihenfolge der ursprünglichen Elemente beibehalten.

Abschluss

In diesem Tutorial haben wir etwas über die Funktionsweise von Slices in Go gelernt. Wir haben erläutert, wie Sie eine „for“-Schleife und Zuordnungen verwenden, um die doppelten Werte aus dem Slice zu entfernen.