树形类

package
v0.0.0-...-fcd50c7 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Aug 21, 2024 License: MIT Imports: 10 Imported by: 0

Documentation

Overview

gtree 包提供了并发安全/不安全的树容器。

部分实现来源于：https://github.com/emirpasic/gods md5:d7058919da3c4b80

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AVLTree 

type AVLTree struct {
	// contains filtered or unexported fields
}

AVLTree 存储AVL树的元素。 md5:d108e2d6ca60747c

func NewAVLTree 

func NewAVLTree(comparator func(v1, v2 interface{}) int, safe ...bool) *AVLTree

NewAVLTree 创建一个带有自定义键比较器的AVL树。 参数 `safe` 用于指定是否需要并发安全，默认为false。 md5:dfb13f71bc07620c

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"
	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	avlTree := gtree.NewAVLTree(gutil.X比较文本)
	for i := 0; i < 6; i++ {
		avlTree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(avlTree)

}

Output:

│       ┌── key5
│   ┌── key4
└── key3
    │   ┌── key2
    └── key1
        └── key0

func NewAVLTreeFrom 

func NewAVLTreeFrom(comparator func(v1, v2 interface{}) int, data map[interface{}]interface{}, safe ...bool) *AVLTree

NewAVLTreeFrom 使用自定义的键比较器和数据映射初始化一个AVL树。 参数`safe`用于指定是否在并发安全模式下使用树，其默认值为false。 md5:856b75ecd9dc1540

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"
	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	avlTree := gtree.NewAVLTree(gutil.X比较文本)
	for i := 0; i < 6; i++ {
		avlTree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	otherAvlTree := gtree.NewAVLTreeFrom(gutil.X比较文本, avlTree.Map())
	fmt.Println(otherAvlTree)

	// May Output:
	// │   ┌── key5
	// │   │   └── key4
	// └── key3
	//     │   ┌── key2
	//     └── key1
	//         └── key0
}

func (*AVLTree) Ceiling 

func (tree *AVLTree) Ceiling(key interface{}) (ceiling *AVLTreeNode, found bool)

Ceiling 找到输入键的天花板节点，如果没有找到天花板节点，则返回nil。第二个返回参数表示是否找到了天花板（true）或未找到（false）。

定义天花板节点为大于或等于给定节点的最小节点。可能找不到天花板节点，因为树为空，或者树中的所有节点都小于给定节点。

键应遵循比较器的类型断言，否则方法会 panic。 md5:6b92342a03f9f586

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewAVLTree(gutil.X比较整数)
	for i := 1; i < 100; i++ {
		if i != 50 {
			tree.X设置值(i, i)
		}
	}

	node, found := tree.Ceiling(1)
	if found {
		fmt.Println("Ceiling 1:", node.Key)
	}

	node, found = tree.Ceiling(50)
	if found {
		fmt.Println("Ceiling 50:", node.Key)
	}

	node, found = tree.Ceiling(100)
	if found {
		fmt.Println("Ceiling 100:", node.Key)
	}

	node, found = tree.Ceiling(-1)
	if found {
		fmt.Println("Ceiling -1:", node.Key)
	}

}

Output:

Ceiling 1: 1
Ceiling 50: 51
Ceiling -1: 1

func (*AVLTree) Clear 

func (tree *AVLTree) Clear()

Clear 从树中移除所有节点。 md5:a7db742922264980

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewAVLTree(gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值(1000+i, "val"+gconv.String(i))
	}
	fmt.Println(tree.Size())

	tree.Clear()
	fmt.Println(tree.Size())

}

Output:

6
0

func (*AVLTree) Clone 

func (tree *AVLTree) Clone() *AVLTree

Clone 返回一个新的树，其中包含当前树的副本。 md5:256477216ae712b7

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	avl := gtree.NewAVLTree(gutil.X比较文本)
	for i := 0; i < 6; i++ {
		avl.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	tree := avl.Clone()

	fmt.Println(tree.Map())
	fmt.Println(tree.Size())

}

Output:

map[key0:val0 key1:val1 key2:val2 key3:val3 key4:val4 key5:val5]
6

func (*AVLTree) Contains 

func (tree *AVLTree) Contains(key interface{}) bool

Contains 检查键 `key` 是否存在于树中。 md5:77fd85af8e586867

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewAVLTree(gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.Contains("key1"))
	fmt.Println(tree.Contains("key6"))

}

Output:

true
false

func (*AVLTree) Flip 

func (tree *AVLTree) Flip(comparator ...func(v1, v2 interface{}) int)

Flip 将树中的键值对交换为值键。 请注意，你应该确保值的类型与键相同，否则比较器会panic。

如果值的类型与键不同，你需要传递新的 `comparator`。 md5:e71ceac22aee55f1

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewAVLTree(gutil.X比较整数)
	for i := 1; i < 6; i++ {
		tree.X设置值(i, i*10)
	}

	fmt.Println("Before Flip", tree.Map())

	tree.Flip()

	fmt.Println("After Flip", tree.Map())

}

Output:

Before Flip map[1:10 2:20 3:30 4:40 5:50]
After Flip map[10:1 20:2 30:3 40:4 50:5]

func (*AVLTree) Floor 

func (tree *AVLTree) Floor(key interface{}) (floor *AVLTreeNode, found bool)

Floor 找到输入键的地板节点，如果没有找到地板节点，则返回nil。第二个返回参数表示是否找到了地板，如果找到为true，否则为false。

地板节点定义为大于或等于给定节点的最大节点。可能找不到地板节点，原因可能是树为空，或者树中的所有节点都大于给定节点。

键应遵循比较器的类型断言，否则方法会 panic。 md5:720f6000179912eb

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewAVLTree(gutil.X比较整数)
	for i := 1; i < 100; i++ {
		if i != 50 {
			tree.X设置值(i, i)
		}
	}

	node, found := tree.Floor(95)
	if found {
		fmt.Println("Floor 95:", node.Key)
	}

	node, found = tree.Floor(50)
	if found {
		fmt.Println("Floor 50:", node.Key)
	}

	node, found = tree.Floor(100)
	if found {
		fmt.Println("Floor 100:", node.Key)
	}

	node, found = tree.Floor(0)
	if found {
		fmt.Println("Floor 0:", node.Key)
	}

}

Output:

Floor 95: 95
Floor 50: 49
Floor 100: 99

func (*AVLTree) Get 

func (tree *AVLTree) Get(key interface{}) (value interface{})

Get 通过`key`在树中搜索节点，并返回其值，如果`key`在树中未找到，则返回nil。 md5:2e2483db20a69167

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewAVLTree(gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.Get("key1"))
	fmt.Println(tree.Get("key10"))

}

Output:

val1
<nil>

func (*AVLTree) GetOrSet 

func (tree *AVLTree) GetOrSet(key interface{}, value interface{}) interface{}

GetOrSet 通过键返回值， 如果该键不存在，则使用给定的`value`设置值，然后返回这个值。 md5:d8f89b6dec47292b

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewAVLTree(gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.GetOrSet("key1", "newVal1"))
	fmt.Println(tree.GetOrSet("key6", "val6"))

}

Output:

val1
val6

func (*AVLTree) GetOrSetFunc 

func (tree *AVLTree) GetOrSetFunc(key interface{}, f func() interface{}) interface{}

GetOrSetFunc 通过键获取值， 如果键不存在，则使用回调函数`f`的返回值设置值， 并返回这个设置的值。 md5:f584dd7547dfbcc0

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewAVLTree(gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.GetOrSetFunc("key1", func() interface{} {
		return "newVal1"
	}))
	fmt.Println(tree.GetOrSetFunc("key6", func() interface{} {
		return "val6"
	}))

}

Output:

val1
val6

func (*AVLTree) GetOrSetFuncLock 

func (tree *AVLTree) GetOrSetFuncLock(key interface{}, f func() interface{}) interface{}

GetOrSetFuncLock 通过键获取值， 如果不存在，它将使用回调函数 `f` 的返回值设置该值，然后返回这个值。

GetOrSetFuncLock 与 GetOrSetFunc 函数的不同之处在于，它在执行函数 `f` 时会先锁定哈希映射的 mutex。 md5:d32fdee586d84dde

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewAVLTree(gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.GetOrSetFuncLock("key1", func() interface{} {
		return "newVal1"
	}))
	fmt.Println(tree.GetOrSetFuncLock("key6", func() interface{} {
		return "val6"
	}))

}

Output:

val1
val6

func (*AVLTree) GetVar 

func (tree *AVLTree) GetVar(key interface{}) *gvar.Var

GetVar 函数通过给定的 `key` 返回一个 gvar.Var，其值为对应的变量。 返回的 gvar.Var 不是并发安全的。 md5:a04747902e4bf242

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewAVLTree(gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.GetVar("key1").String())

}

Output:

val1

func (*AVLTree) GetVarOrSet 

func (tree *AVLTree) GetVarOrSet(key interface{}, value interface{}) *gvar.Var

GetVarOrSet 返回一个从 GetVarOrSet 获取的结果的 gvar.Var。返回的 gvar.Var 不是线程安全的。 md5:089beb08264e18cf

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewAVLTree(gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.GetVarOrSet("key1", "newVal1"))
	fmt.Println(tree.GetVarOrSet("key6", "val6"))

}

Output:

val1
val6

func (*AVLTree) GetVarOrSetFunc 

func (tree *AVLTree) GetVarOrSetFunc(key interface{}, f func() interface{}) *gvar.Var

GetVarOrSetFunc 返回一个 gvar.Var，其结果来自 GetOrSetFunc。 返回的 gvar.Var 不是线程安全的。 md5:8c97b145faade5ae

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewAVLTree(gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.GetVarOrSetFunc("key1", func() interface{} {
		return "newVal1"
	}))
	fmt.Println(tree.GetVarOrSetFunc("key6", func() interface{} {
		return "val6"
	}))

}

Output:

val1
val6

func (*AVLTree) GetVarOrSetFuncLock 

func (tree *AVLTree) GetVarOrSetFuncLock(key interface{}, f func() interface{}) *gvar.Var

GetVarOrSetFuncLock 返回一个gvar.Var，其结果来自GetOrSetFuncLock。 返回的gvar.Var是非并发安全的。 md5:90c22300c2187ce4

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewAVLTree(gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.GetVarOrSetFuncLock("key1", func() interface{} {
		return "newVal1"
	}))
	fmt.Println(tree.GetVarOrSetFuncLock("key6", func() interface{} {
		return "val6"
	}))

}

Output:

val1
val6

func (*AVLTree) IsEmpty 

func (tree *AVLTree) IsEmpty() bool

IsEmpty 如果树中不包含任何节点，则返回true。 md5:8f7ae813360d880b

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewAVLTree(gutil.X比较文本)

	fmt.Println(tree.IsEmpty())

	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.IsEmpty())

}

Output:

true
false

func (*AVLTree) IteratorAsc 

func (tree *AVLTree) IteratorAsc(f func(key, value interface{}) bool)

IteratorAsc 使用给定的回调函数 `f` 以升序遍历树（只读）。如果 `f` 返回 true，则继续遍历；如果返回 false，则停止遍历。 md5:c13b99ae40add3b0

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewAVLTree(gutil.X比较文本)
	for i := 0; i < 10; i++ {
		tree.X设置值(i, 10-i)
	}

	tree.IteratorAsc(func(key, value interface{}) bool {
		fmt.Println("key:", key, ", value:", value)
		return true
	})

}

Output:

key: 0 , value: 10
key: 1 , value: 9
key: 2 , value: 8
key: 3 , value: 7
key: 4 , value: 6
key: 5 , value: 5
key: 6 , value: 4
key: 7 , value: 3
key: 8 , value: 2
key: 9 , value: 1

func (*AVLTree) IteratorAscFrom 

func (tree *AVLTree) IteratorAscFrom(key interface{}, match bool, f func(key, value interface{}) bool)

IteratorAscFrom 从给定的回调函数 `f` 以升序遍历树。 参数 `key` 指定了遍历的起始条目。`match` 参数指定如果 `key` 完全匹配时是否开始遍历，否则使用索引搜索进行遍历。 如果 `f` 返回 true，则继续遍历；如果返回 false，则停止遍历。 md5:c04855bbd3989808

func (*AVLTree) IteratorDesc 

func (tree *AVLTree) IteratorDesc(f func(key, value interface{}) bool)

IteratorDesc 以降序方式遍历树，使用给定的回调函数 `f`。如果 `f` 返回 true，则继续遍历；否则停止。 md5:f6740ea55dafe4bb

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewAVLTree(gutil.X比较文本)
	for i := 0; i < 10; i++ {
		tree.X设置值(i, 10-i)
	}

	tree.IteratorDesc(func(key, value interface{}) bool {
		fmt.Println("key:", key, ", value:", value)
		return true
	})

}

Output:

key: 9 , value: 1
key: 8 , value: 2
key: 7 , value: 3
key: 6 , value: 4
key: 5 , value: 5
key: 4 , value: 6
key: 3 , value: 7
key: 2 , value: 8
key: 1 , value: 9
key: 0 , value: 10

func (*AVLTree) IteratorDescFrom 

func (tree *AVLTree) IteratorDescFrom(key interface{}, match bool, f func(key, value interface{}) bool)

IteratorDescFrom 以降序方式遍历树，使用给定的回调函数 `f`。参数 `key` 指定开始遍历的条目。`match` 表示是否在 `key` 完全匹配时开始遍历，否则使用索引搜索遍历。如果 `f` 返回 true，则继续遍历；否则停止。 md5:e6bb2f7d12ab34f6

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	m := make(map[interface{}]interface{})
	for i := 1; i <= 5; i++ {
		m[i] = i * 10
	}
	tree := gtree.NewAVLTreeFrom(gutil.X比较整数, m)

	tree.IteratorDescFrom(5, true, func(key, value interface{}) bool {
		fmt.Println("key:", key, ", value:", value)
		return true
	})

}

Output:

key: 5 , value: 50
key: 4 , value: 40
key: 3 , value: 30
key: 2 , value: 20
key: 1 , value: 10

func (*AVLTree) IteratorFrom 

func (tree *AVLTree) IteratorFrom(key interface{}, match bool, f func(key, value interface{}) bool)

IteratorFrom是IteratorAscFrom的别名。 md5:6d3d506bcb5fe942

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	m := make(map[interface{}]interface{})
	for i := 1; i <= 5; i++ {
		m[i] = i * 10
	}
	tree := gtree.NewAVLTreeFrom(gutil.X比较整数, m)

	tree.IteratorFrom(1, true, func(key, value interface{}) bool {
		fmt.Println("key:", key, ", value:", value)
		return true
	})

}

Output:

key: 1 , value: 10
key: 2 , value: 20
key: 3 , value: 30
key: 4 , value: 40
key: 5 , value: 50

func (*AVLTree) Keys 

func (tree *AVLTree) Keys() []interface{}

Keys 返回所有键，按升序排列。 md5:c2a692ea3491e160

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewAVLTree(gutil.X比较文本)
	for i := 6; i > 0; i-- {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.Keys())

}

Output:

[key1 key2 key3 key4 key5 key6]

func (*AVLTree) Left 

func (tree *AVLTree) Left() *AVLTreeNode

Left 返回 AVL 树中的最小元素 如果树为空，则返回 nil。 md5:d6b4c070feb60521

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewAVLTree(gutil.X比较整数)
	for i := 1; i < 100; i++ {
		tree.X设置值(i, i)
	}
	fmt.Println(tree.Left().Key, tree.Left().Value)

	emptyTree := gtree.NewAVLTree(gutil.X比较整数)
	fmt.Println(emptyTree.Left())

}

Output:

1 1
<nil>

func (*AVLTree) Map 

func (tree *AVLTree) Map() map[interface{}]interface{}

Map 返回所有键值对项作为一个映射。 md5:c12ca822a6c71dc1

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewAVLTree(gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.Map())

}

Output:

map[key0:val0 key1:val1 key2:val2 key3:val3 key4:val4 key5:val5]

func (AVLTree) MarshalJSON 

func (tree AVLTree) MarshalJSON() (jsonBytes []byte, err error)

MarshalJSON 实现了接口 MarshalJSON 以供 json.Marshal 使用。 md5:43c3b36e60a18f9a

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"
	"github.com/888go/goframe/internal/json"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewAVLTree(gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	bytes, err := json.Marshal(tree)
	if err == nil {
		fmt.Println(gconv.String(bytes))
	}

}

Output:

{"key0":"val0","key1":"val1","key2":"val2","key3":"val3","key4":"val4","key5":"val5"}

func (*AVLTree) Print 

func (tree *AVLTree) Print()

Print 将树打印到标准输出。 md5:24fd6288549a501b

Example 
package main

import (
	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewAVLTree(gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	tree.Print()

}

Output:

│       ┌── key5
│   ┌── key4
└── key3
    │   ┌── key2
    └── key1
        └── key0

func (*AVLTree) Remove 

func (tree *AVLTree) Remove(key interface{}) (value interface{})

Remove 通过键从树中移除节点。 键应符合比较器的类型断言，否则方法将 panic。 md5:23794cd4708d8756

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewAVLTree(gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.Remove("key1"))
	fmt.Println(tree.Remove("key6"))
	fmt.Println(tree.Map())

}

Output:

val1
<nil>
map[key0:val0 key2:val2 key3:val3 key4:val4 key5:val5]

func (*AVLTree) Removes 

func (tree *AVLTree) Removes(keys []interface{})

通过`keys`移除树中的批量删除值。 md5:4620c81ac88b2936

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewAVLTree(gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	removeKeys := make([]interface{}, 2)
	removeKeys = append(removeKeys, "key1")
	removeKeys = append(removeKeys, "key6")

	tree.Removes(removeKeys)

	fmt.Println(tree.Map())

}

Output:

map[key0:val0 key2:val2 key3:val3 key4:val4 key5:val5]

func (*AVLTree) Replace 

func (tree *AVLTree) Replace(data map[interface{}]interface{})

使用给定的`data`替换树中的数据。 md5:ff636c579597f294

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewAVLTree(gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.Map())

	data := map[interface{}]interface{}{
		"newKey0": "newVal0",
		"newKey1": "newVal1",
		"newKey2": "newVal2",
	}

	tree.Replace(data)

	fmt.Println(tree.Map())

}

Output:

map[key0:val0 key1:val1 key2:val2 key3:val3 key4:val4 key5:val5]
map[newKey0:newVal0 newKey1:newVal1 newKey2:newVal2]

func (*AVLTree) Right 

func (tree *AVLTree) Right() *AVLTreeNode

Right 返回AVL树中的最大元素，如果树为空则返回nil。 md5:7f0d34ae61ed561f

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewAVLTree(gutil.X比较整数)
	for i := 1; i < 100; i++ {
		tree.X设置值(i, i)
	}
	fmt.Println(tree.Right().Key, tree.Right().Value)

	emptyTree := gtree.NewAVLTree(gutil.X比较整数)
	fmt.Println(emptyTree.Left())

}

Output:

99 99
<nil>

func (*AVLTree) Search 

func (tree *AVLTree) Search(key interface{}) (value interface{}, found bool)

Search 函数使用给定的 `key` 在树中进行查找。 第二个返回参数 `found` 为 true 表示找到了键，否则为 false。 md5:d151c3783cadda2c

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewAVLTree(gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.Search("key0"))
	fmt.Println(tree.Search("key6"))

}

Output:

val0 true
<nil> false

func (*AVLTree) SetIfNotExist 

func (tree *AVLTree) SetIfNotExist(key interface{}, value interface{}) bool

SetIfNotExist 如果键`key`不存在，则将`value`设置到映射中，并返回true。如果键`key`已存在，且`value`将被忽略，函数返回false。 md5:f80895920828f03e

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewAVLTree(gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.SetIfNotExist("key1", "newVal1"))
	fmt.Println(tree.SetIfNotExist("key6", "val6"))

}

Output:

false
true

func (*AVLTree) SetIfNotExistFunc 

func (tree *AVLTree) SetIfNotExistFunc(key interface{}, f func() interface{}) bool

SetIfNotExistFunc 使用回调函数`f`的返回值设置值，并返回true。 如果`key`已存在，则返回false，且`value`会被忽略。 md5:326c0b7c63d813e7

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewAVLTree(gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.SetIfNotExistFunc("key1", func() interface{} {
		return "newVal1"
	}))
	fmt.Println(tree.SetIfNotExistFunc("key6", func() interface{} {
		return "val6"
	}))

}

Output:

false
true

func (*AVLTree) SetIfNotExistFuncLock 

func (tree *AVLTree) SetIfNotExistFuncLock(key interface{}, f func() interface{}) bool

SetIfNotExistFuncLock 使用回调函数 `f` 的返回值设置值，然后返回 true。 如果 `key` 已存在，则返回 false，`value` 将被忽略。

SetIfNotExistFuncLock 与 SetIfNotExistFunc 函数的区别在于， 它在哈希映射的 mutex.Lock 保护下执行函数 `f`。 md5:a6ee84b157328f61

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewAVLTree(gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.SetIfNotExistFuncLock("key1", func() interface{} {
		return "newVal1"
	}))
	fmt.Println(tree.SetIfNotExistFuncLock("key6", func() interface{} {
		return "val6"
	}))

}

Output:

false
true

func (*AVLTree) Sets 

func (tree *AVLTree) Sets(data map[interface{}]interface{})

设置批处理将键值对添加到树中。 md5:70c6ec85c8b7476c

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewAVLTree(gutil.X比较文本)

	tree.Sets(map[interface{}]interface{}{
		"key1": "val1",
		"key2": "val2",
	})

	fmt.Println(tree.Map())
	fmt.Println(tree.Size())

}

Output:

map[key1:val1 key2:val2]
2

func (*AVLTree) Size 

func (tree *AVLTree) Size() int

Size 返回树中的节点数量。 md5:d437d5852f80de5c

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewAVLTree(gutil.X比较文本)

	fmt.Println(tree.Size())

	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.Size())

}

Output:

0
6

func (*AVLTree) String 

func (tree *AVLTree) String() string

String 返回容器的字符串表示形式. md5:7daf925d59987319

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewAVLTree(gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.String())

}

Output:

│       ┌── key5
│   ┌── key4
└── key3
    │   ┌── key2
    └── key1
        └── key0

func (*AVLTree) Values 

func (tree *AVLTree) Values() []interface{}

Values返回根据键值升序排列的所有值。 md5:6268d60d7aa20c91

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewAVLTree(gutil.X比较文本)
	for i := 6; i > 0; i-- {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.Values())

}

Output:

[val1 val2 val3 val4 val5 val6]

func (*AVLTree) X取MapStrAny 

func (tree *AVLTree) X取MapStrAny() map[string]interface{}

X取MapStrAny 将所有键值对作为 map[string]interface{} 返回。 md5:412456aafc43f7a8

func (*AVLTree) X设置值 

func (tree *AVLTree) X设置值(key interface{}, value interface{})

X设置值 将节点插入到树中。 md5:8af837873ed60d6a

func (*AVLTree) X遍历 

func (tree *AVLTree) X遍历(f func(key, value interface{}) bool)

X遍历 是 IteratorAsc 的别名。 md5:1bfdea306db62845

type AVLTreeNode 

type AVLTreeNode struct {
	Key   interface{}
	Value interface{}
	// contains filtered or unexported fields
}

AVLTreeNode 是树中的一个元素。 md5:ae1bf04ae171ca4e

func (*AVLTreeNode) Next 

func (node *AVLTreeNode) Next() *AVLTreeNode

Next 返回AVL树中序遍历的下一个元素。 md5:bf33a084df1455d4

func (*AVLTreeNode) Prev 

func (node *AVLTreeNode) Prev() *AVLTreeNode

Prev 返回AVL树中序遍历的上一个元素。 md5:d859f5a91f8afa30

type BTree 

type BTree struct {
	// contains filtered or unexported fields
}

BTree 存储 B 树的元素。 md5:191d2e09c9c918ab

func NewBTree 

func NewBTree(m int, comparator func(v1, v2 interface{}) int, safe ...bool) *BTree

NewBTree 创建一个具有 `m`（最大子节点数）和自定义键比较器的 B 树。参数 `safe` 用于指定是否在并发安全模式下使用树，其默认值为 false。 注意，`m` 必须大于或等于 3，否则将引发 panic。 md5:63e15eb274ca4e1d

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"
	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	bTree := gtree.NewBTree(3, gutil.X比较文本)
	for i := 0; i < 6; i++ {
		bTree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}
	fmt.Println(bTree.Map())

}

Output:

map[key0:val0 key1:val1 key2:val2 key3:val3 key4:val4 key5:val5]

func NewBTreeFrom 

func NewBTreeFrom(m int, comparator func(v1, v2 interface{}) int, data map[interface{}]interface{}, safe ...bool) *BTree

NewBTreeFrom 根据给定的参数实例化一个 B-树，包括孩子节点的最大数量 `m`、自定义键比较器和数据映射。 参数 `safe` 用于指定是否需要并发安全，默认情况下为 false。 md5:7a8fbca9b49feb70

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"
	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	bTree := gtree.NewBTree(3, gutil.X比较文本)
	for i := 0; i < 6; i++ {
		bTree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	otherBTree := gtree.NewBTreeFrom(3, gutil.X比较文本, bTree.Map())
	fmt.Println(otherBTree.Map())

}

Output:

map[key0:val0 key1:val1 key2:val2 key3:val3 key4:val4 key5:val5]

func (*BTree) Clear 

func (tree *BTree) Clear()

Clear 从树中移除所有节点。 md5:a7db742922264980

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewBTree(3, gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值(1000+i, "val"+gconv.String(i))
	}
	fmt.Println(tree.Size())

	tree.Clear()
	fmt.Println(tree.Size())

}

Output:

6
0

func (*BTree) Clone 

func (tree *BTree) Clone() *BTree

Clone 返回一个新的树，其中包含当前树的副本。 md5:256477216ae712b7

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	b := gtree.NewBTree(3, gutil.X比较文本)
	for i := 0; i < 6; i++ {
		b.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	tree := b.Clone()

	fmt.Println(tree.Map())
	fmt.Println(tree.Size())

}

Output:

map[key0:val0 key1:val1 key2:val2 key3:val3 key4:val4 key5:val5]
6

func (*BTree) Contains 

func (tree *BTree) Contains(key interface{}) bool

Contains 检查键 `key` 是否存在于树中。 md5:77fd85af8e586867

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewBTree(3, gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.Contains("key1"))
	fmt.Println(tree.Contains("key6"))

}

Output:

true
false

func (*BTree) Get 

func (tree *BTree) Get(key interface{}) (value interface{})

Get 通过`key`在树中搜索节点，并返回其值，如果`key`在树中未找到，则返回nil。 md5:2e2483db20a69167

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewBTree(3, gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.Get("key1"))
	fmt.Println(tree.Get("key10"))

}

Output:

val1
<nil>

func (*BTree) GetOrSet 

func (tree *BTree) GetOrSet(key interface{}, value interface{}) interface{}

GetOrSet 通过键返回值， 如果该键不存在，则使用给定的`value`设置值，然后返回这个值。 md5:d8f89b6dec47292b

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewBTree(3, gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.GetOrSet("key1", "newVal1"))
	fmt.Println(tree.GetOrSet("key6", "val6"))

}

Output:

val1
val6

func (*BTree) GetOrSetFunc 

func (tree *BTree) GetOrSetFunc(key interface{}, f func() interface{}) interface{}

GetOrSetFunc 通过键获取值， 如果键不存在，则使用回调函数`f`的返回值设置值， 并返回这个设置的值。 md5:f584dd7547dfbcc0

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewBTree(3, gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.GetOrSetFunc("key1", func() interface{} {
		return "newVal1"
	}))
	fmt.Println(tree.GetOrSetFunc("key6", func() interface{} {
		return "val6"
	}))

}

Output:

val1
val6

func (*BTree) GetOrSetFuncLock 

func (tree *BTree) GetOrSetFuncLock(key interface{}, f func() interface{}) interface{}

GetOrSetFuncLock 通过键获取值， 如果不存在，它将使用回调函数 `f` 的返回值设置该值，然后返回这个值。

GetOrSetFuncLock 与 GetOrSetFunc 函数的不同之处在于，它在执行函数 `f` 时会先锁定哈希映射的 mutex。 md5:d32fdee586d84dde

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewBTree(3, gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.GetOrSetFuncLock("key1", func() interface{} {
		return "newVal1"
	}))
	fmt.Println(tree.GetOrSetFuncLock("key6", func() interface{} {
		return "val6"
	}))

}

Output:

val1
val6

func (*BTree) GetVar 

func (tree *BTree) GetVar(key interface{}) *gvar.Var

GetVar 函数通过给定的 `key` 返回一个 gvar.Var，其值为对应的变量。 返回的 gvar.Var 不是并发安全的。 md5:a04747902e4bf242

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewBTree(3, gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.GetVar("key1").String())

}

Output:

val1

func (*BTree) GetVarOrSet 

func (tree *BTree) GetVarOrSet(key interface{}, value interface{}) *gvar.Var

GetVarOrSet 返回一个从 GetVarOrSet 获取的结果的 gvar.Var。返回的 gvar.Var 不是线程安全的。 md5:089beb08264e18cf

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewBTree(3, gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.GetVarOrSet("key1", "newVal1"))
	fmt.Println(tree.GetVarOrSet("key6", "val6"))

}

Output:

val1
val6

func (*BTree) GetVarOrSetFunc 

func (tree *BTree) GetVarOrSetFunc(key interface{}, f func() interface{}) *gvar.Var

GetVarOrSetFunc 返回一个 gvar.Var，其结果来自 GetOrSetFunc。 返回的 gvar.Var 不是线程安全的。 md5:8c97b145faade5ae

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewBTree(3, gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.GetVarOrSetFunc("key1", func() interface{} {
		return "newVal1"
	}))
	fmt.Println(tree.GetVarOrSetFunc("key6", func() interface{} {
		return "val6"
	}))

}

Output:

val1
val6

func (*BTree) GetVarOrSetFuncLock 

func (tree *BTree) GetVarOrSetFuncLock(key interface{}, f func() interface{}) *gvar.Var

GetVarOrSetFuncLock 返回一个gvar.Var，其结果来自GetOrSetFuncLock。 返回的gvar.Var是非并发安全的。 md5:90c22300c2187ce4

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewBTree(3, gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.GetVarOrSetFuncLock("key1", func() interface{} {
		return "newVal1"
	}))
	fmt.Println(tree.GetVarOrSetFuncLock("key6", func() interface{} {
		return "val6"
	}))

}

Output:

val1
val6

func (*BTree) Height 

func (tree *BTree) Height() int

Height 返回树的高度。 md5:c3af563cbe50966a

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewBTree(3, gutil.X比较整数)
	for i := 0; i < 100; i++ {
		tree.X设置值(i, i)
	}
	fmt.Println(tree.Height())

}

Output:

6

func (*BTree) IsEmpty 

func (tree *BTree) IsEmpty() bool

IsEmpty 返回true当树中不包含任何节点时. md5:d43f280c082bb0fd

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewBTree(3, gutil.X比较文本)

	fmt.Println(tree.IsEmpty())

	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.IsEmpty())

}

Output:

true
false

func (*BTree) IteratorAsc 

func (tree *BTree) IteratorAsc(f func(key, value interface{}) bool)

IteratorAsc 使用给定的回调函数 `f` 以升序遍历树（只读）。如果 `f` 返回 true，则继续遍历；如果返回 false，则停止遍历。 md5:c13b99ae40add3b0

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewBTree(3, gutil.X比较文本)
	for i := 0; i < 10; i++ {
		tree.X设置值(i, 10-i)
	}

	tree.IteratorAsc(func(key, value interface{}) bool {
		fmt.Println("key:", key, ", value:", value)
		return true
	})

}

Output:

key: 0 , value: 10
key: 1 , value: 9
key: 2 , value: 8
key: 3 , value: 7
key: 4 , value: 6
key: 5 , value: 5
key: 6 , value: 4
key: 7 , value: 3
key: 8 , value: 2
key: 9 , value: 1

func (*BTree) IteratorAscFrom 

func (tree *BTree) IteratorAscFrom(key interface{}, match bool, f func(key, value interface{}) bool)

IteratorAscFrom 从给定的回调函数 `f` 以升序遍历树。 参数 `key` 指定了遍历的起始条目。`match` 参数指定如果 `key` 完全匹配时是否开始遍历，否则使用索引搜索进行遍历。 如果 `f` 返回 true，则继续遍历；如果返回 false，则停止遍历。 md5:c04855bbd3989808

func (*BTree) IteratorDesc 

func (tree *BTree) IteratorDesc(f func(key, value interface{}) bool)

IteratorDesc 以降序方式遍历树，使用给定的回调函数 `f`。如果 `f` 返回 true，则继续遍历；否则停止。 md5:f6740ea55dafe4bb

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewBTree(3, gutil.X比较文本)
	for i := 0; i < 10; i++ {
		tree.X设置值(i, 10-i)
	}

	tree.IteratorDesc(func(key, value interface{}) bool {
		fmt.Println("key:", key, ", value:", value)
		return true
	})

}

Output:

key: 9 , value: 1
key: 8 , value: 2
key: 7 , value: 3
key: 6 , value: 4
key: 5 , value: 5
key: 4 , value: 6
key: 3 , value: 7
key: 2 , value: 8
key: 1 , value: 9
key: 0 , value: 10

func (*BTree) IteratorDescFrom 

func (tree *BTree) IteratorDescFrom(key interface{}, match bool, f func(key, value interface{}) bool)

IteratorDescFrom 以降序方式遍历树，使用给定的回调函数 `f`。参数 `key` 指定开始遍历的条目。`match` 表示是否在 `key` 完全匹配时开始遍历，否则使用索引搜索遍历。如果 `f` 返回 true，则继续遍历；否则停止。 md5:e6bb2f7d12ab34f6

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	m := make(map[interface{}]interface{})
	for i := 1; i <= 5; i++ {
		m[i] = i * 10
	}
	tree := gtree.NewBTreeFrom(3, gutil.X比较整数, m)

	tree.IteratorDescFrom(5, true, func(key, value interface{}) bool {
		fmt.Println("key:", key, ", value:", value)
		return true
	})

}

Output:

key: 5 , value: 50
key: 4 , value: 40
key: 3 , value: 30
key: 2 , value: 20
key: 1 , value: 10

func (*BTree) IteratorFrom 

func (tree *BTree) IteratorFrom(key interface{}, match bool, f func(key, value interface{}) bool)

IteratorFrom是IteratorAscFrom的别名。 md5:6d3d506bcb5fe942

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	m := make(map[interface{}]interface{})
	for i := 1; i <= 5; i++ {
		m[i] = i * 10
	}
	tree := gtree.NewBTreeFrom(3, gutil.X比较整数, m)

	tree.IteratorFrom(1, true, func(key, value interface{}) bool {
		fmt.Println("key:", key, ", value:", value)
		return true
	})

}

Output:

key: 1 , value: 10
key: 2 , value: 20
key: 3 , value: 30
key: 4 , value: 40
key: 5 , value: 50

func (*BTree) Keys 

func (tree *BTree) Keys() []interface{}

Keys 返回所有键，按升序排列。 md5:c2a692ea3491e160

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewBTree(3, gutil.X比较文本)
	for i := 6; i > 0; i-- {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.Keys())

}

Output:

[key1 key2 key3 key4 key5 key6]

func (*BTree) Left 

func (tree *BTree) Left() *BTreeEntry

Left 返回最左边（最小）的条目，如果树为空则返回 nil。 md5:57cf05edc8d10b88

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewBTree(3, gutil.X比较整数)
	for i := 1; i < 100; i++ {
		tree.X设置值(i, i)
	}
	fmt.Println(tree.Left().Key, tree.Left().Value)

	emptyTree := gtree.NewBTree(3, gutil.X比较整数)
	fmt.Println(emptyTree.Left())

}

Output:

1 1
<nil>

func (*BTree) Map 

func (tree *BTree) Map() map[interface{}]interface{}

Map 返回所有键值对项作为一个映射。 md5:c12ca822a6c71dc1

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewBTree(3, gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.Map())

}

Output:

map[key0:val0 key1:val1 key2:val2 key3:val3 key4:val4 key5:val5]

func (BTree) MarshalJSON 

func (tree BTree) MarshalJSON() (jsonBytes []byte, err error)

MarshalJSON 实现了接口 MarshalJSON 以供 json.Marshal 使用。 md5:43c3b36e60a18f9a

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"
	"github.com/888go/goframe/internal/json"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewBTree(3, gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	bytes, err := json.Marshal(tree)
	if err == nil {
		fmt.Println(gconv.String(bytes))
	}

}

Output:

{"key0":"val0","key1":"val1","key2":"val2","key3":"val3","key4":"val4","key5":"val5"}

func (*BTree) Print 

func (tree *BTree) Print()

Print 将树打印到标准输出。 md5:24fd6288549a501b

Example 
package main

import (
	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewBTree(3, gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	tree.Print()

}

Output:

key0
key1
    key2
key3
    key4
    key5

func (*BTree) Remove 

func (tree *BTree) Remove(key interface{}) (value interface{})

Remove 通过 `key` 从树中移除节点。 md5:42fcfa1d28b3945f

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewBTree(3, gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.Remove("key1"))
	fmt.Println(tree.Remove("key6"))
	fmt.Println(tree.Map())

}

Output:

val1
<nil>
map[key0:val0 key2:val2 key3:val3 key4:val4 key5:val5]

func (*BTree) Removes 

func (tree *BTree) Removes(keys []interface{})

通过`keys`移除树中的批量删除值。 md5:4620c81ac88b2936

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewBTree(3, gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	removeKeys := make([]interface{}, 2)
	removeKeys = append(removeKeys, "key1")
	removeKeys = append(removeKeys, "key6")

	tree.Removes(removeKeys)

	fmt.Println(tree.Map())

}

Output:

map[key0:val0 key2:val2 key3:val3 key4:val4 key5:val5]

func (*BTree) Replace 

func (tree *BTree) Replace(data map[interface{}]interface{})

使用给定的`data`替换树中的数据。 md5:ff636c579597f294

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewBTree(3, gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.Map())

	data := map[interface{}]interface{}{
		"newKey0": "newVal0",
		"newKey1": "newVal1",
		"newKey2": "newVal2",
	}

	tree.Replace(data)

	fmt.Println(tree.Map())

}

Output:

map[key0:val0 key1:val1 key2:val2 key3:val3 key4:val4 key5:val5]
map[newKey0:newVal0 newKey1:newVal1 newKey2:newVal2]

func (*BTree) Right 

func (tree *BTree) Right() *BTreeEntry

Right 返回最右边（最大）的条目，如果树为空则返回 nil。 md5:cd331b29b9cc98f8

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewBTree(3, gutil.X比较整数)
	for i := 1; i < 100; i++ {
		tree.X设置值(i, i)
	}
	fmt.Println(tree.Right().Key, tree.Right().Value)

	emptyTree := gtree.NewBTree(3, gutil.X比较整数)
	fmt.Println(emptyTree.Left())

}

Output:

99 99
<nil>

func (*BTree) Search 

func (tree *BTree) Search(key interface{}) (value interface{}, found bool)

Search 函数使用给定的 `key` 在树中进行查找。 第二个返回参数 `found` 为 true 表示找到了键，否则为 false。 md5:d151c3783cadda2c

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewBTree(3, gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.Search("key0"))
	fmt.Println(tree.Search("key6"))

}

Output:

val0 true
<nil> false

func (*BTree) SetIfNotExist 

func (tree *BTree) SetIfNotExist(key interface{}, value interface{}) bool

SetIfNotExist 如果键`key`不存在，则将`value`设置到映射中，并返回true。如果键`key`已存在，且`value`将被忽略，函数返回false。 md5:f80895920828f03e

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewBTree(3, gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.SetIfNotExist("key1", "newVal1"))
	fmt.Println(tree.SetIfNotExist("key6", "val6"))

}

Output:

false
true

func (*BTree) SetIfNotExistFunc 

func (tree *BTree) SetIfNotExistFunc(key interface{}, f func() interface{}) bool

SetIfNotExistFunc 使用回调函数`f`的返回值设置值，并返回true。 如果`key`已存在，则返回false，且`value`会被忽略。 md5:326c0b7c63d813e7

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewBTree(3, gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.SetIfNotExistFunc("key1", func() interface{} {
		return "newVal1"
	}))
	fmt.Println(tree.SetIfNotExistFunc("key6", func() interface{} {
		return "val6"
	}))

}

Output:

false
true

func (*BTree) SetIfNotExistFuncLock 

func (tree *BTree) SetIfNotExistFuncLock(key interface{}, f func() interface{}) bool

SetIfNotExistFuncLock 使用回调函数 `f` 的返回值设置值，然后返回 true。 如果 `key` 已存在，则返回 false，`value` 将被忽略。

SetIfNotExistFuncLock 与 SetIfNotExistFunc 函数的区别在于， 它在哈希映射的 mutex.Lock 保护下执行函数 `f`。 md5:a6ee84b157328f61

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewBTree(3, gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.SetIfNotExistFuncLock("key1", func() interface{} {
		return "newVal1"
	}))
	fmt.Println(tree.SetIfNotExistFuncLock("key6", func() interface{} {
		return "val6"
	}))

}

Output:

false
true

func (*BTree) Sets 

func (tree *BTree) Sets(data map[interface{}]interface{})

设置批处理将键值对添加到树中。 md5:70c6ec85c8b7476c

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewBTree(3, gutil.X比较文本)

	tree.Sets(map[interface{}]interface{}{
		"key1": "val1",
		"key2": "val2",
	})

	fmt.Println(tree.Map())
	fmt.Println(tree.Size())

}

Output:

map[key1:val1 key2:val2]
2

func (*BTree) Size 

func (tree *BTree) Size() int

Size 返回树中的节点数量。 md5:d437d5852f80de5c

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewBTree(3, gutil.X比较文本)

	fmt.Println(tree.Size())

	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.Size())

}

Output:

0
6

func (*BTree) String 

func (tree *BTree) String() string

String 返回一个表示容器的字符串（用于调试目的）. md5:2d28c3cbf692ce78

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewBTree(3, gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.String())

}

Output:

key0
key1
    key2
key3
    key4
    key5

func (*BTree) Values 

func (tree *BTree) Values() []interface{}

Values返回根据键值升序排列的所有值。 md5:6268d60d7aa20c91

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewBTree(3, gutil.X比较文本)
	for i := 6; i > 0; i-- {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.Values())

}

Output:

[val1 val2 val3 val4 val5 val6]

func (*BTree) X取MapStrAny 

func (tree *BTree) X取MapStrAny() map[string]interface{}

X取MapStrAny 将所有键值对作为 map[string]interface{} 返回。 md5:412456aafc43f7a8

func (*BTree) X设置值 

func (tree *BTree) X设置值(key interface{}, value interface{})

X设置值 将键值对插入到树中。 md5:af4d398e6bf21959

func (*BTree) X遍历 

func (tree *BTree) X遍历(f func(key, value interface{}) bool)

X遍历 是 IteratorAsc 的别名。 md5:1bfdea306db62845

type BTreeEntry 

type BTreeEntry struct {
	Key   interface{}
	Value interface{}
}

BTreeEntry表示节点中包含的键值对。 md5:215d17b4d8c2f829

type BTreeNode 

type BTreeNode struct {
	Parent   *BTreeNode
	Entries  []*BTreeEntry // Contained keys in node
	Children []*BTreeNode  // Children nodes
}

BTreeNode 是树中的一个单个元素。 md5:f6e73ea6e5510845

type RedBlackTree 

type RedBlackTree struct {
	// contains filtered or unexported fields
}

RedBlackTree 保存红黑树中的元素。 md5:5b20879b021304e2

func NewRedBlackTree 

func NewRedBlackTree(comparator func(v1, v2 interface{}) int, safe ...bool) *RedBlackTree

NewRedBlackTree 使用自定义键比较器创建一个红黑树。 参数 `safe` 用于指定是否在并发安全模式下使用树，默认为 false。 md5:ee97b0369d4155af

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"
	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	rbTree := gtree.NewRedBlackTree(gutil.X比较文本)
	for i := 0; i < 6; i++ {
		rbTree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(rbTree)

}

Output:

│           ┌── key5
│       ┌── key4
│   ┌── key3
│   │   └── key2
└── key1
    └── key0

func NewRedBlackTreeFrom 

func NewRedBlackTreeFrom(comparator func(v1, v2 interface{}) int, data map[interface{}]interface{}, safe ...bool) *RedBlackTree

NewRedBlackTreeFrom 根据自定义的键比较器和`data`映射实例化一个红黑树。 参数 `safe` 用于指定是否需要在并发安全的环境下使用该树， 默认情况下为false。 md5:d8480b30bce45a04

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"
	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	rbTree := gtree.NewRedBlackTree(gutil.X比较文本)
	for i := 0; i < 6; i++ {
		rbTree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	otherRBTree := gtree.NewRedBlackTreeFrom(gutil.X比较文本, rbTree.Map())
	fmt.Println(otherRBTree)

	// May Output:
	// │           ┌── key5
	// │       ┌── key4
	// │   ┌── key3
	// │   │   └── key2
	// └── key1
	//     └── key0
}

func (*RedBlackTree) Ceiling 

func (tree *RedBlackTree) Ceiling(key interface{}) (ceiling *RedBlackTreeNode, found bool)

Ceiling找到输入键的天花板节点，如果没有找到天花板节点则返回nil。第二个返回参数表示是否找到了天花板，否则为false。

定义天花板节点为其键大于或等于给定`key`的最小节点。可能找不到天花板节点，原因可能是树为空，或者树中的所有节点都小于给定节点。 md5:3d6d229626a6b5b2

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewRedBlackTree(gutil.X比较整数)
	for i := 1; i < 100; i++ {
		if i != 50 {
			tree.X设置值(i, i)
		}
	}

	node, found := tree.Ceiling(1)
	if found {
		fmt.Println("Ceiling 1:", node.Key)
	}

	node, found = tree.Ceiling(50)
	if found {
		fmt.Println("Ceiling 50:", node.Key)
	}

	node, found = tree.Ceiling(100)
	if found {
		fmt.Println("Ceiling 100:", node.Key)
	}

	node, found = tree.Ceiling(-1)
	if found {
		fmt.Println("Ceiling -1:", node.Key)
	}

}

Output:

Ceiling 1: 1
Ceiling 50: 51
Ceiling -1: 1

func (*RedBlackTree) Clear 

func (tree *RedBlackTree) Clear()

Clear 从树中移除所有节点。 md5:a7db742922264980

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewRedBlackTree(gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值(1000+i, "val"+gconv.String(i))
	}
	fmt.Println(tree.Size())

	tree.Clear()
	fmt.Println(tree.Size())

}

Output:

6
0

func (*RedBlackTree) Clone 

func (tree *RedBlackTree) Clone() *RedBlackTree

Clone 返回一个新的树，其中包含当前树的副本。 md5:256477216ae712b7

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	b := gtree.NewRedBlackTree(gutil.X比较文本)
	for i := 0; i < 6; i++ {
		b.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	tree := b.Clone()

	fmt.Println(tree.Map())
	fmt.Println(tree.Size())

}

Output:

map[key0:val0 key1:val1 key2:val2 key3:val3 key4:val4 key5:val5]
6

func (*RedBlackTree) Contains 

func (tree *RedBlackTree) Contains(key interface{}) bool

Contains 检查键 `key` 是否存在于树中。 md5:77fd85af8e586867

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewRedBlackTree(gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.Contains("key1"))
	fmt.Println(tree.Contains("key6"))

}

Output:

true
false

func (*RedBlackTree) Flip 

func (tree *RedBlackTree) Flip(comparator ...func(v1, v2 interface{}) int)

Flip 将树中的键值对交换为值键。 请注意，你应该确保值的类型与键相同，否则比较器会panic。

如果值的类型与键不同，你需要传递新的 `comparator`。 md5:e71ceac22aee55f1

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewRedBlackTree(gutil.X比较文本)
	for i := 1; i < 6; i++ {
		tree.X设置值(i, i*10)
	}

	fmt.Println("Before Flip", tree.Map())

	tree.Flip()

	fmt.Println("After Flip", tree.Map())

}

Output:

Before Flip map[1:10 2:20 3:30 4:40 5:50]
After Flip map[10:1 20:2 30:3 40:4 50:5]

func (*RedBlackTree) Floor 

func (tree *RedBlackTree) Floor(key interface{}) (floor *RedBlackTreeNode, found bool)

Floor 找到输入键的地板节点，如果没有找到地板节点，则返回nil。第二个返回参数表示是否找到了地板（true表示找到，false表示未找到）。

地板节点定义为其键小于或等于给定`key`的最大节点。可能无法找到地板节点，因为树为空，或者树中的所有节点都大于给定节点。 md5:e76dc868738ea5a0

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewRedBlackTree(gutil.X比较整数)
	for i := 1; i < 100; i++ {
		if i != 50 {
			tree.X设置值(i, i)
		}
	}

	node, found := tree.Floor(95)
	if found {
		fmt.Println("Floor 95:", node.Key)
	}

	node, found = tree.Floor(50)
	if found {
		fmt.Println("Floor 50:", node.Key)
	}

	node, found = tree.Floor(100)
	if found {
		fmt.Println("Floor 100:", node.Key)
	}

	node, found = tree.Floor(0)
	if found {
		fmt.Println("Floor 0:", node.Key)
	}

}

Output:

Floor 95: 95
Floor 50: 49
Floor 100: 99

func (*RedBlackTree) Get 

func (tree *RedBlackTree) Get(key interface{}) (value interface{})

Get 通过`key`在树中搜索节点，并返回其值，如果`key`在树中未找到，则返回nil。 md5:2e2483db20a69167

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewRedBlackTree(gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.Get("key1"))
	fmt.Println(tree.Get("key10"))

}

Output:

val1
<nil>

func (*RedBlackTree) GetOrSet 

func (tree *RedBlackTree) GetOrSet(key interface{}, value interface{}) interface{}

GetOrSet 通过键返回值， 如果该键不存在，则使用给定的`value`设置值，然后返回这个值。 md5:d8f89b6dec47292b

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewRedBlackTree(gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.GetOrSet("key1", "newVal1"))
	fmt.Println(tree.GetOrSet("key6", "val6"))

}

Output:

val1
val6

func (*RedBlackTree) GetOrSetFunc 

func (tree *RedBlackTree) GetOrSetFunc(key interface{}, f func() interface{}) interface{}

GetOrSetFunc 通过键获取值， 如果键不存在，则使用回调函数`f`的返回值设置值， 并返回这个设置的值。 md5:f584dd7547dfbcc0

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewRedBlackTree(gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.GetOrSetFunc("key1", func() interface{} {
		return "newVal1"
	}))
	fmt.Println(tree.GetOrSetFunc("key6", func() interface{} {
		return "val6"
	}))

}

Output:

val1
val6

func (*RedBlackTree) GetOrSetFuncLock 

func (tree *RedBlackTree) GetOrSetFuncLock(key interface{}, f func() interface{}) interface{}

GetOrSetFuncLock 通过键获取值， 如果不存在，它将使用回调函数 `f` 的返回值设置该值，然后返回这个值。

GetOrSetFuncLock 与 GetOrSetFunc 函数的不同之处在于，它在执行函数 `f` 时会先锁定哈希映射的 mutex。 md5:d32fdee586d84dde

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewRedBlackTree(gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.GetOrSetFuncLock("key1", func() interface{} {
		return "newVal1"
	}))
	fmt.Println(tree.GetOrSetFuncLock("key6", func() interface{} {
		return "val6"
	}))

}

Output:

val1
val6

func (*RedBlackTree) GetVar 

func (tree *RedBlackTree) GetVar(key interface{}) *gvar.Var

GetVar 函数通过给定的 `key` 返回一个 gvar.Var，其值为对应的变量。 返回的 gvar.Var 不是并发安全的。 md5:a04747902e4bf242

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewRedBlackTree(gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.GetVar("key1").String())

}

Output:

val1

func (*RedBlackTree) GetVarOrSet 

func (tree *RedBlackTree) GetVarOrSet(key interface{}, value interface{}) *gvar.Var

GetVarOrSet 返回一个从 GetVarOrSet 获取的结果的 gvar.Var。返回的 gvar.Var 不是线程安全的。 md5:089beb08264e18cf

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewRedBlackTree(gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.GetVarOrSet("key1", "newVal1"))
	fmt.Println(tree.GetVarOrSet("key6", "val6"))

}

Output:

val1
val6

func (*RedBlackTree) GetVarOrSetFunc 

func (tree *RedBlackTree) GetVarOrSetFunc(key interface{}, f func() interface{}) *gvar.Var

GetVarOrSetFunc 返回一个 gvar.Var，其结果来自 GetOrSetFunc。 返回的 gvar.Var 不是线程安全的。 md5:8c97b145faade5ae

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewRedBlackTree(gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.GetVarOrSetFunc("key1", func() interface{} {
		return "newVal1"
	}))
	fmt.Println(tree.GetVarOrSetFunc("key6", func() interface{} {
		return "val6"
	}))

}

Output:

val1
val6

func (*RedBlackTree) GetVarOrSetFuncLock 

func (tree *RedBlackTree) GetVarOrSetFuncLock(key interface{}, f func() interface{}) *gvar.Var

GetVarOrSetFuncLock 返回一个gvar.Var，其结果来自GetOrSetFuncLock。 返回的gvar.Var是非并发安全的。 md5:90c22300c2187ce4

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewRedBlackTree(gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.GetVarOrSetFuncLock("key1", func() interface{} {
		return "newVal1"
	}))
	fmt.Println(tree.GetVarOrSetFuncLock("key6", func() interface{} {
		return "val6"
	}))

}

Output:

val1
val6

func (*RedBlackTree) IsEmpty 

func (tree *RedBlackTree) IsEmpty() bool

IsEmpty 如果树中不包含任何节点，则返回true。 md5:8f7ae813360d880b

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewRedBlackTree(gutil.X比较文本)

	fmt.Println(tree.IsEmpty())

	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.IsEmpty())

}

Output:

true
false

func (*RedBlackTree) IteratorAsc 

func (tree *RedBlackTree) IteratorAsc(f func(key, value interface{}) bool)

IteratorAsc 使用给定的回调函数 `f` 以升序遍历树（只读）。如果 `f` 返回 true，则继续遍历；如果返回 false，则停止遍历。 md5:c13b99ae40add3b0

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewRedBlackTree(gutil.X比较文本)
	for i := 0; i < 10; i++ {
		tree.X设置值(i, 10-i)
	}

	tree.IteratorAsc(func(key, value interface{}) bool {
		fmt.Println("key:", key, ", value:", value)
		return true
	})

}

Output:

key: 0 , value: 10
key: 1 , value: 9
key: 2 , value: 8
key: 3 , value: 7
key: 4 , value: 6
key: 5 , value: 5
key: 6 , value: 4
key: 7 , value: 3
key: 8 , value: 2
key: 9 , value: 1

func (*RedBlackTree) IteratorAscFrom 

func (tree *RedBlackTree) IteratorAscFrom(key interface{}, match bool, f func(key, value interface{}) bool)

IteratorAscFrom 从给定的回调函数 `f` 以升序遍历树。 参数 `key` 指定了遍历的起始条目。`match` 参数指定如果 `key` 完全匹配时是否开始遍历，否则使用索引搜索进行遍历。 如果 `f` 返回 true，则继续遍历；如果返回 false，则停止遍历。 md5:c04855bbd3989808

func (*RedBlackTree) IteratorDesc 

func (tree *RedBlackTree) IteratorDesc(f func(key, value interface{}) bool)

IteratorDesc 以降序方式遍历树，使用给定的回调函数 `f`。如果 `f` 返回 true，则继续遍历；否则停止。 md5:f6740ea55dafe4bb

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewRedBlackTree(gutil.X比较文本)
	for i := 0; i < 10; i++ {
		tree.X设置值(i, 10-i)
	}

	tree.IteratorDesc(func(key, value interface{}) bool {
		fmt.Println("key:", key, ", value:", value)
		return true
	})

}

Output:

key: 9 , value: 1
key: 8 , value: 2
key: 7 , value: 3
key: 6 , value: 4
key: 5 , value: 5
key: 4 , value: 6
key: 3 , value: 7
key: 2 , value: 8
key: 1 , value: 9
key: 0 , value: 10

func (*RedBlackTree) IteratorDescFrom 

func (tree *RedBlackTree) IteratorDescFrom(key interface{}, match bool, f func(key, value interface{}) bool)

IteratorDescFrom 以降序方式遍历树，使用给定的回调函数 `f`。参数 `key` 指定开始遍历的条目。`match` 表示是否在 `key` 完全匹配时开始遍历，否则使用索引搜索遍历。如果 `f` 返回 true，则继续遍历；否则停止。 md5:e6bb2f7d12ab34f6

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	m := make(map[interface{}]interface{})
	for i := 1; i <= 5; i++ {
		m[i] = i * 10
	}
	tree := gtree.NewRedBlackTreeFrom(gutil.X比较整数, m)

	tree.IteratorDescFrom(5, true, func(key, value interface{}) bool {
		fmt.Println("key:", key, ", value:", value)
		return true
	})

}

Output:

key: 5 , value: 50
key: 4 , value: 40
key: 3 , value: 30
key: 2 , value: 20
key: 1 , value: 10

func (*RedBlackTree) IteratorFrom 

func (tree *RedBlackTree) IteratorFrom(key interface{}, match bool, f func(key, value interface{}) bool)

IteratorFrom是IteratorAscFrom的别名。 md5:6d3d506bcb5fe942

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	m := make(map[interface{}]interface{})
	for i := 1; i <= 5; i++ {
		m[i] = i * 10
	}
	tree := gtree.NewRedBlackTreeFrom(gutil.X比较整数, m)

	tree.IteratorFrom(1, true, func(key, value interface{}) bool {
		fmt.Println("key:", key, ", value:", value)
		return true
	})

}

Output:

key: 1 , value: 10
key: 2 , value: 20
key: 3 , value: 30
key: 4 , value: 40
key: 5 , value: 50

func (*RedBlackTree) Keys 

func (tree *RedBlackTree) Keys() []interface{}

Keys 返回所有键，按升序排列。 md5:c2a692ea3491e160

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewRedBlackTree(gutil.X比较文本)
	for i := 6; i > 0; i-- {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.Keys())

}

Output:

[key1 key2 key3 key4 key5 key6]

func (*RedBlackTree) Left 

func (tree *RedBlackTree) Left() *RedBlackTreeNode

Left 返回最左边（最小）的节点，如果树为空则返回nil。 md5:73ad6a74ff7ce0d2

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewRedBlackTree(gutil.X比较整数)
	for i := 1; i < 100; i++ {
		tree.X设置值(i, i)
	}
	fmt.Println(tree.Left().Key, tree.Left().Value)

	emptyTree := gtree.NewRedBlackTree(gutil.X比较整数)
	fmt.Println(emptyTree.Left())

}

Output:

1 1
<nil>

func (*RedBlackTree) Map 

func (tree *RedBlackTree) Map() map[interface{}]interface{}

Map 返回所有键值对项作为一个映射。 md5:c12ca822a6c71dc1

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewRedBlackTree(gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.Map())

}

Output:

map[key0:val0 key1:val1 key2:val2 key3:val3 key4:val4 key5:val5]

func (RedBlackTree) MarshalJSON 

func (tree RedBlackTree) MarshalJSON() (jsonBytes []byte, err error)

MarshalJSON 实现了接口 MarshalJSON 以供 json.Marshal 使用。 md5:43c3b36e60a18f9a

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"
	"github.com/888go/goframe/internal/json"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewRedBlackTree(gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	bytes, err := json.Marshal(tree)
	if err == nil {
		fmt.Println(gconv.String(bytes))
	}

}

Output:

{"key0":"val0","key1":"val1","key2":"val2","key3":"val3","key4":"val4","key5":"val5"}

func (*RedBlackTree) Print 

func (tree *RedBlackTree) Print()

Print 将树打印到标准输出。 md5:24fd6288549a501b

Example 
package main

import (
	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewRedBlackTree(gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	tree.Print()

}

Output:

│           ┌── key5
│       ┌── key4
│   ┌── key3
│   │   └── key2
└── key1
    └── key0

func (*RedBlackTree) Remove 

func (tree *RedBlackTree) Remove(key interface{}) (value interface{})

Remove 通过 `key` 从树中移除节点。 md5:42fcfa1d28b3945f

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewRedBlackTree(gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.Remove("key1"))
	fmt.Println(tree.Remove("key6"))
	fmt.Println(tree.Map())

}

Output:

val1
<nil>
map[key0:val0 key2:val2 key3:val3 key4:val4 key5:val5]

func (*RedBlackTree) Removes 

func (tree *RedBlackTree) Removes(keys []interface{})

通过`keys`移除树中的批量删除值。 md5:4620c81ac88b2936

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewRedBlackTree(gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	removeKeys := make([]interface{}, 2)
	removeKeys = append(removeKeys, "key1")
	removeKeys = append(removeKeys, "key6")

	tree.Removes(removeKeys)

	fmt.Println(tree.Map())

}

Output:

map[key0:val0 key2:val2 key3:val3 key4:val4 key5:val5]

func (*RedBlackTree) Replace 

func (tree *RedBlackTree) Replace(data map[interface{}]interface{})

使用给定的`data`替换树中的数据。 md5:ff636c579597f294

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewRedBlackTree(gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.Map())

	data := map[interface{}]interface{}{
		"newKey0": "newVal0",
		"newKey1": "newVal1",
		"newKey2": "newVal2",
	}

	tree.Replace(data)

	fmt.Println(tree.Map())

}

Output:

map[key0:val0 key1:val1 key2:val2 key3:val3 key4:val4 key5:val5]
map[newKey0:newVal0 newKey1:newVal1 newKey2:newVal2]

func (*RedBlackTree) Right 

func (tree *RedBlackTree) Right() *RedBlackTreeNode

Right 返回最右边（最大）的节点，如果树为空则返回nil。 md5:92003588329d774d

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewRedBlackTree(gutil.X比较整数)
	for i := 1; i < 100; i++ {
		tree.X设置值(i, i)
	}
	fmt.Println(tree.Right().Key, tree.Right().Value)

	emptyTree := gtree.NewRedBlackTree(gutil.X比较整数)
	fmt.Println(emptyTree.Left())

}

Output:

99 99
<nil>

func (*RedBlackTree) Search 

func (tree *RedBlackTree) Search(key interface{}) (value interface{}, found bool)

Search 函数使用给定的 `key` 在树中进行查找。 第二个返回参数 `found` 为 true 表示找到了键，否则为 false。 md5:d151c3783cadda2c

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewRedBlackTree(gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.Search("key0"))
	fmt.Println(tree.Search("key6"))

}

Output:

val0 true
<nil> false

func (*RedBlackTree) SetComparator 

func (tree *RedBlackTree) SetComparator(comparator func(a, b interface{}) int)

SetComparator 设置或更改排序的比较器。 md5:5108f29cfa1a4664

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	var tree gtree.RedBlackTree
	tree.SetComparator(gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.Map())
	fmt.Println(tree.Size())

}

Output:

map[key0:val0 key1:val1 key2:val2 key3:val3 key4:val4 key5:val5]
6

func (*RedBlackTree) SetIfNotExist 

func (tree *RedBlackTree) SetIfNotExist(key interface{}, value interface{}) bool

SetIfNotExist 如果键`key`不存在，则将`value`设置到映射中，并返回true。如果键`key`已存在，且`value`将被忽略，函数返回false。 md5:f80895920828f03e

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewRedBlackTree(gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.SetIfNotExist("key1", "newVal1"))
	fmt.Println(tree.SetIfNotExist("key6", "val6"))

}

Output:

false
true

func (*RedBlackTree) SetIfNotExistFunc 

func (tree *RedBlackTree) SetIfNotExistFunc(key interface{}, f func() interface{}) bool

SetIfNotExistFunc 使用回调函数`f`的返回值设置值，并返回true。 如果`key`已存在，则返回false，且`value`会被忽略。 md5:326c0b7c63d813e7

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewRedBlackTree(gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.SetIfNotExistFunc("key1", func() interface{} {
		return "newVal1"
	}))
	fmt.Println(tree.SetIfNotExistFunc("key6", func() interface{} {
		return "val6"
	}))

}

Output:

false
true

func (*RedBlackTree) SetIfNotExistFuncLock 

func (tree *RedBlackTree) SetIfNotExistFuncLock(key interface{}, f func() interface{}) bool

SetIfNotExistFuncLock 使用回调函数 `f` 的返回值设置值，然后返回 true。 如果 `key` 已存在，则返回 false，`value` 将被忽略。

SetIfNotExistFuncLock 与 SetIfNotExistFunc 函数的区别在于， 它在哈希映射的 mutex.Lock 保护下执行函数 `f`。 md5:a6ee84b157328f61

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewRedBlackTree(gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.SetIfNotExistFuncLock("key1", func() interface{} {
		return "newVal1"
	}))
	fmt.Println(tree.SetIfNotExistFuncLock("key6", func() interface{} {
		return "val6"
	}))

}

Output:

false
true

func (*RedBlackTree) Sets 

func (tree *RedBlackTree) Sets(data map[interface{}]interface{})

设置批处理将键值对添加到树中。 md5:70c6ec85c8b7476c

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewRedBlackTree(gutil.X比较文本)

	tree.Sets(map[interface{}]interface{}{
		"key1": "val1",
		"key2": "val2",
	})

	fmt.Println(tree.Map())
	fmt.Println(tree.Size())

}

Output:

map[key1:val1 key2:val2]
2

func (*RedBlackTree) Size 

func (tree *RedBlackTree) Size() int

Size 返回树中的节点数量。 md5:d437d5852f80de5c

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewRedBlackTree(gutil.X比较文本)

	fmt.Println(tree.Size())

	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.Size())

}

Output:

0
6

func (*RedBlackTree) String 

func (tree *RedBlackTree) String() string

String 返回容器的字符串表示形式。 md5:d27ed19a0d92f8aa

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewRedBlackTree(gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.String())

}

Output:

│           ┌── key5
│       ┌── key4
│   ┌── key3
│   │   └── key2
└── key1
    └── key0

func (*RedBlackTree) UnmarshalJSON 

func (tree *RedBlackTree) UnmarshalJSON(b []byte) error

UnmarshalJSON实现了json.Unmarshal接口的UnmarshalJSON方法。 md5:f6766b88cf3d63c2

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"
	"github.com/888go/goframe/internal/json"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewRedBlackTree(gutil.X比较文本)
	for i := 0; i < 6; i++ {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}
	bytes, err := json.Marshal(tree)

	otherTree := gtree.NewRedBlackTree(gutil.X比较文本)
	err = json.Unmarshal(bytes, &otherTree)
	if err == nil {
		fmt.Println(otherTree.Map())
	}

}

Output:

map[key0:val0 key1:val1 key2:val2 key3:val3 key4:val4 key5:val5]

func (*RedBlackTree) UnmarshalValue 

func (tree *RedBlackTree) UnmarshalValue(value interface{}) (err error)

UnmarshalValue 是一个接口实现，用于将任何类型的值设置到映射中。 md5:6f3087a6f7df5477

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewRedBlackTree(gutil.X比较文本)

	type User struct {
		Uid   int
		Name  string
		Pass1 string `gconv:"password1"`
		Pass2 string `gconv:"password2"`
	}

	var (
		user = User{
			Uid:   1,
			Name:  "john",
			Pass1: "123",
			Pass2: "456",
		}
	)
	if err := gconv.Scan(user, tree); err == nil {
		fmt.Printf("%#v", tree.Map())
	}

}

Output:

map[interface {}]interface {}{"Name":"john", "Uid":1, "password1":"123", "password2":"456"}

func (*RedBlackTree) Values 

func (tree *RedBlackTree) Values() []interface{}

Values返回根据键值升序排列的所有值。 md5:6268d60d7aa20c91

Example 
package main

import (
	"fmt"

	gtree "github.com/888go/goframe/container/gtree"

	gconv "github.com/888go/goframe/util/gconv"

	gutil "github.com/888go/goframe/util/gutil"
)

func main() {
	tree := gtree.NewRedBlackTree(gutil.X比较文本)
	for i := 6; i > 0; i-- {
		tree.X设置值("key"+gconv.String(i), "val"+gconv.String(i))
	}

	fmt.Println(tree.Values())

}

Output:

[val1 val2 val3 val4 val5 val6]

func (*RedBlackTree) X取MapStrAny 

func (tree *RedBlackTree) X取MapStrAny() map[string]interface{}

X取MapStrAny 将所有键值对作为 map[string]interface{} 返回。 md5:412456aafc43f7a8

func (*RedBlackTree) X设置值 

func (tree *RedBlackTree) X设置值(key interface{}, value interface{})

X设置值 将键值对插入到树中。 md5:af4d398e6bf21959

func (*RedBlackTree) X遍历 

func (tree *RedBlackTree) X遍历(f func(key, value interface{}) bool)

X遍历 是 IteratorAsc 的别名。 md5:1bfdea306db62845

type RedBlackTreeNode 

type RedBlackTreeNode struct {
	Key   interface{}
	Value interface{}
	// contains filtered or unexported fields
}

RedBlackTreeNode 是树中的一个元素。 md5:782ce0fe3b02c5f4

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.