Explication détaillée de l'utilisation du langage Go pour trouver des similitudes et des différences entre deux tableaux

La colonne tutorielle suivante de golang vous présentera les similitudes et les différences liées à l'utilisation du langage go pour trouver deux tableaux. J'espère qu'elle sera utile aux amis dans le besoin !

J'ai récemment rencontré une petite exigence dans le projet L'entrée est deux tableaux, un ancien tableau et un nouveau tableau. .L'exigence Obtenez tous les éléments nouveaux et supprimés du nouveau tableau par rapport à l'ancien tableau, par exemple :

输入：
arr_old: {"1", "2", "4", "5", "7", "9"}
arr_new: {"2", "3", "4", "6", "7"}
返回：
arr_added: {"3", "6"}
arr_deleted: {"1", "5", "9"}

Il n'existe pas de méthode de comparaison directe similaire dans la bibliothèque standard de go. La méthode la plus simple est bien sûr l'ancien tableau. Accédez au nouveau tableau pour chaque élément. S'il n'est pas trouvé, il est supprimé. Ensuite, les éléments du nouveau tableau sont recherchés un par un. trouvé, ajoute-t-on. Cependant, cette méthode est trop inefficace.

Ici, j'utilise une idée basée sur des opérations d'ensemble, c'est-à-dire pour trouver respectivement l'intersection et l'union de deux tableaux. L'union moins l'intersection correspond à tous les éléments modifiés (ou nouveaux), ou. supprimé), parcourez les éléments de cet ensemble et recherchez dans l'ancien tableau, s'il est trouvé dans l'ancien tableau, alors c'est l'élément supprimé sinon, s'il n'est pas trouvé, il doit être trouvé dans le nouveau tableau (utiliser ; Sans le parcourir à nouveau), il s'agit alors de l'élément nouvellement ajouté.

Au-dessus du code, il y a une astuce ici, qui consiste à utiliser le caractère unique de la clé de la carte dans Go, à utiliser les éléments du tableau comme clé de la carte et à réaliser une recherche rapide via la carte.

package main

import (
	"fmt"
)

func main() {
	//fmt.Println("Hello World!")
	src := []string{"1", "2", "4", "5", "7", "9"}
	dest := []string{"2", "3", "4", "6", "7"}

	added, removed := Arrcmp(src, dest)
	fmt.Printf("add: %v\nrem: %v\n", added, removed)
}

func Arrcmp(src []string, dest []string) ([]string, []string) {
	msrc := make(map[string]byte) //按源数组建索引
	mall := make(map[string]byte) //源+目所有元素建索引

	var set []string //交集

	//1.源数组建立map
	for _, v := range src {
		msrc[v] = 0
		mall[v] = 0
	}
	//2.目数组中，存不进去，即重复元素，所有存不进去的集合就是并集
	for _, v := range dest {
		l := len(mall)
		mall[v] = 1
		if l != len(mall) { //长度变化，即可以存
			l = len(mall)
		} else { //存不了，进并集
			set = append(set, v)
		}
	}
	//3.遍历交集，在并集中找，找到就从并集中删，删完后就是补集（即并-交=所有变化的元素）
	for _, v := range set {
		delete(mall, v)
	}
	//4.此时，mall是补集，所有元素去源中找，找到就是删除的，找不到的必定能在目数组中找到，即新加的
	var added, deleted []string
	for v, _ := range mall {
		_, exist := msrc[v]
		if exist {
			deleted = append(deleted, v)
		} else {
			added = append(added, v)
		}
	}

	return added, deleted
}

Résultats d'exploitation :

add: [6 3]
rem: [1 5 9]

Bienvenue pour partager des méthodes plus efficaces.

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!