From 8dab13c925024f329b774c80a33a11f08b427387 Mon Sep 17 00:00:00 2001 From: Emir Pasic Date: Wed, 23 Mar 2016 05:40:01 +0100 Subject: [PATCH 1/2] - expose the root of the red-black tree to allow custom tree traversal --- trees/redblacktree/redblacktree.go | 282 ++++++++++++++--------------- 1 file changed, 141 insertions(+), 141 deletions(-) diff --git a/trees/redblacktree/redblacktree.go b/trees/redblacktree/redblacktree.go index 42a8553..6e527fe 100644 --- a/trees/redblacktree/redblacktree.go +++ b/trees/redblacktree/redblacktree.go @@ -49,18 +49,18 @@ const ( ) type Tree struct { - root *node + Root *Node size int comparator utils.Comparator } -type node struct { - key interface{} - value interface{} +type Node struct { + Key interface{} + Value interface{} color color - left *node - right *node - parent *node + Left *Node + Right *Node + Parent *Node } // Instantiates a red-black tree with the custom comparator. @@ -81,35 +81,35 @@ func NewWithStringComparator() *Tree { // Inserts node into the tree. // Key should adhere to the comparator's type assertion, otherwise method panics. func (tree *Tree) Put(key interface{}, value interface{}) { - insertedNode := &node{key: key, value: value, color: red} - if tree.root == nil { - tree.root = insertedNode + insertedNode := &Node{Key: key, Value: value, color: red} + if tree.Root == nil { + tree.Root = insertedNode } else { - node := tree.root + node := tree.Root loop := true for loop { - compare := tree.comparator(key, node.key) + compare := tree.comparator(key, node.Key) switch { case compare == 0: - node.value = value + node.Value = value return case compare < 0: - if node.left == nil { - node.left = insertedNode + if node.Left == nil { + node.Left = insertedNode loop = false } else { - node = node.left + node = node.Left } case compare > 0: - if node.right == nil { - node.right = insertedNode + if node.Right == nil { + node.Right = insertedNode loop = false } else { - node = node.right + node = node.Right } } } - insertedNode.parent = node + insertedNode.Parent = node } tree.insertCase1(insertedNode) tree.size += 1 @@ -121,7 +121,7 @@ func (tree *Tree) Put(key interface{}, value interface{}) { func (tree *Tree) Get(key interface{}) (value interface{}, found bool) { node := tree.lookup(key) if node != nil { - return node.value, true + return node.Value, true } return nil, false } @@ -129,29 +129,29 @@ func (tree *Tree) Get(key interface{}) (value interface{}, found bool) { // Remove the node from the tree by key. // Key should adhere to the comparator's type assertion, otherwise method panics. func (tree *Tree) Remove(key interface{}) { - var child *node + var child *Node node := tree.lookup(key) if node == nil { return } - if node.left != nil && node.right != nil { - pred := node.left.maximumNode() - node.key = pred.key - node.value = pred.value + if node.Left != nil && node.Right != nil { + pred := node.Left.maximumNode() + node.Key = pred.Key + node.Value = pred.Value node = pred } - if node.left == nil || node.right == nil { - if node.right == nil { - child = node.left + if node.Left == nil || node.Right == nil { + if node.Right == nil { + child = node.Left } else { - child = node.right + child = node.Right } if node.color == black { node.color = nodeColor(child) tree.deleteCase1(node) } tree.replaceNode(node, child) - if node.parent == nil && child != nil { + if node.Parent == nil && child != nil { child.color = black } } @@ -172,7 +172,7 @@ func (tree *Tree) Size() int { func (tree *Tree) Keys() []interface{} { keys := make([]interface{}, tree.size) for i, node := range tree.inOrder() { - keys[i] = node.key + keys[i] = node.Key } return keys } @@ -181,48 +181,48 @@ func (tree *Tree) Keys() []interface{} { func (tree *Tree) Values() []interface{} { values := make([]interface{}, tree.size) for i, node := range tree.inOrder() { - values[i] = node.value + values[i] = node.Value } return values } // Removes all nodes from the tree. func (tree *Tree) Clear() { - tree.root = nil + tree.Root = nil tree.size = 0 } func (tree *Tree) String() string { str := "RedBlackTree\n" if !tree.Empty() { - output(tree.root, "", true, &str) + output(tree.Root, "", true, &str) } return str } -func (node *node) String() string { - return fmt.Sprintf("%v", node.key) +func (node *Node) String() string { + return fmt.Sprintf("%v", node.Key) } // Returns all nodes in order -func (tree *Tree) inOrder() []*node { - nodes := make([]*node, tree.size) +func (tree *Tree) inOrder() []*Node { + nodes := make([]*Node, tree.size) if tree.size > 0 { - current := tree.root + current := tree.Root stack := linkedliststack.New() done := false count := 0 for !done { if current != nil { stack.Push(current) - current = current.left + current = current.Left } else { if !stack.Empty() { currentPop, _ := stack.Pop() - current = currentPop.(*node) + current = currentPop.(*Node) nodes[count] = current count += 1 - current = current.right + current = current.Right } else { done = true } @@ -232,15 +232,15 @@ func (tree *Tree) inOrder() []*node { return nodes } -func output(node *node, prefix string, isTail bool, str *string) { - if node.right != nil { +func output(node *Node, prefix string, isTail bool, str *string) { + if node.Right != nil { newPrefix := prefix if isTail { newPrefix += "│ " } else { newPrefix += " " } - output(node.right, newPrefix, false, str) + output(node.Right, newPrefix, false, str) } *str += prefix if isTail { @@ -249,114 +249,114 @@ func output(node *node, prefix string, isTail bool, str *string) { *str += "┌── " } *str += node.String() + "\n" - if node.left != nil { + if node.Left != nil { newPrefix := prefix if isTail { newPrefix += " " } else { newPrefix += "│ " } - output(node.left, newPrefix, true, str) + output(node.Left, newPrefix, true, str) } } -func (tree *Tree) lookup(key interface{}) *node { - node := tree.root +func (tree *Tree) lookup(key interface{}) *Node { + node := tree.Root for node != nil { - compare := tree.comparator(key, node.key) + compare := tree.comparator(key, node.Key) switch { case compare == 0: return node case compare < 0: - node = node.left + node = node.Left case compare > 0: - node = node.right + node = node.Right } } return nil } -func (node *node) grandparent() *node { - if node != nil && node.parent != nil { - return node.parent.parent +func (node *Node) grandparent() *Node { + if node != nil && node.Parent != nil { + return node.Parent.Parent } return nil } -func (node *node) uncle() *node { - if node == nil || node.parent == nil || node.parent.parent == nil { +func (node *Node) uncle() *Node { + if node == nil || node.Parent == nil || node.Parent.Parent == nil { return nil } - return node.parent.sibling() + return node.Parent.sibling() } -func (node *node) sibling() *node { - if node == nil || node.parent == nil { +func (node *Node) sibling() *Node { + if node == nil || node.Parent == nil { return nil } - if node == node.parent.left { - return node.parent.right + if node == node.Parent.Left { + return node.Parent.Right } else { - return node.parent.left + return node.Parent.Left } } -func (tree *Tree) rotateLeft(node *node) { - right := node.right +func (tree *Tree) rotateLeft(node *Node) { + right := node.Right tree.replaceNode(node, right) - node.right = right.left - if right.left != nil { - right.left.parent = node + node.Right = right.Left + if right.Left != nil { + right.Left.Parent = node } - right.left = node - node.parent = right + right.Left = node + node.Parent = right } -func (tree *Tree) rotateRight(node *node) { - left := node.left +func (tree *Tree) rotateRight(node *Node) { + left := node.Left tree.replaceNode(node, left) - node.left = left.right - if left.right != nil { - left.right.parent = node + node.Left = left.Right + if left.Right != nil { + left.Right.Parent = node } - left.right = node - node.parent = left + left.Right = node + node.Parent = left } -func (tree *Tree) replaceNode(old *node, new *node) { - if old.parent == nil { - tree.root = new +func (tree *Tree) replaceNode(old *Node, new *Node) { + if old.Parent == nil { + tree.Root = new } else { - if old == old.parent.left { - old.parent.left = new + if old == old.Parent.Left { + old.Parent.Left = new } else { - old.parent.right = new + old.Parent.Right = new } } if new != nil { - new.parent = old.parent + new.Parent = old.Parent } } -func (tree *Tree) insertCase1(node *node) { - if node.parent == nil { +func (tree *Tree) insertCase1(node *Node) { + if node.Parent == nil { node.color = black } else { tree.insertCase2(node) } } -func (tree *Tree) insertCase2(node *node) { - if nodeColor(node.parent) == black { +func (tree *Tree) insertCase2(node *Node) { + if nodeColor(node.Parent) == black { return } tree.insertCase3(node) } -func (tree *Tree) insertCase3(node *node) { +func (tree *Tree) insertCase3(node *Node) { uncle := node.uncle() if nodeColor(uncle) == red { - node.parent.color = black + node.Parent.color = black uncle.color = black node.grandparent().color = red tree.insertCase1(node.grandparent()) @@ -365,121 +365,121 @@ func (tree *Tree) insertCase3(node *node) { } } -func (tree *Tree) insertCase4(node *node) { +func (tree *Tree) insertCase4(node *Node) { grandparent := node.grandparent() - if node == node.parent.right && node.parent == grandparent.left { - tree.rotateLeft(node.parent) - node = node.left - } else if node == node.parent.left && node.parent == grandparent.right { - tree.rotateRight(node.parent) - node = node.right + if node == node.Parent.Right && node.Parent == grandparent.Left { + tree.rotateLeft(node.Parent) + node = node.Left + } else if node == node.Parent.Left && node.Parent == grandparent.Right { + tree.rotateRight(node.Parent) + node = node.Right } tree.insertCase5(node) } -func (tree *Tree) insertCase5(node *node) { - node.parent.color = black +func (tree *Tree) insertCase5(node *Node) { + node.Parent.color = black grandparent := node.grandparent() grandparent.color = red - if node == node.parent.left && node.parent == grandparent.left { + if node == node.Parent.Left && node.Parent == grandparent.Left { tree.rotateRight(grandparent) - } else if node == node.parent.right && node.parent == grandparent.right { + } else if node == node.Parent.Right && node.Parent == grandparent.Right { tree.rotateLeft(grandparent) } } -func (node *node) maximumNode() *node { +func (node *Node) maximumNode() *Node { if node == nil { return nil } - for node.right != nil { - node = node.right + for node.Right != nil { + node = node.Right } return node } -func (tree *Tree) deleteCase1(node *node) { - if node.parent == nil { +func (tree *Tree) deleteCase1(node *Node) { + if node.Parent == nil { return } else { tree.deleteCase2(node) } } -func (tree *Tree) deleteCase2(node *node) { +func (tree *Tree) deleteCase2(node *Node) { sibling := node.sibling() if nodeColor(sibling) == red { - node.parent.color = red + node.Parent.color = red sibling.color = black - if node == node.parent.left { - tree.rotateLeft(node.parent) + if node == node.Parent.Left { + tree.rotateLeft(node.Parent) } else { - tree.rotateRight(node.parent) + tree.rotateRight(node.Parent) } } tree.deleteCase3(node) } -func (tree *Tree) deleteCase3(node *node) { +func (tree *Tree) deleteCase3(node *Node) { sibling := node.sibling() - if nodeColor(node.parent) == black && + if nodeColor(node.Parent) == black && nodeColor(sibling) == black && - nodeColor(sibling.left) == black && - nodeColor(sibling.right) == black { + nodeColor(sibling.Left) == black && + nodeColor(sibling.Right) == black { sibling.color = red - tree.deleteCase1(node.parent) + tree.deleteCase1(node.Parent) } else { tree.deleteCase4(node) } } -func (tree *Tree) deleteCase4(node *node) { +func (tree *Tree) deleteCase4(node *Node) { sibling := node.sibling() - if nodeColor(node.parent) == red && + if nodeColor(node.Parent) == red && nodeColor(sibling) == black && - nodeColor(sibling.left) == black && - nodeColor(sibling.right) == black { + nodeColor(sibling.Left) == black && + nodeColor(sibling.Right) == black { sibling.color = red - node.parent.color = black + node.Parent.color = black } else { tree.deleteCase5(node) } } -func (tree *Tree) deleteCase5(node *node) { +func (tree *Tree) deleteCase5(node *Node) { sibling := node.sibling() - if node == node.parent.left && + if node == node.Parent.Left && nodeColor(sibling) == black && - nodeColor(sibling.left) == red && - nodeColor(sibling.right) == black { + nodeColor(sibling.Left) == red && + nodeColor(sibling.Right) == black { sibling.color = red - sibling.left.color = black + sibling.Left.color = black tree.rotateRight(sibling) - } else if node == node.parent.right && + } else if node == node.Parent.Right && nodeColor(sibling) == black && - nodeColor(sibling.right) == red && - nodeColor(sibling.left) == black { + nodeColor(sibling.Right) == red && + nodeColor(sibling.Left) == black { sibling.color = red - sibling.right.color = black + sibling.Right.color = black tree.rotateLeft(sibling) } tree.deleteCase6(node) } -func (tree *Tree) deleteCase6(node *node) { +func (tree *Tree) deleteCase6(node *Node) { sibling := node.sibling() - sibling.color = nodeColor(node.parent) - node.parent.color = black - if node == node.parent.left && nodeColor(sibling.right) == red { - sibling.right.color = black - tree.rotateLeft(node.parent) - } else if nodeColor(sibling.left) == red { - sibling.left.color = black - tree.rotateRight(node.parent) + sibling.color = nodeColor(node.Parent) + node.Parent.color = black + if node == node.Parent.Left && nodeColor(sibling.Right) == red { + sibling.Right.color = black + tree.rotateLeft(node.Parent) + } else if nodeColor(sibling.Left) == red { + sibling.Left.color = black + tree.rotateRight(node.Parent) } } -func nodeColor(node *node) color { +func nodeColor(node *Node) color { if node == nil { return black } From 87ab028182a904fcf9bd7d79cdf605aafb82841c Mon Sep 17 00:00:00 2001 From: Emir Pasic Date: Wed, 23 Mar 2016 06:22:23 +0100 Subject: [PATCH 2/2] - update documentation to account for changes in the red-black tree (exposing root) --- README.md | 65 ++++++--------- examples/redblacktree.go | 12 +-- examples/redblacktreeextended.go | 135 +++++++++++++++++++++++++++++++ 3 files changed, 166 insertions(+), 46 deletions(-) create mode 100644 examples/redblacktreeextended.go diff --git a/README.md b/README.md index ff6ad5b..b26838c 100644 --- a/README.md +++ b/README.md @@ -39,19 +39,18 @@ type Interface interface { Clear() Values() []interface{} } - ``` Container specific operations: ```go -// Returns sorted container's elements with respect to the passed comparator. +// Returns sorted container's elements with respect to the passed comparator. // Does not effect the ordering of elements within the container. // Uses timsort. func GetSortedValues(container Interface, comparator utils.Comparator) []interface{} { ``` -####Sets +####Sets A set is a data structure that can store elements and 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 structed is often used to ensure that no duplicates are present in a collection. @@ -96,8 +95,6 @@ func main() { set.Empty() // true set.Size() // 0 } - - ``` #####TreeSet @@ -125,7 +122,6 @@ func main() { set.Empty() // true set.Size() // 0 } - ``` ####Lists @@ -220,8 +216,6 @@ func main() { list.Add("a") // ["a"] list.Clear() // [] } - - ``` #####DoublyLinkedList @@ -257,8 +251,6 @@ func main() { list.Add("a") // ["a"] list.Clear() // [] } - - ``` @@ -279,14 +271,13 @@ type Interface interface { // Clear() // Values() []interface{} } - ``` #####LinkedListStack -This stack structure is based on a linked list, i.e. each previous element has a point to the next. +This stack structure is based on a linked list, i.e. each previous element has a point to the next. -All operations are guaranted constant time performance, except _Values()_, which is as always of linear time performance. +All operations are guaranteed constant time performance, except _Values()_, which is as always of linear time performance. ```go package main @@ -307,7 +298,6 @@ func main() { stack.Empty() // true stack.Size() // 0 } - ``` #####ArrayStack @@ -335,8 +325,6 @@ func main() { stack.Empty() // true stack.Size() // 0 } - - ``` ####Maps @@ -361,7 +349,7 @@ type Interface interface { #####HashMap -Map structure based on hash tables, more exactly, Go's map. Keys are unordered. +Map structure based on hash tables, more exactly, Go's map. Keys are unordered. All operations are guaranted constant time performance, except _Key()_ and _Values()_ retrieval that of linear time performance. @@ -384,12 +372,11 @@ func main() { m.Empty() // true m.Size() // 0 } - ``` #####TreeMap -Map structure based on our red-black tree implementation. Keys are ordered with respect to the passed comparator. +Map structure based on our red-black tree implementation. Keys are ordered with respect to the passed comparator. _Put()_, _Get()_ and _Remove()_ are guaranteed log(n) time performance. @@ -414,8 +401,6 @@ func main() { m.Empty() // true m.Size() // 0 } - - ``` ####Trees @@ -432,7 +417,7 @@ type Interface interface { // Values() []interface{} } ``` - + #####RedBlackTree A red–black tree is a binary search tree with an extra bit of data per node, its color, which can be either red or black. The extra bit of storage ensures an approximately balanced tree by constraining how nodes are colored from any path from the root to the leaf. Thus, it is a data structure which is a type of self-balancing binary search tree. @@ -487,9 +472,10 @@ func main() { tree.Empty() // true tree.Size() // 0 } - ``` +Extending the red-black tree's functionality has been demonstrated in the following [example](https://github.com/emirpasic/gods/blob/master/examples/redblacktreeextended.go). + #####BinaryHeap A binary heap is a heap data structure created using a binary tree. It can be seen as a binary tree with two additional constraints: @@ -558,7 +544,7 @@ Return values: -1, if a < b 0, if a == b 1, if a > b - + Comparator signature: type Comparator func(a, b interface{}) int @@ -640,13 +626,13 @@ func byID(a, b interface{}) int { } func main() { - set := treeset.NewWith(byID) + set := treeset.NewWith(byID) set.Add(User{2, "Second"}) set.Add(User{3, "Third"}) set.Add(User{1, "First"}) set.Add(User{4, "Fourth"}) - + fmt.Println(set) // {1 First}, {2 Second}, {3 Third}, {4 Fourth} } ``` @@ -670,38 +656,37 @@ func main() { strings = append(strings, "c") // ["d","a",b","c"] utils.Sort(strings, utils.StringComparator) // ["a","b","c","d"] } - ``` ## Motivations -Collections and data structures found in other languages: Java Collections, C++ Standard Template Library (STL) containers, Qt Containers, etc. +Collections and data structures found in other languages: Java Collections, C++ Standard Template Library (STL) containers, Qt Containers, etc. ## Goals -**Fast algorithms**: +**Fast algorithms**: - Based on decades of knowledge and experiences of other libraries mentioned above. -**Memory efficient algorithms**: - +**Memory efficient algorithms**: + - Avoiding to consume memory by using optimal algorithms and data structures for the given set of problems, e.g. red-black tree in case of TreeMap to avoid keeping redundant sorted array of keys in memory. -**Easy to use library**: - - - Well-structued library with minimalistic set of atomic operations from which more complex operations can be crafted. +**Easy to use library**: + + - Well-structured library with minimalistic set of atomic operations from which more complex operations can be crafted. + +**Stable library**: -**Stable library**: - - Only additions are permitted keeping the library backward compatible. -**Solid documentation and examples**: - +**Solid documentation and examples**: + - Learning by example. -**Production ready**: +**Production ready**: - - Still waiting for the project to mature and be used in some heavy back-end tasks. + - Used in production. There is often a tug of war between speed and memory when crafting algorithms. We choose to optimize for speed in most cases within reasonable limits on memory consumption. diff --git a/examples/redblacktree.go b/examples/redblacktree.go index a5c54ec..8dab4a6 100644 --- a/examples/redblacktree.go +++ b/examples/redblacktree.go @@ -31,7 +31,7 @@ import ( rbt "github.com/emirpasic/gods/trees/redblacktree" ) -func RedBlacTtreeExample() { +func RedBlackTreeExample() { tree := rbt.NewWithIntComparator() // empty(keys are of type int) tree.Put(1, "x") // 1->x @@ -46,11 +46,11 @@ func RedBlacTtreeExample() { // // RedBlackTree // │ ┌── 6 - // │ ┌── 5 - // │ ┌── 4 - // │ │ └── 3 - // └── 2 - // └── 1 + // │ ┌── 5 + // │ ┌── 4 + // │ │ └── 3 + // └── 2 + // └── 1 _ = tree.Values() // []interface {}{"a", "b", "c", "d", "e", "f"} (in order) _ = tree.Keys() // []interface {}{1, 2, 3, 4, 5, 6} (in order) diff --git a/examples/redblacktreeextended.go b/examples/redblacktreeextended.go new file mode 100644 index 0000000..fbb8d6c --- /dev/null +++ b/examples/redblacktreeextended.go @@ -0,0 +1,135 @@ +/* +Copyright (c) 2015, Emir Pasic +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +* Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +* Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +package examples + +import ( + "fmt" + rbt "github.com/emirpasic/gods/trees/redblacktree" +) + +type RedBlackTreeExtended struct { + *rbt.Tree +} + +func (tree *RedBlackTreeExtended) GetMin() (value interface{}, found bool) { + node, found := tree.getMinFromNode(tree.Root) + if node != nil { + return node.Value, found + } else { + return nil, false + } +} + +func (tree *RedBlackTreeExtended) GetMax() (value interface{}, found bool) { + node, found := tree.getMaxFromNode(tree.Root) + if node != nil { + return node.Value, found + } else { + return nil, false + } +} + +func (tree *RedBlackTreeExtended) RemoveMin() (value interface{}, deleted bool) { + node, found := tree.getMinFromNode(tree.Root) + if found { + tree.Remove(node.Key) + return node.Value, found + } else { + return nil, false + } +} + +func (tree *RedBlackTreeExtended) RemoveMax() (value interface{}, deleted bool) { + node, found := tree.getMaxFromNode(tree.Root) + if found { + tree.Remove(node.Key) + return node.Value, found + } else { + return nil, false + } +} + +func (tree *RedBlackTreeExtended) getMinFromNode(node *rbt.Node) (foundNode *rbt.Node, found bool) { + if node == nil { + return nil, false + } + if node.Left == nil { + return node, true + } else { + return tree.getMinFromNode(node.Left) + } +} + +func (tree *RedBlackTreeExtended) getMaxFromNode(node *rbt.Node) (foundNode *rbt.Node, found bool) { + if node == nil { + return nil, false + } + if node.Right == nil { + return node, true + } else { + return tree.getMaxFromNode(node.Right) + } +} + +func print(tree *RedBlackTreeExtended) { + max, _ := tree.GetMax() + min, _ := tree.GetMin() + fmt.Printf("Value for max key: %v \n", max) + fmt.Printf("Value for min key: %v \n", min) + fmt.Println(tree) +} + +func RedBlackTreeExtendedExample() { + tree := RedBlackTreeExtended{rbt.NewWithIntComparator()} + + tree.Put(1, "a") // 1->x (in order) + tree.Put(2, "b") // 1->x, 2->b (in order) + tree.Put(3, "c") // 1->x, 2->b, 3->c (in order) + tree.Put(4, "d") // 1->x, 2->b, 3->c, 4->d (in order) + tree.Put(5, "e") // 1->x, 2->b, 3->c, 4->d, 5->e (in order) + + print(&tree) + // Value for max key: e + // Value for min key: a + // RedBlackTree + // │ ┌── 5 + // │ ┌── 4 + // │ │ └── 3 + // └── 2 + // └── 1 + + tree.RemoveMin() // 2->b, 3->c, 4->d, 5->e (in order) + tree.RemoveMax() // 2->b, 3->c, 4->d (in order) + tree.RemoveMin() // 3->c, 4->d (in order) + tree.RemoveMax() // 3->c (in order) + + print(&tree) + // Value for max key: c + // Value for min key: c + // RedBlackTree + // └── 3 +}