Archives
/
gods
mirror of https://github.com/emirpasic/gods
2
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

- revert some of changes coming from avl tree merge

Browse Source
pull/51/head
Emir Pasic 7 years ago
parent b5004c7e71
commit 6c67eb0b06
19 changed files with 132 additions and 236 deletions
Show Stats Download Patch File Download Diff File

4
maps/treebidimap/enumerable.go
Unescape Escape View File

@ -21,7 +21,7 @@ func (m *Map) Each(f func(key interface{}, value interface{})) {
// Map invokes the given function once for each element and returns a container
// containing the values returned by the given function as key/value pairs.
func (m *Map) Map(f func(key1 interface{}, value1 interface{}) (interface{}, interface{})) *Map {
newMap := NewWithTrees(m.forwardMap.New(), m.inverseMap.New())
newMap := NewWith(m.keyComparator, m.valueComparator)
iterator := m.Iterator()
for iterator.Next() {
key2, value2 := f(iterator.Key(), iterator.Value())
@ -32,7 +32,7 @@ func (m *Map) Map(f func(key1 interface{}, value1 interface{}) (interface{}, int
// Select returns a new container containing all elements for which the given function returns a true value.
func (m *Map) Select(f func(key interface{}, value interface{}) bool) *Map {
newMap := NewWithTrees(m.forwardMap.New(), m.inverseMap.New())
newMap := NewWith(m.keyComparator, m.valueComparator)
iterator := m.Iterator()
for iterator.Next() {
if f(iterator.Key(), iterator.Value()) {

7
maps/treebidimap/iterator.go
Unescape Escape View File

@ -4,7 +4,10 @@
package treebidimap
import "github.com/emirpasic/gods/containers"
import (
"github.com/emirpasic/gods/containers"
rbt "github.com/emirpasic/gods/trees/redblacktree"
)
func assertIteratorImplementation() {
var _ containers.ReverseIteratorWithKey = (*Iterator)(nil)
@ -12,7 +15,7 @@ func assertIteratorImplementation() {
// Iterator holding the iterator's state
type Iterator struct {
iterator containers.ReverseIteratorWithKey
iterator rbt.Iterator
}
// Iterator returns a stateful iterator whose elements are key/value pairs.

22
maps/treebidimap/treebidimap.go
Unescape Escape View File

@ -19,12 +19,10 @@ package treebidimap
import (
"fmt"
"strings"
"github.com/emirpasic/gods/maps"
"github.com/emirpasic/gods/trees/redblacktree"
"github.com/emirpasic/gods/utils"
"github.com/spewspews/gods/trees"
"github.com/spewspews/gods/trees/redblacktree"
"strings"
)
func assertMapImplementation() {
@ -33,8 +31,10 @@ func assertMapImplementation() {
// Map holds the elements in two red-black trees.
type Map struct {
forwardMap trees.Tree
inverseMap trees.Tree
forwardMap redblacktree.Tree
inverseMap redblacktree.Tree
keyComparator utils.Comparator
valueComparator utils.Comparator
}
type data struct {
@ -45,8 +45,10 @@ type data struct {
// NewWith instantiates a bidirectional map.
func NewWith(keyComparator utils.Comparator, valueComparator utils.Comparator) *Map {
return &Map{
forwardMap: redblacktree.NewWith(keyComparator),
inverseMap: redblacktree.NewWith(valueComparator),
forwardMap: *redblacktree.NewWith(keyComparator),
inverseMap: *redblacktree.NewWith(valueComparator),
keyComparator: keyComparator,
valueComparator: valueComparator,
}
}
@ -60,10 +62,6 @@ func NewWithStringComparators() *Map {
return NewWith(utils.StringComparator, utils.StringComparator)
}
func NewWithTrees(forwardTree trees.Tree, inverseTree trees.Tree) *Map {
return &Map{forwardMap: forwardTree, inverseMap: inverseTree}
}
// Put inserts element into the map.
func (m *Map) Put(key interface{}, value interface{}) {
if d, ok := m.forwardMap.Get(key); ok {

9
maps/treemap/enumerable.go
Unescape Escape View File

@ -4,7 +4,10 @@
package treemap
import "github.com/emirpasic/gods/containers"
import (
"github.com/emirpasic/gods/containers"
rbt "github.com/emirpasic/gods/trees/redblacktree"
)
func assertEnumerableImplementation() {
var _ containers.EnumerableWithKey = (*Map)(nil)
@ -21,7 +24,7 @@ func (m *Map) Each(f func(key interface{}, value interface{})) {
// Map invokes the given function once for each element and returns a container
// containing the values returned by the given function as key/value pairs.
func (m *Map) Map(f func(key1 interface{}, value1 interface{}) (interface{}, interface{})) *Map {
newMap := &Map{tree: m.tree.New()}
newMap := &Map{tree: rbt.NewWith(m.tree.Comparator)}
iterator := m.Iterator()
for iterator.Next() {
key2, value2 := f(iterator.Key(), iterator.Value())
@ -32,7 +35,7 @@ func (m *Map) Map(f func(key1 interface{}, value1 interface{}) (interface{}, int
// Select returns a new container containing all elements for which the given function returns a true value.
func (m *Map) Select(f func(key interface{}, value interface{}) bool) *Map {
newMap := &Map{tree: m.tree.New()}
newMap := &Map{tree: rbt.NewWith(m.tree.Comparator)}
iterator := m.Iterator()
for iterator.Next() {
if f(iterator.Key(), iterator.Value()) {

7
maps/treemap/iterator.go
Unescape Escape View File

@ -4,7 +4,10 @@
package treemap
import "github.com/emirpasic/gods/containers"
import (
"github.com/emirpasic/gods/containers"
rbt "github.com/emirpasic/gods/trees/redblacktree"
)
func assertIteratorImplementation() {
var _ containers.ReverseIteratorWithKey = (*Iterator)(nil)
@ -12,7 +15,7 @@ func assertIteratorImplementation() {
// Iterator holding the iterator's state
type Iterator struct {
iterator containers.ReverseIteratorWithKey
iterator rbt.Iterator
}
// Iterator returns a stateful iterator whose elements are key/value pairs.

20
maps/treemap/treemap.go
Unescape Escape View File

@ -14,8 +14,7 @@ package treemap
import (
"fmt"
"github.com/emirpasic/gods/maps"
rbt "github.com/spewspews/gods/trees/redblacktree"
"github.com/spewspews/gods/trees"
rbt "github.com/emirpasic/gods/trees/redblacktree"
"github.com/emirpasic/gods/utils"
"strings"
)
@ -26,7 +25,7 @@ func assertMapImplementation() {
// Map holds the elements in a red-black tree
type Map struct {
tree trees.Tree
tree *rbt.Tree
}
// NewWith instantiates a tree map with the custom comparator.
@ -44,11 +43,6 @@ func NewWithStringComparator() *Map {
return &Map{tree: rbt.NewWithStringComparator()}
}
// NewWithTree instantiates a new empty map with given tree
func NewWithTree(tree trees.Tree) *Map {
return &Map{tree: tree}
}
// Put inserts key-value pair into the map.
// Key should adhere to the comparator's type assertion, otherwise method panics.
func (m *Map) Put(key interface{}, value interface{}) {
@ -96,13 +90,19 @@ func (m *Map) Clear() {
// Min returns the minimum key and its value from the tree map.
// Returns nil, nil if map is empty.
func (m *Map) Min() (key interface{}, value interface{}) {
return m.tree.Min()
if node := m.tree.Left(); node != nil {
return node.Key, node.Value
}
return nil, nil
}
// Max returns the maximum key and its value from the tree map.
// Returns nil, nil if map is empty.
func (m *Map) Max() (key interface{}, value interface{}) {
return m.tree.Max()
if node := m.tree.Right(); node != nil {
return node.Key, node.Value
}
return nil, nil
}
// String returns a string representation of container

44
maps/treemap/treemap_test.go
Unescape Escape View File

@ -7,8 +7,6 @@ package treemap
import (
"fmt"
"testing"
"github.com/spewspews/gods/trees/avltree"
)
func TestMapPut(t *testing.T) {
@ -53,48 +51,6 @@ func TestMapPut(t *testing.T) {
}
}
func TestMapAVLPut(t *testing.T) {
m := NewWithTree(avltree.NewWithIntComparator())
m.Put(5, "e")
m.Put(6, "f")
m.Put(7, "g")
m.Put(3, "c")
m.Put(4, "d")
m.Put(1, "x")
m.Put(2, "b")
m.Put(1, "a") //overwrite
if actualValue := m.Size(); actualValue != 7 {
t.Errorf("Got %v expected %v", actualValue, 7)
}
if actualValue, expectedValue := m.Keys(), []interface{}{1, 2, 3, 4, 5, 6, 7}; !sameElements(actualValue, expectedValue) {
t.Errorf("Got %v expected %v", actualValue, expectedValue)
}
if actualValue, expectedValue := m.Values(), []interface{}{"a", "b", "c", "d", "e", "f", "g"}; !sameElements(actualValue, expectedValue) {
t.Errorf("Got %v expected %v", actualValue, expectedValue)
}
// key,expectedValue,expectedFound
tests1 := [][]interface{}{
{1, "a", true},
{2, "b", true},
{3, "c", true},
{4, "d", true},
{5, "e", true},
{6, "f", true},
{7, "g", true},
{8, nil, false},
}
for _, test := range tests1 {
// retrievals
actualValue, actualFound := m.Get(test[0])
if actualValue != test[1] || actualFound != test[2] {
t.Errorf("Got %v expected %v", actualValue, test[1])
}
}
}
func TestMapRemove(t *testing.T) {
m := NewWithIntComparator()
m.Put(5, "e")

9
sets/treeset/enumerable.go
Unescape Escape View File

@ -4,7 +4,10 @@
package treeset
import "github.com/emirpasic/gods/containers"
import (
"github.com/emirpasic/gods/containers"
rbt "github.com/emirpasic/gods/trees/redblacktree"
)
func assertEnumerableImplementation() {
var _ containers.EnumerableWithIndex = (*Set)(nil)
@ -21,7 +24,7 @@ func (set *Set) Each(f func(index int, value interface{})) {
// Map invokes the given function once for each element and returns a
// container containing the values returned by the given function.
func (set *Set) Map(f func(index int, value interface{}) interface{}) *Set {
newSet := &Set{tree: set.tree.New()}
newSet := &Set{tree: rbt.NewWith(set.tree.Comparator)}
iterator := set.Iterator()
for iterator.Next() {
newSet.Add(f(iterator.Index(), iterator.Value()))
@ -31,7 +34,7 @@ func (set *Set) Map(f func(index int, value interface{}) interface{}) *Set {
// Select returns a new container containing all elements for which the given function returns a true value.
func (set *Set) Select(f func(index int, value interface{}) bool) *Set {
newSet := NewWithTree(set.tree.New())
newSet := &Set{tree: rbt.NewWith(set.tree.Comparator)}
iterator := set.Iterator()
for iterator.Next() {
if f(iterator.Index(), iterator.Value()) {

6
sets/treeset/iterator.go
Unescape Escape View File

@ -6,7 +6,7 @@ package treeset
import (
"github.com/emirpasic/gods/containers"
"github.com/spewspews/gods/trees"
rbt "github.com/emirpasic/gods/trees/redblacktree"
)
func assertIteratorImplementation() {
@ -16,8 +16,8 @@ func assertIteratorImplementation() {
// Iterator returns a stateful iterator whose values can be fetched by an index.
type Iterator struct {
index int
iterator containers.ReverseIteratorWithKey
tree trees.Tree
iterator rbt.Iterator
tree *rbt.Tree
}
// Iterator holding the iterator's state

13
sets/treeset/treeset.go
Unescape Escape View File

@ -11,12 +11,10 @@ package treeset
import (
"fmt"
"strings"
"github.com/emirpasic/gods/sets"
rbt "github.com/emirpasic/gods/trees/redblacktree"
"github.com/emirpasic/gods/utils"
"github.com/spewspews/gods/trees"
rbt "github.com/spewspews/gods/trees/redblacktree"
"strings"
)
func assertSetImplementation() {
@ -25,7 +23,7 @@ func assertSetImplementation() {
// Set holds elements in a red-black tree
type Set struct {
tree trees.Tree
tree *rbt.Tree
}
var itemExists = struct{}{}
@ -45,11 +43,6 @@ func NewWithStringComparator() *Set {
return &Set{tree: rbt.NewWithStringComparator()}
}
// NewWithTree instantiates a new empty set with given tree
func NewWithTree(tree trees.Tree) *Set {
return &Set{tree: tree}
}
// Add adds the items (one or more) to the set.
func (set *Set) Add(items ...interface{}) {
for _, item := range items {

20
sets/treeset/treeset_test.go
Unescape Escape View File

@ -7,8 +7,6 @@ package treeset
import (
"fmt"
"testing"
"github.com/spewspews/gods/trees/avltree"
)
func TestSetAdd(t *testing.T) {
@ -29,24 +27,6 @@ func TestSetAdd(t *testing.T) {
}
}
func TestSetAVLAdd(t *testing.T) {
set := NewWithTree(avltree.NewWithIntComparator())
set.Add()
set.Add(1)
set.Add(2)
set.Add(2, 3)
set.Add()
if actualValue := set.Empty(); actualValue != false {
t.Errorf("Got %v expected %v", actualValue, false)
}
if actualValue := set.Size(); actualValue != 3 {
t.Errorf("Got %v expected %v", actualValue, 3)
}
if actualValue, expectedValue := fmt.Sprintf("%d%d%d", set.Values()...), "123"; actualValue != expectedValue {
t.Errorf("Got %v expected %v", actualValue, expectedValue)
}
}
func TestSetContains(t *testing.T) {
set := NewWithIntComparator()
set.Add(3, 1, 2)

7
trees/binaryheap/binaryheap.go
Unescape Escape View File

@ -13,15 +13,14 @@ package binaryheap
import (
"fmt"
"strings"
"github.com/emirpasic/gods/containers"
"github.com/emirpasic/gods/lists/arraylist"
"github.com/emirpasic/gods/trees"
"github.com/emirpasic/gods/utils"
"strings"
)
func assertTreeImplementation() {
var _ containers.Container = (*Heap)(nil)
var _ trees.Tree = (*Heap)(nil)
}
// Heap holds elements in an array-list

32
trees/btree/btree.go
Unescape Escape View File

@ -19,7 +19,7 @@ package btree
import (
"bytes"
"fmt"
"github.com/spewspews/gods/trees"
"github.com/emirpasic/gods/trees"
"github.com/emirpasic/gods/utils"
"strings"
)
@ -31,7 +31,7 @@ func assertTreeImplementation() {
// Tree holds elements of the B-tree
type Tree struct {
Root *Node // Root node
comparator utils.Comparator // Key comparator
Comparator utils.Comparator // Key comparator
size int // Total number of keys in the tree
m int // order (maximum number of children)
}
@ -54,7 +54,7 @@ func NewWith(order int, comparator utils.Comparator) *Tree {
if order < 3 {
panic("Invalid order, should be at least 3")
}
return &Tree{m: order, comparator: comparator}
return &Tree{m: order, Comparator: comparator}
}
// NewWithIntComparator instantiates a B-tree with the order (maximum number of children) and the IntComparator, i.e. keys are of type int.
@ -105,11 +105,6 @@ func (tree *Tree) Remove(key interface{}) {
}
}
// New returns an empty tree with the same comparator
func (tree *Tree) New() trees.Tree {
return &Tree{m: tree.m, comparator: tree.comparator}
}
// Empty returns true if tree does not contain any nodes
func (tree *Tree) Empty() bool {
return tree.size == 0
@ -172,15 +167,6 @@ func (tree *Tree) LeftValue() interface{} {
return nil
}
// Min returns the minimum key value pair in the tree.
func (tree *Tree) Min() (interface{}, interface{}) {
n := tree.Left()
if n == nil {
return nil, nil
}
return n.Entries[0].Key, n.Entries[0].Value
}
// Right returns the right-most (max) node or nil if tree is empty.
func (tree *Tree) Right() *Node {
return tree.right(tree.Root)
@ -202,16 +188,6 @@ func (tree *Tree) RightValue() interface{} {
return nil
}
// Max returns the minimum key value pair in the tree.
func (tree *Tree) Max() (interface{}, interface{}) {
n := tree.Right()
if n == nil {
return nil, nil
}
l := len(n.Entries)-1
return n.Entries[l].Key, n.Entries[l].Value
}
// String returns a string representation of container (for debugging purposes)
func (tree *Tree) String() string {
var buffer bytes.Buffer
@ -290,7 +266,7 @@ func (tree *Tree) search(node *Node, key interface{}) (index int, found bool) {
var mid int
for low <= high {
mid = (high + low) / 2
compare := tree.comparator(key, node.Entries[mid].Key)
compare := tree.Comparator(key, node.Entries[mid].Key)
switch {
case compare > 0:
low = mid + 1

41
trees/btree/btree_test.go
Unescape Escape View File

@ -929,17 +929,25 @@ func TestBTreeIteratorBegin(t *testing.T) {
tree.Put(2, "b")
it := tree.Iterator()
if it.node != nil {
t.Errorf("Got %v expected %v", it.node, nil)
}
it.Begin()
i := 0
for it.Next() {
i++
if it.node != nil {
t.Errorf("Got %v expected %v", it.node, nil)
}
if i != 3 {
t.Errorf("Got %d expected %d\n", i, tree.Size())
for it.Next() {
}
it.Begin()
if it.node != nil {
t.Errorf("Got %v expected %v", it.node, nil)
}
it.Next()
if key, value := it.Key(), it.Value(); key != 1 || value != "a" {
t.Errorf("Got %v,%v expected %v,%v", key, value, 1, "a")
@ -948,22 +956,25 @@ func TestBTreeIteratorBegin(t *testing.T) {
func TestBTreeIteratorEnd(t *testing.T) {
tree := NewWithIntComparator(3)
tree.Put(3, "c")
tree.Put(1, "a")
tree.Put(2, "b")
it := tree.Iterator()
it.End()
i := 0
for it.Prev() {
i++
if it.node != nil {
t.Errorf("Got %v expected %v", it.node, nil)
}
if i != 3 {
t.Errorf("Got %d expected %d\n", i, tree.Size())
it.End()
if it.node != nil {
t.Errorf("Got %v expected %v", it.node, nil)
}
tree.Put(3, "c")
tree.Put(1, "a")
tree.Put(2, "b")
it.End()
if it.node != nil {
t.Errorf("Got %v expected %v", it.node, nil)
}
it.Prev()
if key, value := it.Key(), it.Value(); key != 3 || value != "c" {
t.Errorf("Got %v,%v expected %v,%v", key, value, 3, "c")

12
trees/btree/iterator.go
Unescape Escape View File

@ -25,8 +25,8 @@ const (
)
// Iterator returns a stateful iterator whose elements are key/value pairs.
func (tree *Tree) Iterator() containers.ReverseIteratorWithKey {
return &Iterator{tree: tree, node: nil, position: begin}
func (tree *Tree) Iterator() Iterator {
return Iterator{tree: tree, node: nil, position: begin}
}
// Next moves the iterator to the next element and returns true if there was a next element in the container.
@ -80,11 +80,11 @@ func (iterator *Iterator) Next() bool {
}
}
end:
end:
iterator.End()
return false
between:
between:
iterator.position = between
return true
}
@ -139,11 +139,11 @@ func (iterator *Iterator) Prev() bool {
}
}
begin:
begin:
iterator.Begin()
return false
between:
between:
iterator.position = between
return true
}

16
trees/redblacktree/iterator.go
Unescape Escape View File

@ -24,8 +24,8 @@ const (
)
// Iterator returns a stateful iterator whose elements are key/value pairs.
func (tree *Tree) Iterator() containers.ReverseIteratorWithKey {
return &Iterator{tree: tree, node: nil, position: begin}
func (tree *Tree) Iterator() Iterator {
return Iterator{tree: tree, node: nil, position: begin}
}
// Next moves the iterator to the next element and returns true if there was a next element in the container.
@ -55,18 +55,18 @@ func (iterator *Iterator) Next() bool {
node := iterator.node
for iterator.node.Parent != nil {
iterator.node = iterator.node.Parent
if iterator.tree.comparator(node.Key, iterator.node.Key) <= 0 {
if iterator.tree.Comparator(node.Key, iterator.node.Key) <= 0 {
goto between
}
}
}
end:
end:
iterator.node = nil
iterator.position = end
return false
between:
between:
iterator.position = between
return true
}
@ -97,18 +97,18 @@ func (iterator *Iterator) Prev() bool {
node := iterator.node
for iterator.node.Parent != nil {
iterator.node = iterator.node.Parent
if iterator.tree.comparator(node.Key, iterator.node.Key) >= 0 {
if iterator.tree.Comparator(node.Key, iterator.node.Key) >= 0 {
goto between
}
}
}
begin:
begin:
iterator.node = nil
iterator.position = begin
return false
between:
between:
iterator.position = between
return true
}

49
trees/redblacktree/redblacktree.go
Unescape Escape View File

@ -13,9 +13,8 @@ package redblacktree
import (
"fmt"
"github.com/emirpasic/gods/trees"
"github.com/emirpasic/gods/utils"
"github.com/spewspews/gods/trees"
)
func assertTreeImplementation() {
@ -32,7 +31,7 @@ const (
type Tree struct {
Root *Node
size int
comparator utils.Comparator
Comparator utils.Comparator
}
// Node is a single element within the tree
@ -47,27 +46,17 @@ type Node struct {
// NewWith instantiates a red-black tree with the custom comparator.
func NewWith(comparator utils.Comparator) *Tree {
return &Tree{comparator: comparator}
return &Tree{Comparator: comparator}
}
// NewWithIntComparator instantiates a red-black tree with the IntComparator, i.e. keys are of type int.
func NewWithIntComparator() *Tree {
return &Tree{comparator: utils.IntComparator}
return &Tree{Comparator: utils.IntComparator}
}
// NewWithStringComparator instantiates a red-black tree with the StringComparator, i.e. keys are of type string.
func NewWithStringComparator() *Tree {
return &Tree{comparator: utils.StringComparator}
}
// Comparator returns the comparator function for the tree.
func (tree *Tree) Comparator() utils.Comparator {
return tree.comparator
}
// New returns a new empty tree with the same comparator.
func (tree *Tree) New() trees.Tree {
return &Tree{comparator: tree.comparator}
return &Tree{Comparator: utils.StringComparator}
}
// Put inserts node into the tree.
@ -80,7 +69,7 @@ func (tree *Tree) Put(key interface{}, value interface{}) {
node := tree.Root
loop := true
for loop {
compare := tree.comparator(key, node.Key)
compare := tree.Comparator(key, node.Key)
switch {
case compare == 0:
node.Key = key
@ -203,26 +192,6 @@ func (tree *Tree) Right() *Node {
return parent
}
// Min returns the minimum key value pair of the AVL tree
// or nils if the tree is empty.
func (tree *Tree) Min() (interface{}, interface{}) {
n := tree.Left()
if n == nil {
return nil, nil
}
return n.Key, n.Value
}
// Max returns the minimum key value pair of the AVL tree
// or nils if the tree is empty.
func (tree *Tree) Max() (interface{}, interface{}) {
n := tree.Right()
if n == nil {
return nil, nil
}
return n.Key, n.Value
}
// Floor Finds floor node of the input key, return the floor node or nil if no ceiling is found.
// Second return parameter is true if floor was found, otherwise false.
//
@ -235,7 +204,7 @@ func (tree *Tree) Floor(key interface{}) (floor *Node, found bool) {
found = false
node := tree.Root
for node != nil {
compare := tree.comparator(key, node.Key)
compare := tree.Comparator(key, node.Key)
switch {
case compare == 0:
return node, true
@ -264,7 +233,7 @@ func (tree *Tree) Ceiling(key interface{}) (ceiling *Node, found bool) {
found = false
node := tree.Root
for node != nil {
compare := tree.comparator(key, node.Key)
compare := tree.Comparator(key, node.Key)
switch {
case compare == 0:
return node, true
@ -331,7 +300,7 @@ func output(node *Node, prefix string, isTail bool, str *string) {
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

41
trees/redblacktree/redblacktree_test.go
Unescape Escape View File

@ -477,17 +477,25 @@ func TestRedBlackTreeIteratorBegin(t *testing.T) {
tree.Put(2, "b")
it := tree.Iterator()
if it.node != nil {
t.Errorf("Got %v expected %v", it.node, nil)
}
it.Begin()
i := 0
for it.Next() {
i++
if it.node != nil {
t.Errorf("Got %v expected %v", it.node, nil)
}
if i != 3 {
t.Errorf("Got %d expected %d\n", i, tree.Size())
for it.Next() {
}
it.Begin()
if it.node != nil {
t.Errorf("Got %v expected %v", it.node, nil)
}
it.Next()
if key, value := it.Key(), it.Value(); key != 1 || value != "a" {
t.Errorf("Got %v,%v expected %v,%v", key, value, 1, "a")
@ -496,22 +504,25 @@ func TestRedBlackTreeIteratorBegin(t *testing.T) {
func TestRedBlackTreeIteratorEnd(t *testing.T) {
tree := NewWithIntComparator()
tree.Put(3, "c")
tree.Put(1, "a")
tree.Put(2, "b")
it := tree.Iterator()
it.End()
i := 0
for it.Prev() {
i++
if it.node != nil {
t.Errorf("Got %v expected %v", it.node, nil)
}
if i != 3 {
t.Errorf("Got %d expected %d\n", i, tree.Size())
it.End()
if it.node != nil {
t.Errorf("Got %v expected %v", it.node, nil)
}
tree.Put(3, "c")
tree.Put(1, "a")
tree.Put(2, "b")
it.End()
if it.node != nil {
t.Errorf("Got %v expected %v", it.node, nil)
}
it.Prev()
if key, value := it.Key(), it.Value(); key != 3 || value != "c" {
t.Errorf("Got %v,%v expected %v,%v", key, value, 3, "c")

9
trees/trees.go
Unescape Escape View File

@ -13,15 +13,6 @@ import "github.com/emirpasic/gods/containers"
// Tree interface that all trees implement
type Tree interface {
New() Tree
Iterator() containers.ReverseIteratorWithKey
Put(key interface{}, value interface{})
Remove(key interface{})
Get(key interface{}) (interface{}, bool)
Keys() []interface{}
Min() (interface{}, interface{})
Max() (interface{}, interface{})
containers.Container
// Empty() bool
// Size() int

Write Preview
Loading…
Cancel
Save