Data Structures and Algorithms

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

Modern text indexing library for go

Distributed, Fault-tolerant task queue

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

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

Concurrent scalable data structures like `xsync.Map`, a concurrent generic hash table

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

Fast and easy-to-use skip list for Go

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

Go package for mapping values to and from space-filling curves, such as Hilbert and Peano curves.

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 small, powerful and flexible merge library.

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

Golang Bloom filter implementation

Finite-State Machine package

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

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

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

A useful Set collection implementation for Go

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

Python-like dictionaries (dict) for Go

Go Data Structures using Go 1.18 generics

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

An implementation of prefix tree

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

Split byte streams into chunks, and arrange chunks into trees, with boundaries determined by content, not position

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

Persistent, fast ordered map using tree heaps.

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

Iterator implementation to provide map and reduce functionalities

fractional api for Go

Generic pipeline functions for concurrent processing

Disjoint Set data structure implementation in Go

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

LINQ-like lazy evaluation library with type-safe generics, performance optimizations and zero dependencies

Functions that operate on slices; like `package strings` but adapted to work with slices.

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

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

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

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