Comment supprimer des éléments d'une tranche en langage Go

Méthode de suppression : 1. Interceptez la tranche pour supprimer l'élément spécifié, la syntaxe est "append(a[:i], a[i+1:]...)". 2. Créez une nouvelle tranche, filtrez les éléments à supprimer et affectez-les à la nouvelle tranche. 3. Utilisez un index d'indice pour enregistrer la position où un élément valide doit être ; parcourez tous les éléments, et lorsqu'un élément valide est rencontré, déplacez-le vers l'index et augmentez l'index de un, la position finale de l'index est la position suivante de tous ; éléments valides, et enfin faire une interception.

L'environnement d'exploitation de ce tutoriel : système Windows 7, GO version 1.18, ordinateur Dell G3.

Go ne fournit pas de syntaxe ou de fonctions spéciales pour supprimer des éléments de tranche. Vous devez utiliser les caractéristiques de la tranche elle-même pour supprimer des éléments.

Il existe généralement les méthodes suivantes pour supprimer des éléments spécifiés dans une tranche. Cet article utilise []int comme exemple pour donner l'implémentation spécifique.

1. Méthode d'interception (modifier la tranche d'origine)

Ici, l'interception de la tranche permet de supprimer l'élément spécifié. Notez que lors de la suppression, les éléments suivants seront avancés, donc l'indice i doit être déplacé d'une position vers la gauche.

// DeleteSlice1 删除指定元素。
func DeleteSlice1(a []int, elem int) []int {
	for i := 0; i < len(a); i++ {
		if a[i] == elem {
			a = append(a[:i], a[i+1:]...)
			i--
		}
	}
	return a
}

2. Méthode de copie (sans changer la tranche d'origine)

Cette méthode est la plus simple à comprendre. Réutilisez une tranche et filtrez les éléments à supprimer. L'inconvénient est qu'il faut libérer de l'espace pour une autre tranche. L'avantage est qu'il est facile à comprendre et ne modifie pas la tranche d'origine.

// DeleteSlice2 删除指定元素。
func DeleteSlice2(a []int, elem int) []int {
	tmp := make([]int, 0, len(a))
	for _, v := range a {
		if v != elem {
			tmp = append(tmp, v)
		}
	}
	return tmp
}

3. Méthode Shift (modifier la tranche d'origine)

3.1 Méthode 1

Utilisez un index d'indice pour enregistrer la position où devrait être le prochain élément valide. Parcourez tous les éléments lorsqu’un élément valide est rencontré, déplacez-le vers l’index et augmentez l’index de un. La position finale de l'index est la position suivante de tous les éléments valides, et finalement une interception suffit. Cette méthode modifiera la tranche d'origine.

Cette méthode peut être considérée comme une amélioration par rapport à la première méthode d'interception, car chaque fois qu'un élément doit être déplacé, les performances sont meilleures.

// DeleteSlice3 删除指定元素。
func DeleteSlice3(a []int, elem int) []int {
	j := 0
	for _, v := range a {
		if v != elem {
			a[j] = v
			j++
		}
	}
	return a[:j]
}

3.2 Méthode 2

crée une tranche, mais partage le tableau sous-jacent de la tranche d'origine. De cette manière, il n’est pas nécessaire d’allouer de l’espace mémoire supplémentaire et les modifications peuvent être effectuées directement sur la tranche d’origine.

// DeleteSlice4 删除指定元素。
func DeleteSlice4(a []int, elem int) []int {
	tgt := a[:0]
	for _, v := range a {
		if v != elem {
			tgt = append(tgt, v)
		}
	}
	return tgt
}

4. Comparaison des performances

Supposons que notre tranche ait 0 et 1, nous voulons supprimer tous les 0.

Ici, nous testons des tranches d'une longueur de 10, 100 et 1 000 pour comparer les différences de performances des quatre implémentations ci-dessus.

La fonction de tranche générée est la suivante :

func getSlice(n int) []int {
	a := make([]int, 0, n)
	for i := 0; i < n; i++ {
		if i%2 == 0 {
			a = append(a, 0)
			continue
		}
		a = append(a, 1)
	}
	return a
}

Le code de référence est le suivant :

func BenchmarkDeleteSlice1(b *testing.B) {
	for i := 0; i < b.N; i++ {
		_ = DeleteSlice1(getSlice(10), 0)
	}
}
func BenchmarkDeleteSlice2(b *testing.B) {
	for i := 0; i < b.N; i++ {
		_ = DeleteSlice2(getSlice(10), 0)
	}
}
func BenchmarkDeleteSlice3(b *testing.B) {
	for i := 0; i < b.N; i++ {
		_ = DeleteSlice3(getSlice(10), 0)
	}
}
func BenchmarkDeleteSlice4(b *testing.B) {
	for i := 0; i < b.N; i++ {
		_ = DeleteSlice4(getSlice(10), 0)
	}
}

Les résultats du test sont les suivants :

La longueur de tranche d'origine est de 10 :

go test -bench=. main/slice
goos: windows
goarch: amd64
pkg: main/slice
cpu: Intel(R) Core(TM) i7-9700 CPU @ 3.00GHz
BenchmarkDeleteSlice1-8         17466486                65.07 ns/op
BenchmarkDeleteSlice2-8         14897282                85.22 ns/op
BenchmarkDeleteSlice3-8         21952129                50.78 ns/op
BenchmarkDeleteSlice4-8         22176390                54.68 ns/op
PASS
ok      main/slice      5.427s

La longueur de tranche d'origine est de 100 :

BenchmarkDeleteSlice1-8          1652146               762.1 ns/op
BenchmarkDeleteSlice2-8          2124237               578.4 ns/op
BenchmarkDeleteSlice3-8          3161318               359.9 ns/op
BenchmarkDeleteSlice4-8          2714158               423.7 ns/op

La longueur de tranche d'origine est de 1000 :

BenchmarkDeleteSlice1-8            56067             21915 ns/op
BenchmarkDeleteSlice2-8           258662              5007 ns/op
BenchmarkDeleteSlice3-8           432049              2724 ns/op
BenchmarkDeleteSlice4-8           325194              3615 ns/op

5 Résumé

D'après les résultats des tests de référence, la méthode la plus performante est la méthode de décalage, et la première méthode de mise en œuvre est la meilleure. La méthode la moins performante et la plus couramment utilisée est la méthode d’interception. À mesure que la longueur de la tranche augmente, la différence de performances entre les quatre méthodes de suppression ci-dessus deviendra plus évidente.

En utilisation réelle, nous pouvons choisir en fonction des différents scénarios. Si vous ne pouvez pas modifier la tranche d'origine à l'aide de la méthode de copie, vous pouvez modifier la tranche d'origine à l'aide de la première méthode d'implémentation de la méthode shift.

【Recommandations associées : Tutoriel vidéo Go, Enseignement de la programmation】

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!