deque Alternatives - Go Data Structures

Popularity

1.5

Growing

Activity

5.7

Declining

Stars 15

Watchers 1

Forks 0

Last Commit 5 months ago

Programming language: Go

Tags: Data Structures

deque alternatives and similar packages

Based on the "Data Structures" category

gods

9.7 3.5 deque VS gods

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

9.5 1.3 deque VS go-datastructures

a collection of useful, performant, and thread-safe data structures
golang-set

8.3 0.0 deque VS golang-set

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

8.1 3.5 deque VS gota

An implementation of dataframes, series, and data wrangling methods for Go.
boomfilters

7.9 0.0 deque VS boomfilters

probabilistic data structures for processing continuous, unbounded streams
roaring

7.5 6.6 deque VS roaring

Go package implementing compressed bitsets.
willf/bloom

7.5 0.0 deque VS willf/bloom

Go package implementing Bloom filters.
hyperloglog

7.2 2.5 deque VS hyperloglog

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

7.1 2.1 deque VS bitset

Go package implementing bitsets.
cuckoofilter

7.1 3.3 deque VS cuckoofilter

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

6.9 2.5 deque VS trie

Trie implementation in Go
go-geoindex

6.7 0.0 deque VS go-geoindex

In-memory geo index.
algorithms

6.7 0.0 deque VS algorithms

Algorithms and data structures.CLRS study.
gocache

6.4 6.8 deque VS gocache

A complete Go cache library with mutiple stores (memory, memcache, redis, ...), chainable, loadable, metrics cache and more.
mafsa

6.0 0.1 deque VS mafsa

MA-FSA implementation with Minimal Perfect Hashing
goskiplist

5.9 0.0 deque VS goskiplist

A skip list implementation in Go.
hilbert

5.8 0.0 deque VS hilbert

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

5.7 2.0 deque VS merkletree

Implementation of a merkle tree providing an efficient and secure verification of the contents of data structures.
ttlcache

5.6 3.2 deque VS ttlcache

An in-memory LRU string-interface{} map with expiration for golang
binpacker

5.2 0.0 deque VS binpacker

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

5.2 1.7 deque VS Bloomfilter

Face-meltingly fast, thread-safe, marshalable, unionable, probability- and optimal-size-calculating Bloom filter in go
go-adaptive-radix-tree

5.1 0.4 deque VS go-adaptive-radix-tree

A Go implementation of Adaptive Radix Tree.
bloom

4.9 0.0 deque VS bloom

Bloom filters implemented in Go.
conjungo

4.7 0.0 deque VS conjungo

A small, powerful and flexible merge library.
iter

4.6 7.3 deque VS iter

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

4.6 8.1 deque VS gostl

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

4.5 0.0 deque VS encoding

Integer Compression Libraries for Go.
ring

4.4 2.9 deque VS ring

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

4.3 0.0 deque VS skiplist

Skiplist implementation in Go
bit

4.3 0.0 deque VS bit

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

4.2 4.1 deque VS go-rquad

Region quadtrees with efficient point location and neighbour finding.
levenshtein

3.9 3.6 deque VS levenshtein

Implmentation to calculate levenshtein distance in Go.
goconcurrentqueue

3.8 5.7 deque VS goconcurrentqueue

Concurrent FIFO queue.
go-mcache

3.5 3.7 deque VS go-mcache

Fast in-memory key:value store/cache library. Pointer caches.
remember-go

3.3 3.9 deque VS remember-go

A universal interface for caching slow database queries (backed by redis, memcached, ristretto, or in-memory).
set

3.3 0.5 deque VS set

Simple set data structure implementation in Go using LinkedHashMap.
count-min-log

3.1 0.0 deque VS count-min-log

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

2.9 6.8 deque VS crunch

Go package implementing buffers for handling various datatypes easily.
goset

2.4 0.8 deque VS goset

A useful Set collection implementation for Go.
ptrie

2.2 5.1 deque VS ptrie

An implementation of prefix tree.
hide

2.0 0.0 deque VS hide

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

2.0 0.0 deque VS pipeline

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

1.7 0.0 deque VS mspm

Multi-String Pattern Matching Algorithm for information retrieval.
timedmap

1.7 5.6 deque VS timedmap

Map with expiring key-value pairs.
null

1.5 1.9 deque VS null

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

1.3 0.0 deque VS dict

Python-like dictionaries (dict) for Go.
go-ef

1.3 0.0 deque VS go-ef

A Go implementation of the Elias-Fano encoding.
treap

1.3 2.1 deque VS treap

Persistent, fast ordered map using tree heaps.
gofal

0.7 5.9 deque VS gofal

fractional api for Go.
parsefields

0.5 0.0 deque VS parsefields

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

Do you think we are missing an alternative of deque or a related project?

Add another 'Data Structures' Package

Popular Comparisons

README

Overview

Deque is a highly optimized double-ended queue.

Benchmark

Benchmark_PushBack/Deque<harden>   100000000            10.3 ns/op         9 B/op          0 allocs/op
Benchmark_PushBack/Deque            20000000            81.3 ns/op        24 B/op          1 allocs/op
Benchmark_PushBack/list.List         5000000           281 ns/op          56 B/op          2 allocs/op
Benchmark_PushFront/Deque<harden>  195840157             7.96 ns/op        9 B/op          0 allocs/op
Benchmark_PushFront/Deque           30000000            70.6 ns/op        24 B/op          1 allocs/op
Benchmark_PushFront/list.List        5000000           276 ns/op          56 B/op          2 allocs/op
Benchmark_Random/Deque<harden>      65623633            17.3 ns/op         0 B/op          0 allocs/op
Benchmark_Random/Deque              50000000            32.1 ns/op         4 B/op          0 allocs/op
Benchmark_Random/list.List          30000000           123 ns/op          28 B/op          1 allocs/op

Usage

import "github.com/edwingeng/deque"

dq := NewDeque()
dq.PushBack(100)
dq.PushBack(200)
dq.PushBack(300)
for !dq.Empty() {
    fmt.Println(dq.PopFront())
}

dq.PushFront(100)
dq.PushFront(200)
dq.PushFront(300)
for i, n := 0, dq.Len(); i < n; i++ {
    fmt.Println(dq.PopFront())
}

// Output:
// 100
// 200
// 300
// 300
// 200
// 100

Harden the element data type

./harden.sh <outputDir> <packageName> [elemType]

Documentation

https://godoc.org/github.com/edwingeng/deque

deque

A highly optimized double-ended queue.