create

tree/bptree.go

@@ -0,0 +1,90 @@
+package tree
+
+// B+ tree
+
+type BPTree[T Item[T]] struct {
+	length int
+	degree int
+}
+
+// 初始化B+树
+func NewBPTree[T Item[T]](degree int) *BPTree[T] {
+	return &BPTree[T]{
+		degree: degree,
+	}
+}
+
+// nil cannot be added to the tree (will panic).
+func (t *BPTree[T]) ReplaceOrInsert(item Item[T]) Item[T] {
+	return item
+}
+
+func (t *BPTree[T]) Delete(item T) (T, bool) {
+	return *new(T), false
+}
+
+func (t *BPTree[T]) Get(key T) (T, bool) {
+	return *new(T), false
+}
+
+// Has returns true if the given key is in the tree.
+func (t *BPTree[T]) Has(key T) bool {
+	return false
+}
+
+// 升序
+func (t *BPTree[T]) Ascend(iterator ItemIterator[T]) {
+}
+
+// 大于等于
+func (t *BPTree[T]) AscendGreaterOrEqual(pivot Item[T], iterator ItemIterator[T]) {
+
+}
+
+// 小于
+func (t *BPTree[T]) AscendLessThan(pivot Item[T], iterator ItemIterator[T]) {
+
+}
+
+// 范围迭代
+func (t *BPTree[T]) AscendRange(greaterOrEqual, lessThan Item[T], iterator ItemIterator[T]) {
+
+}
+
+// 降序升序迭代
+func (t *BPTree[T]) Descend(iterator ItemIterator[T]) {
+}
+
+// 大于，降序迭代
+func (t *BPTree[T]) DescendGreaterThan(pivot Item[T], iterator ItemIterator[T]) {
+
+}
+
+// 小于等于，降序迭代
+func (t *BPTree[T]) DescendLessOrEquql(pivot Item[T], iterator ItemIterator[T]) {
+
+}
+
+// 范围降序迭代
+func (t *BPTree[T]) DescendRange(greaterOrEqual, lessThan Item[T], iterator ItemIterator[T]) {
+
+}
+
+func (t *BPTree[T]) Min() (T, bool) {
+	return *new(T), false
+}
+
+func (t *BPTree[T]) Max() (T, bool) {
+	return *new(T), false
+}
+
+func (t *BPTree[T]) Len() int {
+	return t.length
+}
+
+func (t *BPTree[T]) Clear() {
+}
+
+// B+ 树节点
+type bpNode[T Item[T]] struct {
+}

tree/bptree_test.go

@@ -0,0 +1,2 @@
+package tree_test
+

tree/btree.go

@@ -0,0 +1,112 @@
+package tree
+
+import "sync"
+
+const (
+	DefaultFreeListSize = 32
+)
+
+type FreeList[T Item[T]] struct {
+	mu       sync.Mutex
+	freelist []*bNode[T]
+}
+
+// 初始化B树
+type BTree[T Item[T]] struct {
+	degree int
+	length int
+	root   *bNode[T]
+}
+
+func NewBTree[T Item[T]](degree int) *BTree[T] {
+	return &BTree[T]{}
+}
+
+// nil cannot be added to the tree (will panic).
+func (t *BTree[T]) ReplaceOrInsert(item Item[T]) Item[T] {
+	return item
+}
+
+func (t *BTree[T]) Delete(item T) (T, bool) {
+	return *new(T), false
+}
+
+func (t *BTree[T]) Get(key T) (T, bool) {
+	return *new(T), false
+}
+
+// Has returns true if the given key is in the tree.
+func (t *BTree[T]) Has(key T) bool {
+	return false
+}
+
+// 升序
+func (t *BTree[T]) Ascend(iterator ItemIterator[T]) {
+}
+
+// 大于等于
+func (t *BTree[T]) AscendGreaterOrEqual(pivot Item[T], iterator ItemIterator[T]) {
+
+}
+
+// 小于
+func (t *BTree[T]) AscendLessThan(pivot Item[T], iterator ItemIterator[T]) {
+
+}
+
+// 范围迭代
+func (t *BTree[T]) AscendRange(greaterOrEqual, lessThan Item[T], iterator ItemIterator[T]) {
+
+}
+
+// 降序升序迭代
+func (t *BTree[T]) Descend(iterator ItemIterator[T]) {
+}
+
+// 大于，降序迭代
+func (t *BTree[T]) DescendGreaterThan(pivot Item[T], iterator ItemIterator[T]) {
+
+}
+
+// 小于等于，降序迭代
+func (t *BTree[T]) DescendLessOrEquql(pivot Item[T], iterator ItemIterator[T]) {
+
+}
+
+// 范围降序迭代
+func (t *BTree[T]) DescendRange(greaterOrEqual, lessThan Item[T], iterator ItemIterator[T]) {
+
+}
+
+func (t *BTree[T]) Min() (T, bool) {
+	return *new(T), false
+}
+
+func (t *BTree[T]) Max() (T, bool) {
+	return *new(T), false
+}
+
+func (t *BTree[T]) Len() int {
+	return t.length
+}
+
+func (t *BTree[T]) Clear() {
+
+}
+
+// items stores items in a node.
+type items[T Item[T]] []T
+
+// children stores child nodes in a node.
+type children[T Item[T]] []*bNode[T]
+
+type copyOnWriteContext[T Item[T]] struct {
+	freelist *FreeList[T]
+}
+
+// B树的内部节点
+type bNode[T Item[T]] struct {
+	items    items[T]
+	children children[T]
+	cow      *copyOnWriteContext[T]
+}

tree/btree_test.go

@@ -0,0 +1,15 @@
+package tree
+
+import "testing"
+
+func TestNewBTree(t *testing.T) {
+	tr := NewBTree[Int](32)
+
+	_ = tr
+}
+
+type Int int
+
+func (a Int) Less(b Int) bool {
+	return a < b
+}

tree/rbtree.go

@@ -0,0 +1,42 @@
+package tree
+
+type color uint
+
+const (
+	RED   color = 0
+	BLACK color = 1
+)
+
+type RBTree[T Item[T]] struct {
+	root *redBlackNode[T]
+}
+
+// 初始化红黒树
+func NewRBTree[T Item[T]]() *RBTree[T] {
+	return &RBTree[T]{}
+}
+
+func (t *RBTree[T]) ReplaceOrInsert(item Item[T]) Item[T] {
+	return item
+}
+
+func (t *RBTree[T]) Delete(item T) (T, bool) {
+	return *new(T), false
+}
+
+func (t *RBTree[T]) Get(key T) (T, bool) {
+	return *new(T), false
+}
+
+func (t *RBTree[T]) Has(key T) bool {
+	return false
+}
+
+// 红黒树节点
+type redBlackNode[T Item[T]] struct {
+	Color  color            // 颜色
+	Item   T                // 数据
+	parent *redBlackNode[T] // 父节点
+	left   *redBlackNode[T] // 左
+	right  *redBlackNode[T] // 右
+}

tree/tree.go

@@ -0,0 +1,28 @@
+package tree
+
+type ITree[T Item[T]] interface {
+	ReplaceOrInsert(item Item[T]) Item[T]                                    // nil cannot be added to the tree (will panic).
+	Delete(item T) (T, bool)                                                 // 删除节点
+	Get(key T) (T, bool)                                                     // 获取节点
+	Has(key T) bool                                                          // 节点在树中存在时返回true
+	Ascend(iterator ItemIterator[T])                                         // 升序
+	AscendGreaterOrEqual(pivot Item[T], iterator ItemIterator[T])            // 大于等于
+	AscendLessThan(pivot Item[T], iterator ItemIterator[T])                  // 小于
+	AscendRange(greaterOrEqual, lessThan Item[T], iterator ItemIterator[T])  // 范围迭代
+	Descend(iterator ItemIterator[T])                                        // 降序升序迭代
+	DescendGreaterThan(pivot Item[T], iterator ItemIterator[T])              // 大于，降序迭代
+	DescendLessOrEquql(pivot Item[T], iterator ItemIterator[T])              // 小于等于，降序迭代
+	DescendRange(greaterOrEqual, lessThan Item[T], iterator ItemIterator[T]) // 范围降序迭代
+	Min() (T, bool)
+	Max() (T, bool)
+	Len() int
+	Clear()
+}
+
+// 表示树中的单个对象。
+type Item[T any] interface {
+	Less(than T) bool
+}
+
+// 迭代函数，返回true时停止迭代
+type ItemIterator[T Item[T]] func(i T) bool