데이터 구조: Set - Golang

안녕하세요 여러분, 잘 지내시나요? 오늘은 Set이라는 데이터 구조를 생성하는 것으로 구성된 Go에 관련된 내용을 가져오려고 합니다.

결국, 세트란 무엇입니까?

세트는 반복되지 않는 값의 컬렉션을 포함하는 선형 데이터 세트입니다. Set은 특별한 순서 없이 고유한 값을 저장할 수 있습니다.

결국, Go에 Set이 있나요?

답은 '아니오'입니다. 예를 들어 Go에는 Java나 C#과 같은 Set 또는 HashSet 데이터 구조가 없습니다. 하지만 Terraform을 소유한 대규모 기술 회사인 Hashicorp에는 Go 세계에서 이러한 유형의 문제를 해결하는 라이브러리가 있습니다. 기사 끝에 저장소 링크를 남겨 두겠습니다.

Set은 어떤 문제를 해결하나요?

• 멤버십 확인: 요소가 내부에 존재하는지 빠르게 확인하는 Excel을 설정합니다. 이는 세트가 빠른 조회를 위해 종종 해싱 기술을 사용하여 멤버십 확인에 O(1)의 평균 시간 복잡도를 제공하기 때문입니다.

• 고유한 요소 찾기: 집합을 사용하면 목록에서 고유한 요소를 계산하거나 찾는 것이 효율적입니다. 모든 요소를 ​​세트에 추가하기만 하면 고유한 항목만 포함됩니다. 이렇게 하면 복잡한 비교 루프가 필요하지 않습니다.

• 집합 연산: 집합은 합집합(두 집합의 요소 결합), 교집합(두 집합에 공통인 요소 찾기) 및 차이(한 집합에 있는 요소만 다른 집합에는 없음)와 같은 연산을 위한 내장 함수를 제공합니다. . 이러한 작업은 데이터 조작 및 분석에 매우 유용합니다.

• 세트가 좋은 옵션이 될 수 있는 문제의 구체적인 예는 다음과 같습니다.

• 목록에서 중복 요소 찾기: 모든 요소를 ​​세트에 추가합니다. 설정된 크기가 원래 목록 크기보다 작을 경우 중복이 있습니다.
  두 목록의 교차점 찾기: 교차점 설정 연산을 사용하여 두 목록에 모두 존재하는 요소를 찾습니다.

• 데이터세트에서 자주 사용되는 요소 식별: 세트에 요소를 추가하고 해당 요소의 발생 횟수를 셉니다. 이 세트는 중복을 제거하여 고유한 요소와 빈도에 집중할 수 있게 해줍니다.

• 문자열이 회문인지 확인: 문자열을 집합으로 변환하고 크기를 확인합니다. 중복을 제거한 후에도 크기가 동일하면 회문입니다(모든 문자가 한 번만 나타남).

좋아요, 주석을 통해 코드 내의 흐름을 설명하는 새로운 접근 방식으로 코드를 설명하겠습니다.

import "fmt"

// Criamos nossa estrutura para definir um map
type Set struct {
    integerMap map[int]bool
}

// Criamos nosso "construtor" para inicializar o map
func (s *Set) newSet() {
    s.integerMap = make(map[int]bool)
}

// Aqui temos a função que vai verificar se o elemento é false, por padrão é sempre falso, e se o elemento retornar false é porque esse valor não existe no nosso map e então podemos adicioná-lo. Mas se essa função retornar true, no nosso addElement ele nem vai adicionar ao mapa.
func (s *Set) containsElement(el int) bool {
    var exists bool
    _, exists = s.integerMap[el]
    return exists
}

// Responsável pela adição do elemento no mapa.
// Aqui, esse if verifica se o elemento contido é falso; se for falso, ele não tem uma duplicata e então pode ser adicionado à lista.
// Agora, se o resultado de contains for true, ele nem vai cair dentro desse if e por tanto não vai adicionar a lista.
func (s *Set) addElement(el int) {
    if !s.containsElement(el) {
        s.integerMap[el] = true
    }
}

// Aqui um delete simples
func (s *Set) deleteEl(el int) {
    delete(s.integerMap, el)
}

// Aqui damos um findAll que lista todos os elementos, sendo seu Big O O(n)
func (s *Set) allElements() {
    for k := range s.integerMap {
        fmt.Println(k)
    }
}

// Aqui temos a função que tem o length, que vai ser o tamanho do nosso integerMap, e a variável c, que pode ser chamada de collection, pois vai ser nossa coleção das chaves do nosso map, ou seja, uma lista.
// Dentro do nosso for, fazemos esse loop para descobrir se c[x] é maior do que c[n + 1], ou seja, a próxima posição na nossa lista.
// Criamos o initialValue que vai ser o valor em relação à posição da lista.
// Depois, atribuimos a c[x] o próximo valor da iteração, ou seja, c[x+1].
// E por fim, atribuimos o valor de c[x+1] = initialValue.
// Assim, fazemos com que os maiores valores da lista sejam trocados, jogando os maiores para o final da lista. O maior número SEMPRE tem que estar no fim da lista.
// Em outros termos, estamos fazendo uma ordenação por bolha ou bubblesort.
// Seu Big O é de O(n) no melhor caso e no pior caso é O(n^2).
// Mas sua complexidade espacial é muito boa, sendo O(1).
func (s *Set) maximumElements() {
    length := len(s.integerMap)

    c := s.allElements()

    for n := 0; x < length-1; x++ {
        if c[x] > c[x+1] {
            initialValue := c[x]
            c[x] = c[x+1]
            c[x+1] = initialValue
        }
    }
    maximumValue := c[length-1]
    fmt.Printf("MaximumValue: %d\n", maximumValue)
}

// Com a explicação do maximumElements, aqui é a mesma coisa,só que o menor número também tem que estar no final da lista.
func (s *Set) minumumElements() {

    c := s.allElements()
    length := len(s.integerMap)

    for x := 0; x < length-1; x++ {
        if c[x] < c[x+1] {
            initialValue := c[x]
            c[x] = c[x+1]
            c[x+1] = initialValue
        }
    }

    m := c[length-1]
    fmt.Printf("Minimum value %d\n", m)
}

// aqui temos nosso sizeOfSet que basicamente vai printar na tela o tamanho do nossa lista
func (s *Set) sizeOfSet() {
    fmt.Printf("Length of List: %v\n", len(s.allElements()))
}

func printValues(values []int) {

    fmt.Printf("List of Values: %v\n", values)
}

func main() {
    set := &Set{}
    set.newSet()
    set.addElement(3)
    set.addElement(6)
    set.addElement(8)
    set.addElement(9)
    set.addElement(10)
    set.addElement(14)
    set.addElement(3)
    set.addElement(2)
    set.addElement(14)

    values := set.allElements()
    printValues(values)

    set.maximumElements()
    set.minumumElements()

    fmt.Printf("Contains Value: %v\n", set.containsElement(1))

    set.sizeOfSet()

    set.deleteElements(14)
    set.deleteElements(2)
    fmt.Println("--------------------------------")
    valuesAfterDelete := set.allElements()
    set.maximumElements()
    set.minumumElements()
    printValues(valuesAfterDelete)
}

• 콘솔 응답

List of Values: [8 9 10 14 2 3 6]
MaximumValue: 14
Minimum value: 2
Contains Value: false
Length of List: 7
--------------------------------
MaximumValue: 10
Minimum value: 3
List of Values: [9 10 3 6 8]

나는 매우 흥미로운 주제인 Intersect와 Union에 대해 이야기하는 두 번째 부분을 가져오려고 합니다.

오늘은 여기까지입니다. Go에서 Set을 사용하는 방법이나 이 주제도 이해하셨기를 바랍니다. 나는 이 주제에 관해 2부를 작성하려고 합니다. 잘 자시고 다음에 또 만나요!

• Hashicorp 저장소 링크: https://github.com/hashicorp/go-set
• BigO를 더 잘 이해할 수 있는 웹사이트: https://www.bigochheatsheet.com/
• 저는 Go에서 생산성을 높이는 도구 역할을 하는 CLI를 만들고 있습니다. 살펴보세요: https://github.com/YlanzinhoY/tooling_golang

위 내용은 데이터 구조: Set - Golang의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!