Sets

A set is a data structure that can store elements and has no repeated values. It is a computer implementation of the mathematical concept of a finite set. Unlike most other collection types, rather than retrieving a specific element from a set, one typically tests an element for membership in a set. This structure is often used to ensure that no duplicates are present in a container.

Implements Container interface.

type Set interface {
    Add(elements ...interface{})
    Remove(elements ...interface{})
    Contains(elements ...interface{}) bool
    containers.Container
    // Empty() bool
    // Size() int
    // Clear()
    // Values() []interface{}
}

HashSet

A set backed by a hash table (actually a Go’s map). It makes no guarantees as to the iteration order of the set.

Implements Set, JSONSerializer and JSONDeserializer interfaces.

package main
import "github.com/emirpasic/gods/sets/hashset"
func main() {
    set := hashset.New()   // empty
    set.Add(1)             // 1
    set.Add(2, 2, 3, 4, 5) // 3, 1, 2, 4, 5 (random order, duplicates ignored)
    set.Remove(4)          // 5, 3, 2, 1 (random order)
    set.Remove(2, 3)       // 1, 5 (random order)
    set.Contains(1)        // true
    set.Contains(1, 5)     // true
    set.Contains(1, 6)     // false
    _ = set.Values()       // []int{5,1} (random order)
    set.Clear()            // empty
    set.Empty()            // true
    set.Size()             // 0
}

TreeSet

A set backed by a red-black tree to keep the elements ordered with respect to the comparator.

Implements Set, IteratorWithIndex, EnumerableWithIndex, JSONSerializer and JSONDeserializer interfaces.

package main
import "github.com/emirpasic/gods/sets/treeset"
func main() {
    set := treeset.NewWithIntComparator() // empty (keys are of type int)
    set.Add(1)                            // 1
    set.Add(2, 2, 3, 4, 5)                // 1, 2, 3, 4, 5 (in order, duplicates ignored)
    set.Remove(4)                         // 1, 2, 3, 5 (in order)
    set.Remove(2, 3)                      // 1, 5 (in order)
    set.Contains(1)                       // true
    set.Contains(1, 5)                    // true
    set.Contains(1, 6)                    // false
    _ = set.Values()                      // []int{1,5} (in order)
    set.Clear()                           // empty
    set.Empty()                           // true
    set.Size()                            // 0
}

LinkedHashSet

A set that preserves insertion-order. Data structure is backed by a hash table to store values and doubly-linked list to store insertion ordering.

Implements Set, IteratorWithIndex, EnumerableWithIndex, JSONSerializer and JSONDeserializer interfaces.

package main
import "github.com/emirpasic/gods/sets/linkedhashset"
func main() {
    set := linkedhashset.New() // empty
    set.Add(5)                 // 5
    set.Add(4, 4, 3, 2, 1)     // 5, 4, 3, 2, 1 (in insertion-order, duplicates ignored)
    set.Add(4)                 // 5, 4, 3, 2, 1 (duplicates ignored, insertion-order unchanged)
    set.Remove(4)              // 5, 3, 2, 1 (in insertion-order)
    set.Remove(2, 3)           // 5, 1 (in insertion-order)
    set.Contains(1)            // true
    set.Contains(1, 5)         // true
    set.Contains(1, 6)         // false
    _ = set.Values()           // []int{5, 1} (in insertion-order)
    set.Clear()                // empty
    set.Empty()                // true
    set.Size()                 // 0
}