Detaillierte Erläuterung der Verwendung der Go-Sprache zum Finden von Ähnlichkeiten und Unterschieden zwischen zwei Arrays

Die folgende Tutorial-Kolumne von golang stellt Ihnen die Gemeinsamkeiten und Unterschiede der Verwendung der Go-Sprache zum Finden zweier Arrays vor. Ich hoffe, dass sie Freunden in Not hilfreich sein wird!

Ich bin kürzlich auf eine kleine Anforderung in einem Projekt gestoßen. Die Eingabe besteht aus zwei Arrays, einem alten Array und einem neuen Array. Es ist erforderlich, alle neuen und gelöschten Elemente des neuen Arrays abzurufen Das alte Array, zum Beispiel:

rrree

In der Standardbibliothek von Go gibt es keine ähnliche direkte Vergleichsmethode. Die einfachste Methode besteht natürlich darin, für jedes Element des alten Arrays zu wechseln Wenn es nicht gefunden wird, löschen Sie es und fügen Sie dann nacheinander die Elemente des neuen Arrays hinzu und suchen Sie danach. Wenn Sie es nicht finden können, ist diese Methode zu ineffizient .

Hier verwende ich eine Idee, die auf Mengenoperationen basiert, das heißt, den Schnittpunkt bzw. die Vereinigung zweier Arrays zu finden. Die Vereinigung minus dem Schnittpunkt sind alle geänderten Elemente (entweder neu oder gelöscht), die Elemente in dieser Sammlung durchlaufen und im alten Array suchen, dann ist es das gelöschte Element; wenn es nicht gefunden wird, wird es definitiv im neuen Array gefunden (es besteht keine Notwendigkeit, es tatsächlich erneut zu durchlaufen). . einmal), dann ist es ein neues Element.

Der obige Code ist hier ein Trick, der darin besteht, die Einzigartigkeit der Kartenschlüssel in Go zu nutzen, die Elemente des Arrays als Schlüssel der Karte zu verwenden und eine schnelle Suche durch die Karte zu erreichen.

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

Operationsergebnisse:

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
}

Willkommen zum Austausch effizienterer Methoden.

Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung der Verwendung der Go-Sprache zum Finden von Ähnlichkeiten und Unterschieden zwischen zwei Arrays. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!