Entfernen und hinzufügen von Elementen zum array in lang GEHEN

Ich habe 2 arrays deklariert als :
var input []string und var output []string .

Den Eingabe-array ist gefüllt mit einigen IDs zunächst. Output-array ist NULL.

Nach jeder iteration möchte ich Entferne ein zufälliges element aus der Eingabe-array und fügen Sie die Ausgabe-array.

Am Ende alle Elemente im Ausgabe-array wird derselbe sein wie der input-array - (aber mit unterschiedlichen Bestellung(Indexierung)).

for index := 0; index < len(input); index++ {
    if !visited[index] {
        //do something
    }
}
output[#iteration index] = input[current index]

Wenn ich versuche, dies zu tun, bekomme ich array out of bounds error.

InformationsquelleAutor fnaticRC ggwp | 2015-11-20

append arrays go slice

16

Für die output array, das Sie verwenden müssen append oder verteilen Sie es mit einer anfänglichen Kapazität entsprechend der Größe der input.
```
//before the loop
output := make([]string, len(input))
```
wäre meine Empfehlung, weil append verursacht einen Haufen unnötige Umschichtungen und Sie bereits wissen, welche Kapazität Sie benötigen, da es basiert auf der input.

Die andere Sache wäre:
```
output = append(output, input[index])
```
Aber wie ich schon sagte, von dem, was ich beobachtet habe append wächst die anfängliche Kapazität exponentiell. Diese werden Basis 2 wenn Sie noch nicht angegeben, was bedeutet, dass Sie tun werden einige unnötige Umschichtungen vor erreichen der gewünschten Kapazität.

Vielen Dank Jungs ! Das funktionierte perfekt in Ordnung zu sein 🙂
Gibt es eine Möglichkeit zum Anhängen an eine Scheibe ohne Neuzuweisung?

InformationsquelleAutor evanmcdonnal
2

Finden Sie ein paar nützliche tricks bei der golang/SliceTricks.

Seit der Einführung der append built-in, die meisten der Funktionalität der container/vector - Paket, das entfernt wurde, in Go 1, können repliziert werden, mit append und copy.

Hier sind die Vektor-Methoden und Ihre Scheibe-manipulation Analoga:

AppendVector
```
a = append(a, b...)
```
Kopieren
```
b = make([]T, len(a))
copy(b, a)
//or
b = append([]T(nil), a...)
```
Schneiden
```
a = append(a[:i], a[j:]...)
```
Löschen
```
a = append(a[:i], a[i+1:]...)
//or
a = a[:i+copy(a[i:], a[i+1:])]
```
Löschen ohne Erhaltung der Reihenfolge
```
a[i] = a[len(a)-1] 
a = a[:len(a)-1]
```
HINWEIS, Wenn der Typ des Elements ist eine Zeiger oder ein struct mit Zeiger-Felder, die Notwendigkeit, Müll gesammelt, die oben genannten Implementierungen von Cut und Delete haben ein Potenzial Speicherverlust problem: einige Elemente mit Werten, die noch verwiesen wird, durch den slice - a und kann somit nicht erfasst werden. Der folgende code kann dieses problem beheben:

Schnitt
```
copy(a[i:], a[j:])
for k, n := len(a)-j+i, len(a); k < n; k++ {
    a[k] = nil //or the zero value of T
}
a = a[:len(a)-j+i]
```
Löschen
```
copy(a[i:], a[i+1:])
a[len(a)-1] = nil //or the zero value of T
a = a[:len(a)-1]
```
Löschen ohne Erhaltung der Reihenfolge
```
a[i] = a[len(a)-1]
a[len(a)-1] = nil
a = a[:len(a)-1]
```
Erweitern
```
a = append(a[:i], append(make([]T, j), a[i:]...)...)
```
Erweitern
```
a = append(a, make([]T, j)...)
```
Einfügen
```
a = append(a[:i], append([]T{x}, a[i:]...)...)
```
HINWEIS Die zweite append erstellt eine neue Scheibe mit seiner eigenen zugrunde liegenden Speicher und kopiert die Elemente in a[i:] um die Scheibe, und diese Elemente sind dann kopieren zurück zu schneiden a (von der ersten append). Die Schaffung der neuen Scheibe (und damit Speicher-Müll) und die zweite Kopie kann vermieden werden, indem ein alternativer Weg:

Einfügen
```
s = append(s, 0)
copy(s[i+1:], s[i:])
s[i] = x
```
InsertVector
```
a = append(a[:i], append(b, a[i:]...)...)
```
Pop
```
x, a = a[0], a[1:]
```
Pop Zurück
```
x, a = a[len(a)-1], a[:len(a)-1]
```
Push
```
a = append(a, x)
```
Push-Vorne
```
a = append([]T{ x }, a...)
```
Shift
```
x, a := a[0], a[1:]
```
Unshift
```
a = append([]T{x}, a...)
```
Weitere Tricks

Filterung ohne Zuweisung

Dieser trick nutzt die Tatsache, dass eine Scheibe Aktien der gleichen backing-array und Kapazität als das original, so dass der Speicher wiederverwendet wird, der für die gefilterten Scheibe. Natürlich, der ursprüngliche Inhalt geändert werden.
```
b := a[:0]
for _, x := range a {
    if f(x) {
        b = append(b, x)
    }
}
```
Rückwärtsfahren

Ersetzen Sie den Inhalt der Scheibe mit den gleichen Elementen, aber in umgekehrter Reihenfolge:
```
for i := len(a)/2-1; i >= 0; i-- {
    opp := len(a)-1-i
    a[i], a[opp] = a[opp], a[i]
}
```
Das gleiche, außer mit zwei Indizes:
```
for left, right := 0, len(a)-1; left < right; left, right = left+1, right-1 {
    a[left], a[right] = a[right], a[left]
}
```
Mischen

Fisher–Yates-Algorithmus:
```
for i := len(a) - 1; i > 0; i-- {
    j := rand.Intn(i + 1)
    a[i], a[j] = a[j], a[i]
}
```
InformationsquelleAutor TonnyL

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

Weitere Tricks

Filterung ohne Zuweisung

Rückwärtsfahren

Mischen