Data Structures and Algorithms Go Libraries Ranking

- Go Data Structures. Containers, Sets, Lists, Stacks, Maps, BidiMaps, Trees, HashSet etc.

- Modern text indexing library for go.

- Collection of useful, performant, and thread-safe data structures.

- Distributed, Fault-tolerant task queue.

- Thread-Safe and Non-Thread-Safe high-performance sets for Go.

- Implementation of dataframes, series, and data wrangling methods for Go.

- Go package implementing compressed bitsets.

- Go package implementing Bloom filters.

- Probabilistic data structures for processing continuous, unbounded streams.

- Go package implementing bitsets.

- Cuckoo filter: a good alternative to a counting bloom filter implemented in Go.

- Data structure and algorithm library for go, designed to provide functions similar to C++ STL.

- HyperLogLog implementation with Sparse, LogLog-Beta bias correction and TailCut space reduction.

- Algorithms and data structures.CLRS study.

- Trie implementation in Go.

- Fast ring-buffer deque (double-ended queue).

- Go string comparison and edit distance algorithms library (Levenshtein, LCS, Hamming, Damerau levenshtein, Jaro-Winkler, etc.) compatible with Unicode.

- Implementation to calculate levenshtein distance in Go.

- Concurrent FIFO queue.

- Go implementation of Adaptive Radix Tree.

- Dense, zero-allocation, SIMD-enabled bitmap/bitset in Go.

- Multiple thread-safe, generic queue implementations for Go.

- In-memory geo index.

- Cuckoo filter: a comprehensive cuckoo filter, which is configurable and space optimized compared with other implements, and all features mentioned in original paper are available.

- Very fast Go Skiplist implementation.

- A high-performance, thread-safe generic concurrent hash map implementation with Swiss Map.

- Binary packer and unpacker helps user build custom binary stream.

- A highly optimized double-ended queue.

- Go implementation of C++ STL iterators and algorithms.

- Golang set data structure with bonus bit-twiddling functions.

- Bloom filters implemented in Go.

- Go implementation of a high performance, thread safe bloom filter.

- An easy to use, lightweight, thread-safe and append-only in-memory data structure inspired by Apache Kafka.

- Region quadtrees with efficient point location and neighbour finding.

- A comprehensive, reusable and efficient concurrent-safe generics utility functions and data structures library.

- Determine how intervals relate to each other.

- a thread-safe concurrent map for go, support using `interface{}` as key and auto scale up shards.

- Generic tuple implementation for Go 1.18+.

- Go package implementing buffers for handling various datatypes easily.

- Levenshtein distance and similarity metrics with customizable edit costs and Winkler-like bonus for common prefix.

- Finite-State Machine package.

- Zero allocation Nullable structures in one library with handy conversion functions, marshallers and unmarshallers.

- Golang Bloom filter implementation.

- Generic slice, map, set, iterator, and goroutine utilities.

- Skiplist implementation in Go.

- ID type with marshalling to/from hash to prevent sending IDs to clients.

- Go implementation Count-Min-Log sketch: Approximately counting with approximate counters (Like Count-Min sketch but using less memory).

- Generic key-sorted map using a red-black tree under the hood.

- Highly concurrent drop-in replacement for `bufio.Writer`.

- An implementation of pipelines with fan-in and fan-out.

- Go 1.18+ generic map interface for maps; safe maps; ordered maps; ordered, safe maps; etc.

- A useful Set collection implementation for Go.

- Fast, zero-allocation, lexicographical-order-preserving packing of native types to bytes.

- Go 1.18+ generics package inspired by Kotlin's Sequence and Map.

- Go Data Structures using Go 1.18 generics.

- Python-like dictionaries (dict) for Go.

- An implementation of prefix tree.

- Go module that processes work concurrently and returns output in a channel in the order of input.

- Null Types, Safe primitive type conversion and fetching value from complex structures.

- A Go implementation of the Elias-Fano encoding.

- Generic, zero-alloc, 100%-test covered quadtree.

- Adaptive radix tree (prefix-tree or compact-trie).

- Nullable Go types that can be marshalled/unmarshalled to/from JSON.

- FIFO Pipeline which parallels execution on each stage while maintaining the order of messages and results.

- Simple set data structure implementation in Go using LinkedHashMap.

- Multi-String Pattern Matching Algorithm for information retrieval.

- Convenient looping using Go's range-over-func feature.

- FSM for Go.

- Space-efficient computation of Merkle root hashes and inclusion proofs.

- Pure, generic functions for slices.

- Yet another Bloomfilter implementation in Go, compatible with Java's Guava library.

- fractional api for Go.

- Generic pipeline functions for concurrent processing.

- Iterator implementation to provide map and reduce functionalities.

- Doubly-ended heap (min-max heap) with O(log n) access to both minimum and maximum elements.

- Disjoint Set data structure implementation in Go.

- First pure Go implementation of Ribbon filters (practically smaller than Bloom and Xor) for space-efficient approximate set membership queries.

- A persistent, map-like object for the Go programming language. Supports multiple embedded key-value stores.

- A generic, thread-safe doubly linked list with full iterator support and an intrusive singly linked list for embedded use; a feature-rich replacement for container/list.

- Tools for parse JSON-like logs for collecting unique fields and events.

- Simple, in memory, zero dependency and battle tested, thread-safe deferred queue.

- Topological sort lib,Sorting and pruning of DAG graphs.

- Combinatorial operations including permutations, combinations, and combinations-with-replacement.

- Type-safe generic wrapper for `sync.Map` with full method parity and zero dependencies.

- HMap is a concurrent and secure, generic support Map implementation designed to provide an easy-to-use API.