diff --git a/g/container/gtree/gtree_avltree.go b/g/container/gtree/gtree_avltree.go index 87a19e397..a72ad9bbb 100644 --- a/g/container/gtree/gtree_avltree.go +++ b/g/container/gtree/gtree_avltree.go @@ -224,10 +224,11 @@ func (tree *AVLTree) Contains(key interface{}) bool { // Remove remove the node from the tree by key. // Key should adhere to the comparator's type assertion, otherwise method panics. -func (tree *AVLTree) Remove(key interface{}) { +func (tree *AVLTree) Remove(key interface{}) (value interface{}) { tree.mu.Lock() defer tree.mu.Unlock() - tree.remove(key, &tree.root) + value, _ = tree.remove(key, &tree.root) + return } // Removes batch deletes values of the tree by . @@ -414,7 +415,7 @@ func (tree *AVLTree) Flip(comparator...func(v1, v2 interface{}) int) { t = NewAVLTree(tree.comparator, !tree.mu.IsSafe()) } tree.IteratorAsc(func(key, value interface{}) bool { - tree.put(value, key, nil, &tree.root) + t.put(value, key, nil, &t.root) return true }) tree.mu.Lock() @@ -477,35 +478,34 @@ func (tree *AVLTree) put(key interface{}, value interface{}, p *AVLTreeNode, qp c = 1 } a := (c + 1) / 2 - var fix bool - fix = tree.put(key, value, q, &q.children[a]) - if fix { + if tree.put(key, value, q, &q.children[a]) { return putFix(int8(c), qp) } return false } -func (tree *AVLTree) remove(key interface{}, qp **AVLTreeNode) bool { +func (tree *AVLTree) remove(key interface{}, qp **AVLTreeNode) (value interface{}, fix bool) { q := *qp if q == nil { - return false + return nil, false } c := tree.comparator(key, q.Key) if c == 0 { tree.size-- + value = q.Value + fix = true if q.children[1] == nil { if q.children[0] != nil { q.children[0].parent = q.parent } *qp = q.children[0] - return true + return } - fix := removeMin(&q.children[1], &q.Key, &q.Value) - if fix { - return removeFix(-1, qp) + if removeMin(&q.children[1], &q.Key, &q.Value) { + return value, removeFix(-1, qp) } - return false + return } if c < 0 { @@ -514,11 +514,11 @@ func (tree *AVLTree) remove(key interface{}, qp **AVLTreeNode) bool { c = 1 } a := (c + 1) / 2 - fix := tree.remove(key, &q.children[a]) + value, fix = tree.remove(key, &q.children[a]) if fix { - return removeFix(int8(-c), qp) + return value, removeFix(int8(-c), qp) } - return false + return nil, false } func removeMin(qp **AVLTreeNode, minKey *interface{}, minVal *interface{}) bool { @@ -574,9 +574,9 @@ func removeFix(c int8, t **AVLTreeNode) bool { a := (c + 1) / 2 if s.children[a].b == 0 { - s = rotate(c, s) + s = rotate(c, s) s.b = -c - *t = s + *t = s return false } diff --git a/g/container/gtree/gtree_btree.go b/g/container/gtree/gtree_btree.go index 9f44221a3..f06c9b945 100644 --- a/g/container/gtree/gtree_btree.go +++ b/g/container/gtree/gtree_btree.go @@ -553,7 +553,7 @@ func (tree *BTree) search(node *BTreeNode, key interface{}) (index int, found bo // searchRecursively searches recursively down the tree starting at the startNode func (tree *BTree) searchRecursively(startNode *BTreeNode, key interface{}) (node *BTreeNode, index int, found bool) { - if tree.IsEmpty() { + if tree.size == 0 { return nil, -1, false } node = startNode @@ -676,7 +676,7 @@ func setParent(nodes []*BTreeNode, parent *BTreeNode) { } func (tree *BTree) left(node *BTreeNode) *BTreeNode { - if tree.IsEmpty() { + if tree.size == 0 { return nil } current := node @@ -689,7 +689,7 @@ func (tree *BTree) left(node *BTreeNode) *BTreeNode { } func (tree *BTree) right(node *BTreeNode) *BTreeNode { - if tree.IsEmpty() { + if tree.size == 0 { return nil } current := node @@ -742,10 +742,10 @@ func (tree *BTree) delete(node *BTreeNode, index int) { } // deleting from an internal node - leftLargestNode := tree.right(node.Children[index]) // largest node in the left sub-tree (assumed to exist) + leftLargestNode := tree.right(node.Children[index]) // largest node in the left sub-tree (assumed to exist) leftLargestEntryIndex := len(leftLargestNode.Entries) - 1 - node.Entries[index] = leftLargestNode.Entries[leftLargestEntryIndex] - deletedKey := leftLargestNode.Entries[leftLargestEntryIndex].Key + node.Entries[index] = leftLargestNode.Entries[leftLargestEntryIndex] + deletedKey := leftLargestNode.Entries[leftLargestEntryIndex].Key tree.deleteEntry(leftLargestNode, leftLargestEntryIndex) tree.rebalance(leftLargestNode, deletedKey) } diff --git a/g/container/gtree/gtree_z_avl_tree_test.go b/g/container/gtree/gtree_z_avl_tree_test.go new file mode 100644 index 000000000..f20ed2601 --- /dev/null +++ b/g/container/gtree/gtree_z_avl_tree_test.go @@ -0,0 +1,103 @@ +// Copyright 2017-2019 gf Author(https://github.com/gogf/gf). All Rights Reserved. +// +// This Source Code Form is subject to the terms of the MIT License. +// If a copy of the MIT was not distributed with gm file, +// You can obtain one at https://github.com/gogf/gf. + +package gtree_test + +import ( + "github.com/gogf/gf/g/container/gtree" + "github.com/gogf/gf/g/test/gtest" + "github.com/gogf/gf/g/util/gutil" + "testing" +) + + +func Test_AVLTree_Basic(t *testing.T) { + gtest.Case(t, func() { + m := gtree.NewAVLTree(gutil.ComparatorString) + m.Set("key1", "val1") + gtest.Assert(m.Keys(), []interface{}{"key1"}) + + gtest.Assert(m.Get("key1"), "val1") + gtest.Assert(m.Size(), 1) + gtest.Assert(m.IsEmpty(), false) + + gtest.Assert(m.GetOrSet("key2", "val2"), "val2") + gtest.Assert(m.SetIfNotExist("key2", "val2"), false) + + gtest.Assert(m.SetIfNotExist("key3", "val3"), true) + + gtest.Assert(m.Remove("key2"), "val2") + gtest.Assert(m.Contains("key2"), false) + + gtest.AssertIN("key3", m.Keys()) + gtest.AssertIN("key1", m.Keys()) + gtest.AssertIN("val3", m.Values()) + gtest.AssertIN("val1", m.Values()) + + m.Flip() + gtest.Assert(m.Map(), map[interface{}]interface{}{"val3": "key3", "val1": "key1"}) + + m.Clear() + gtest.Assert(m.Size(), 0) + gtest.Assert(m.IsEmpty(), true) + + m2 := gtree.NewAVLTreeFrom(gutil.ComparatorString, map[interface{}]interface{}{1: 1, "key1": "val1"}) + gtest.Assert(m2.Map(), map[interface{}]interface{}{1: 1, "key1": "val1"}) + }) +} +func Test_AVLTree_Set_Fun(t *testing.T) { + m := gtree.NewAVLTree(gutil.ComparatorString) + m.GetOrSetFunc("fun", getValue) + m.GetOrSetFuncLock("funlock", getValue) + gtest.Assert(m.Get("funlock"), 3) + gtest.Assert(m.Get("fun"), 3) + m.GetOrSetFunc("fun", getValue) + gtest.Assert(m.SetIfNotExistFunc("fun", getValue), false) + gtest.Assert(m.SetIfNotExistFuncLock("funlock", getValue), false) +} + +func Test_AVLTree_Batch(t *testing.T) { + m := gtree.NewAVLTree(gutil.ComparatorString) + m.Sets(map[interface{}]interface{}{1: 1, "key1": "val1", "key2": "val2", "key3": "val3"}) + gtest.Assert(m.Map(), map[interface{}]interface{}{1: 1, "key1": "val1", "key2": "val2", "key3": "val3"}) + m.Removes([]interface{}{"key1", 1}) + gtest.Assert(m.Map(), map[interface{}]interface{}{"key2": "val2", "key3": "val3"}) +} +func Test_AVLTree_Iterator(t *testing.T){ + expect := map[interface{}]interface{}{1: 1, "key1": "val1"} + + m := gtree.NewAVLTreeFrom(gutil.ComparatorString, expect) + m.Iterator(func(k interface{}, v interface{}) bool { + gtest.Assert(expect[k], v) + return true + }) + // 断言返回值对遍历控制 + i := 0 + j := 0 + m.Iterator(func(k interface{}, v interface{}) bool { + i++ + return true + }) + m.Iterator(func(k interface{}, v interface{}) bool { + j++ + return false + }) + gtest.Assert(i, 2) + gtest.Assert(j, 1) +} + +func Test_AVLTree_Clone(t *testing.T) { + //clone 方法是深克隆 + m := gtree.NewAVLTreeFrom(gutil.ComparatorString, map[interface{}]interface{}{1: 1, "key1": "val1"}) + m_clone := m.Clone() + m.Remove(1) + //修改原 map,clone 后的 map 不影响 + gtest.AssertIN(1, m_clone.Keys()) + + m_clone.Remove("key1") + //修改clone map,原 map 不影响 + gtest.AssertIN("key1", m.Keys()) +} \ No newline at end of file diff --git a/g/container/gtree/gtree_z_b_tree_test.go b/g/container/gtree/gtree_z_b_tree_test.go new file mode 100644 index 000000000..1596bd175 --- /dev/null +++ b/g/container/gtree/gtree_z_b_tree_test.go @@ -0,0 +1,99 @@ +// Copyright 2017-2019 gf Author(https://github.com/gogf/gf). All Rights Reserved. +// +// This Source Code Form is subject to the terms of the MIT License. +// If a copy of the MIT was not distributed with gm file, +// You can obtain one at https://github.com/gogf/gf. + +package gtree_test + +import ( + "github.com/gogf/gf/g/container/gtree" + "github.com/gogf/gf/g/test/gtest" + "github.com/gogf/gf/g/util/gutil" + "testing" +) + +func Test_BTree_Basic(t *testing.T) { + gtest.Case(t, func() { + m := gtree.NewBTree(3, gutil.ComparatorString) + m.Set("key1", "val1") + gtest.Assert(m.Keys(), []interface{}{"key1"}) + + gtest.Assert(m.Get("key1"), "val1") + gtest.Assert(m.Size(), 1) + gtest.Assert(m.IsEmpty(), false) + + gtest.Assert(m.GetOrSet("key2", "val2"), "val2") + gtest.Assert(m.SetIfNotExist("key2", "val2"), false) + + gtest.Assert(m.SetIfNotExist("key3", "val3"), true) + + gtest.Assert(m.Remove("key2"), "val2") + gtest.Assert(m.Contains("key2"), false) + + gtest.AssertIN("key3", m.Keys()) + gtest.AssertIN("key1", m.Keys()) + gtest.AssertIN("val3", m.Values()) + gtest.AssertIN("val1", m.Values()) + + m.Clear() + gtest.Assert(m.Size(), 0) + gtest.Assert(m.IsEmpty(), true) + + m2 := gtree.NewBTreeFrom(3, gutil.ComparatorString, map[interface{}]interface{}{1: 1, "key1": "val1"}) + gtest.Assert(m2.Map(), map[interface{}]interface{}{1: 1, "key1": "val1"}) + }) +} +func Test_BTree_Set_Fun(t *testing.T) { + m := gtree.NewBTree(3, gutil.ComparatorString) + m.GetOrSetFunc("fun", getValue) + m.GetOrSetFuncLock("funlock", getValue) + gtest.Assert(m.Get("funlock"), 3) + gtest.Assert(m.Get("fun"), 3) + m.GetOrSetFunc("fun", getValue) + gtest.Assert(m.SetIfNotExistFunc("fun", getValue), false) + gtest.Assert(m.SetIfNotExistFuncLock("funlock", getValue), false) +} + +func Test_BTree_Batch(t *testing.T) { + m := gtree.NewBTree(3, gutil.ComparatorString) + m.Sets(map[interface{}]interface{}{1: 1, "key1": "val1", "key2": "val2", "key3": "val3"}) + gtest.Assert(m.Map(), map[interface{}]interface{}{1: 1, "key1": "val1", "key2": "val2", "key3": "val3"}) + m.Removes([]interface{}{"key1", 1}) + gtest.Assert(m.Map(), map[interface{}]interface{}{"key2": "val2", "key3": "val3"}) +} +func Test_BTree_Iterator(t *testing.T){ + expect := map[interface{}]interface{}{1: 1, "key1": "val1"} + + m := gtree.NewBTreeFrom(3, gutil.ComparatorString, expect) + m.Iterator(func(k interface{}, v interface{}) bool { + gtest.Assert(expect[k], v) + return true + }) + // 断言返回值对遍历控制 + i := 0 + j := 0 + m.Iterator(func(k interface{}, v interface{}) bool { + i++ + return true + }) + m.Iterator(func(k interface{}, v interface{}) bool { + j++ + return false + }) + gtest.Assert(i, 2) + gtest.Assert(j, 1) +} + +func Test_BTree_Clone(t *testing.T) { + //clone 方法是深克隆 + m := gtree.NewBTreeFrom(3, gutil.ComparatorString, map[interface{}]interface{}{1: 1, "key1": "val1"}) + m_clone := m.Clone() + m.Remove(1) + //修改原 map,clone 后的 map 不影响 + gtest.AssertIN(1, m_clone.Keys()) + + m_clone.Remove("key1") + //修改clone map,原 map 不影响 + gtest.AssertIN("key1", m.Keys()) +} \ No newline at end of file diff --git a/g/test/gtest/gtest.go b/g/test/gtest/gtest.go index ba66e3830..a2d155c58 100644 --- a/g/test/gtest/gtest.go +++ b/g/test/gtest/gtest.go @@ -287,7 +287,7 @@ func compareMap(value, expect interface{}) error { } } } else { - return fmt.Errorf(`[ASSERT] EXPECT MAP LENGTH %d == %d`, rvExpect.Len(), rvValue.Len()) + return fmt.Errorf(`[ASSERT] EXPECT MAP LENGTH %d == %d`, rvValue.Len(), rvExpect.Len()) } } else { return fmt.Errorf(`[ASSERT] EXPECT VALUE TO BE A MAP`)