【发布时间】：2014-06-23 19:24:24
【问题描述】：
我是 Go 新手，已经实现了二叉搜索树。树可以存储任何值（具体来说，任何实现 interface{} 的值）。
我想在这个实现的基础上创建一个自平衡的红黑树。在面向对象的语言中，我会定义一个 BinarySearchTree 的子类，添加一个 color 数据成员，然后重写 Insert 方法以执行平衡操作。
问题：如何在不重复代码的情况下在 Go 中实现二叉搜索树和红黑树？
当前的二叉搜索树实现
这是我的二叉搜索树实现：
package trees
import (
"github.com/modocache/cargo/comparators"
"reflect"
)
type BinarySearchTree struct {
Parent *BinarySearchTree
Left *BinarySearchTree
Right *BinarySearchTree
Value interface{} // Can hold any value
less comparators.Less // A comparator function to determine whether
// an inserted value is placed left or right
}
func NewBinarySearchTree(value interface{}, less comparators.Less) *BinarySearchTree {
return &BinarySearchTree{Value: value, less: less}
}
func (tree *BinarySearchTree) Insert(value interface{}) *BinarySearchTree {
if tree.less(value, tree.Value) {
return tree.insertLeft(value)
} else {
return tree.insertRight(value)
}
}
func (tree *BinarySearchTree) insertLeft(value interface{}) *BinarySearchTree {
if tree.Left == nil {
tree.Left = &BinarySearchTree{Value: value, Parent: tree, less: tree.less}
return tree.Left
} else {
return tree.Left.Insert(value)
}
}
func (tree *BinarySearchTree) insertRight(value interface{}) *BinarySearchTree {
if tree.Right == nil {
tree.Right = &BinarySearchTree{Value: value, Parent: tree, less: tree.less}
return tree.Right
} else {
return tree.Right.Insert(value)
}
}
func (tree *BinarySearchTree) Find(value interface{}) *BinarySearchTree {
if reflect.DeepEqual(value, tree.Value) {
return tree
} else if tree.less(value, tree.Value) {
return tree.findLeft(value)
} else {
return tree.findRight(value)
}
}
func (tree *BinarySearchTree) findLeft(value interface{}) *BinarySearchTree {
if tree.Left == nil {
return nil
} else {
return tree.Left.Find(value)
}
}
func (tree *BinarySearchTree) findRight(value interface{}) *BinarySearchTree {
if tree.Right == nil {
return nil
} else {
return tree.Right.Find(value)
}
}
以下是如何使用此结构的示例：
tree := NewBinarySearchTree(100, func(value, treeValue interface{}) bool {
return value.(int) < treeValue.(int)
})
tree.Insert(200)
tree.Insert(300)
tree.Insert(250)
tree.Insert(150)
tree.Insert(275)
tree.Find(250) // Returns tree.Right.Right.Left
希望（但不可能）实现红黑树
我想像这样“扩展”BinarySearchTree struct：
type RedBlackTree struct {
Parent *RedBlackTree // These must be able to store
Left *RedBlackTree // pointers to red-black trees
Right *RedBlackTree
Value interface{}
less comparators.Less
color RedBlackTreeColor // Each tree must maintain a color property
}
然后像这样“覆盖”.Insert() 方法：
func (tree *RedBlackTree) Insert(value interface{}) *RedBlackTree {
var inserted *RedBlackTree
// Insertion logic is identical to BinarySearchTree
if tree.less(value, tree.Value) {
inserted = tree.insertLeft(value)
} else {
inserted tree.insertRight(value)
}
// .balance() is a private method on RedBlackTree that balances
// the tree based on each node's color
inserted.balance()
// Returns a *RedBlackTree
return inserted
}
不过，我不认为这是惯用的 Go 代码。
- 由于
BinarySearchTree是用指向其他BinarySearchTree结构的指针定义的，“扩展”BinarySearchTree的RedBlackTree仍然具有指向BinarySearchTree对象的指针。 - 无法“覆盖”
.Insert()。我唯一的选择是定义另一种方法，例如.BalancedInsert()。
目前正在尝试
我目前正在尝试的一个想法是定义一个这样的接口：
type BinarySearchable interface {
Parent() *BinarySearchable
SetParent(searchable *BinarySearchable)
Left() *BinarySearchable
SetLeft(searchable *BinarySearchable)
Right() *BinarySearchable
SetRight(searchable *BinarySearchable)
Value() interface{}
Less() comparators.Less
Insert(searchable *BinarySearchable) *BinarySearchable
Find(value interface{}) *BinarySearchable
}
BinarySearchTree 和 RedBlackTree 然后将实现这些接口。然而，一个问题是如何共享.Insert() 逻辑。也许定义一个每个结构将使用的私有函数？
欢迎提出任何建议。
【问题讨论】：
标签： go binary-search-tree dry red-black-tree