312 lines
11 KiB
Nim
312 lines
11 KiB
Nim
# Nimbus
|
||
# Copyright (c) 2018-2022 Status Research & Development GmbH
|
||
# Licensed under either of
|
||
# * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or
|
||
# http://www.apache.org/licenses/LICENSE-2.0)
|
||
# * MIT license ([LICENSE-MIT](LICENSE-MIT) or
|
||
# http://opensource.org/licenses/MIT)
|
||
# at your option. This file may not be copied, modified, or distributed except
|
||
# according to those terms.
|
||
|
||
## Generic Red-black Tree
|
||
## ======================
|
||
##
|
||
## This `red-black <https://en.wikipedia.org/wiki/Red–black_tree>`_ tree
|
||
## library was inspired by Julienne Walker's excellent tutorial,
|
||
## captured `here <https://archive.is/miDT>`_ or
|
||
## `here <https://web.archive.org/web/20180706105528/http://eternallyconfuzzled.com/tuts/datastructures/jsw_tut_rbtree.aspx>`_.
|
||
## The downloadable C library has been captured
|
||
## `here <https://web.archive.org/web/20160428112900/http://eternallyconfuzzled.com/libs/jsw_rbtree.zip>`_.
|
||
##
|
||
## In a nutshell,t a *red-black tree* emulates a *b-tree* by replacing a
|
||
## b-tree node
|
||
## ::
|
||
## | a, b, c
|
||
## | / | | \
|
||
##
|
||
## by red or black colored binary nodes
|
||
## ::
|
||
## | b
|
||
## | <black>
|
||
## | a / \ c
|
||
## | <red> <red>
|
||
## | / \ / \
|
||
##
|
||
## So, apart from insert and delete operations which are basically masked
|
||
## *b-tree* operations, search and traversal tools for binary trees can be
|
||
## used for *red-black trees* as well.
|
||
##
|
||
## Red-black tree module interface components
|
||
## ------------------------------------------
|
||
##
|
||
## :C:
|
||
## Opaque data type: It is a comparable contents or data container derived
|
||
## from a key data item of type `K` (see comments on `RbMkcFn` type.) This
|
||
## data type `C` must be an object *reference*.
|
||
##
|
||
## :K:
|
||
## Opaque index type: It is used to identify and retrieve some data
|
||
## container of type `C`.
|
||
##
|
||
|
||
# Historic ackn:
|
||
# http://eternallyconfuzzled.com/libs/jsw_rbtree.zip (now defunct)
|
||
#
|
||
# Original copyright notice from jsw_rbtree.h:
|
||
# > Created (Julienne Walker): August 23, 2003
|
||
# > Modified (Julienne Walker): March 14, 2008
|
||
#
|
||
# This code is in the public domain. Anyone may
|
||
# use it or change it in any way that they see
|
||
# fit. The author assumes no responsibility for
|
||
# damages incurred through use of the original
|
||
# code or any variations thereof.
|
||
#
|
||
# It is requested, but not required, that due
|
||
# credit is given to the original author and
|
||
# anyone who has modified the code through
|
||
# a header comment, such as this one.typedef
|
||
|
||
import
|
||
std/[tables],
|
||
../results
|
||
|
||
const
|
||
rbTreeReBalancedFlag* = 1
|
||
rbTreeNodesDeletedFlag* = 2
|
||
rbTreeFlushDataFlag* = 4
|
||
|
||
type
|
||
RbCmpFn*[C,K] = ##\
|
||
## A function of this type compares a `casket` argument against the `key` \
|
||
## argument.
|
||
## The function returns either zero, a positive, or a negaitve integer not
|
||
## unlike `cmp()` for integers or strings. This type of function is used
|
||
## for organising the red-black tree in a sorted manner.
|
||
proc(casket: C; key: K): int {.gcsafe.}
|
||
|
||
RbMkcFn*[C,K] = ##\
|
||
## A function of this type creates a new object `C` from argument key `K`.
|
||
## Given a pair of functions `(cmp,mkc)` of respective types
|
||
## `(RbCmpFn,RbMkcFn)`, the function `mkc` must satisfy
|
||
## ::
|
||
## cmp(mkc(key),key) == 0
|
||
##
|
||
## which is taken for granted and *not* verified by the red-black tree
|
||
## functions. Also, `mkc()` must be injective, i.e.
|
||
## ::
|
||
## key != key' => mkc(key) != mkc(key')
|
||
##
|
||
## Once generated, the value `mkc(key)` of type `C` will be made
|
||
## accessible by the API so that it can be modified but it must be made
|
||
## certain that no modification changes the reverse image of `mkc()`,
|
||
## i.e. for every modification `mod:C -> C` the following must hold
|
||
## ::
|
||
## cmp(mod(mkc(key)),key) == 0
|
||
##
|
||
## A trivial example for `mkc()` would be to return a copy of the argument
|
||
## key and consider it read-only.
|
||
proc(key: K): C {.gcsafe.}
|
||
|
||
RbInfo* = enum ##\
|
||
## Used as code error compinent in `RbResult` function return code.
|
||
rbOk = 0 ## Seldom used (mainly for debugging)
|
||
rbFail ## Just failed something
|
||
rbEmptyTree ## No data yet
|
||
rbNotFound ## No matching entry
|
||
rbExists ## Could not insert as new entry
|
||
|
||
rbEndOfWalk ## All nodes visited
|
||
rbWalkClosed ## This walk has been closed
|
||
rbWalkBlocked ## Tree changed while walking
|
||
|
||
rbVfyRootIsRed ## Debug: Root node is red
|
||
rbVfyRedParentRedLeftLink ## ..
|
||
rbVfyRedParentRedRightLink
|
||
rbVfyRedParentRedBothLinks
|
||
rbVfyLeftLinkGtParent
|
||
rbVfyRightLinkLtParent
|
||
rbVfyBothLinkCmpParentReversed
|
||
rbVfyBlackChainLevelMismatch
|
||
|
||
RbDir* = enum ##\
|
||
## Node link direction, array index.
|
||
## The red-black tree implementation here also requires implicit colour
|
||
## value encodings `false` for black and `true` for red (see getters
|
||
## `isRed()`, `toDir()`, `not()`, and the `isRed=()` setter.)
|
||
rbLeft = 0
|
||
rbRight = 1
|
||
|
||
RbResult*[C] = ##\
|
||
## Combined function return code, data value or errror code.
|
||
Result[C,RbInfo]
|
||
|
||
RbNodeRef*[C] = ref object ##\
|
||
## Node with value container, main component of a red-black tree.
|
||
## These nodes build up the red-black tree (see
|
||
## `eternally confuzzled <https://archive.is/miDT>`_.)
|
||
redColour: bool ## Algorithm dependent colour marker
|
||
link*:array[RbDir,RbNodeRef[C]] ## Left and right tree links, vertex
|
||
casket*: C ## Comparable node data container
|
||
|
||
RbTreeRef*[C,K] = ref object of RootObj ##\
|
||
## Red-black tree descriptor object
|
||
cmpFn: RbCmpFn[C,K] ## Comparison handler
|
||
mkcFn: RbMkcFn[C,K] ## Pseudo-dup handler
|
||
root*: RbNodeRef[C] ## Top of the tree
|
||
cache*: RbNodeRef[C] ## Last node created, found etc.
|
||
size*: int ## Number of node items
|
||
dirty*: int ## Reset walk while tree is manipulated
|
||
walkIdGen: uint ## Id generaror for walks[] table
|
||
walks*: Table[uint,RbWalkRef[C,K]] ## Open walk descriptors list
|
||
|
||
RbWalkRef*[C,K] = ref object of RootObj ##\
|
||
## Traversal descriptor for a red-black tree
|
||
id*: uint ## walks[] table registry
|
||
tree*: RbTreeRef[C,K] ## Paired tree
|
||
node*: RbNodeRef[C] ## Current node
|
||
path*: seq[RbNodeRef[C]] ## Traversal path
|
||
top*: int ## Top of stack
|
||
start*: bool ## `true` after a rewind operation
|
||
stop*: bool ## End of traversal
|
||
|
||
when (NimMajor, NimMinor) < (1, 4):
|
||
{.push raises: [Defect].}
|
||
else:
|
||
{.push raises: [].}
|
||
|
||
# ------------------------------------------------------------------------------
|
||
# Public functions, constructor
|
||
# ------------------------------------------------------------------------------
|
||
|
||
proc newRbTreeRef*[C,K](cmp: RbCmpFn[C,K]; mkc: RbMkcFn[C,K]): RbTreeRef[C,K] =
|
||
## Constructor. Create generic red-black tree descriptor for data container
|
||
## type `C` and key type `K`. Details about the function arguments `cmpFn`
|
||
## and `mkcFn` are documented with the type definitions of `RbCmpFn` and
|
||
## `RbMkcFn`.
|
||
RbTreeRef[C,K](
|
||
cmpFn: cmp,
|
||
mkcFn: mkc,
|
||
walkIdGen: 1, # next free ID
|
||
walks: initTable[uint,RbWalkRef[C,K]](1))
|
||
|
||
|
||
proc newWalkId*[C,K](rbt: RbTreeRef[C,K]): uint {.inline.} =
|
||
## Generate new free walk ID, returns zero in (theoretical) case all other
|
||
## IDs are exhausted.
|
||
for id in rbt.walkIdGen .. high(type rbt.walkIdGen):
|
||
if not rbt.walks.hasKey(id):
|
||
rbt.walkIdGen = id
|
||
return id
|
||
for id in 1u ..< rbt.walkIdGen:
|
||
if not rbt.walks.hasKey(id):
|
||
rbt.walkIdGen = id
|
||
return id
|
||
0
|
||
|
||
# ------------------------------------------------------------------------------
|
||
# Public handlers
|
||
# ------------------------------------------------------------------------------
|
||
|
||
proc cmp*[C,K](rbt: RbTreeRef[C,K]; casket: C; key: K): int {.inline.} =
|
||
## See introduction for an explanation of opaque argument types `C` and `D`,
|
||
## and the type definition for `RbCmpFn` for properties of this function.
|
||
rbt.cmpFn(casket, key)
|
||
|
||
proc mkc*[C,K](rbt: RbTreeRef[C,K]; key: K): C {.inline.} =
|
||
## See introduction for an explanation of opaque argument/return types `C`
|
||
## and `D`, and the type definition for `RbMkdFn` for properties of this
|
||
## function.
|
||
rbt.mkcFn(key)
|
||
|
||
# ------------------------------------------------------------------------------
|
||
# Public getters
|
||
# ------------------------------------------------------------------------------
|
||
|
||
proc linkLeft*[C](node: RbNodeRef[C]): RbNodeRef[C] {.inline.} =
|
||
## Getter, shortcut for `node.link[rbLeft]`
|
||
node.link[rbLeft]
|
||
|
||
proc linkRight*[C](node: RbNodeRef[C]): RbNodeRef[C] {.inline.} =
|
||
## Getter, shortcut for `node.link[rbRight]`
|
||
node.link[rbRight]
|
||
|
||
proc isRed*[C](node: RbNodeRef[C]): bool {.inline.} =
|
||
## Getter, `true` if node colour is read.
|
||
not node.isNil and node.redColour
|
||
|
||
# ------------------------------------------------------------------------------
|
||
# Public setters
|
||
# ------------------------------------------------------------------------------
|
||
|
||
proc `linkLeft=`*[C](node, child: RbNodeRef[C]) {.inline.} =
|
||
## Getter, shortcut for `node.link[rbLeft] = child`
|
||
node.link[rbLeft] = child
|
||
|
||
proc `linkRight=`*[C](node, child: RbNodeRef[C]) {.inline.} =
|
||
## Getter, shortcut for `node.link[rbRight] = child`
|
||
node.link[rbRight] = child
|
||
|
||
proc `isRed=`*[C](node: RbNodeRef[C]; value: bool) {.inline.} =
|
||
## Setter, `true` sets red node colour.
|
||
node.redColour = value
|
||
|
||
# ------------------------------------------------------------------------------
|
||
# Public helpers: `rbDir` as array index
|
||
# ------------------------------------------------------------------------------
|
||
|
||
proc `not`*(d: RbDir): RbDir {.inline.} =
|
||
## Opposite direction of argument `d`.
|
||
if d == rbLeft: rbRight else: rbLeft
|
||
|
||
proc toDir*(b: bool): RbDir {.inline.} =
|
||
## Convert to link diection `rbLeft` (false) or `rbRight` (true).
|
||
if b: rbRight else: rbLeft
|
||
|
||
# ------------------------------------------------------------------------------
|
||
# Public pretty printer
|
||
# ------------------------------------------------------------------------------
|
||
|
||
proc `$`*[C](node: RbNodeRef[C]): string =
|
||
## Pretty printer, requres `$()` for type `C` to be known.
|
||
if node.isNil:
|
||
return "nil"
|
||
proc colour(red: bool): string =
|
||
if red: "red" else: "black"
|
||
"(" &
|
||
node.isRed.colour & "," &
|
||
$node.casket & "," &
|
||
"left=" & $node.linkLeft & "," &
|
||
"right=" & $node.linkRight & ")"
|
||
|
||
proc `$`*[C,K](rbt: RbTreeRef[C,K]): string =
|
||
## Pretty printer
|
||
if rbt.isNil:
|
||
return "nil"
|
||
"[" &
|
||
"size=" & $rbt.size & "," &
|
||
"gen=" & $rbt.walkIdGen & "," &
|
||
"root=" & $rbt.root & "]"
|
||
|
||
proc `$`*[C,K](w: RbWalkRef[C,K]): string =
|
||
## Pretty printer
|
||
if w.isNil:
|
||
return "nil"
|
||
result = "[id=" & $w.id
|
||
if w.tree.isNil:
|
||
result &= ",tree=nil"
|
||
if w.node.isNil:
|
||
result &= ",node=nil"
|
||
else:
|
||
result &= ",node=" & $w.node.casket
|
||
result &= ",path.len=" & $w.path.len
|
||
if w.start:
|
||
result &= ",start"
|
||
if w.stop:
|
||
result &= ",stop"
|
||
result &= "]"
|
||
|
||
# ------------------------------------------------------------------------------
|
||
# End
|
||
# ------------------------------------------------------------------------------
|