Initial commit

Author: alomerry

.gitignore

@@ -0,0 +1 @@
+.idea

LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2023 Alomerry Wu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

algorithm/bst.go

@@ -0,0 +1,163 @@
+package algorithm
+
+type Priority interface {
+	Less(i, j interface{}) bool
+	Equal(i, j interface{}) bool
+	Empty() bool
+}
+
+type BSTree[T Priority] struct {
+	data  T
+	Left  *BSTree[T]
+	Right *BSTree[T]
+}
+
+// NewBSTNode Attention: data need implement Priority
+func NewBSTNode[T Priority](data T) *BSTree[T] {
+	return &BSTree[T]{
+		data: data,
+	}
+}
+
+func (p *BSTree[T]) Insert(newNode *BSTree[T]) *BSTree[T] {
+	if newNode == nil {
+		return p
+	}
+	if p == nil {
+		return NewBSTNode(newNode.data)
+	}
+
+	if p.data.Empty() {
+		panic("can't less nil data")
+	}
+
+	if p.data.Less(p.data, newNode.data) {
+		if p.Right == nil {
+			p.Right = newNode
+		} else {
+			p.Right.Insert(newNode)
+		}
+	} else {
+		if p.Left == nil {
+			p.Left = newNode
+		} else {
+			p.Left.Insert(newNode)
+		}
+	}
+	return p
+}
+
+func (p *BSTree[T]) Remove(newNode *BSTree[T]) *BSTree[T] {
+	if p.Left != nil {
+		p.Left = p.Left.Remove(newNode)
+	}
+
+	if p.Right != nil {
+		p.Right = p.Right.Remove(newNode)
+	}
+
+	// ATTENTION golang 无法修改 receiver 本身，需要 return
+	if p.data.Equal(p.data, newNode.data) {
+		if p.Left == nil && p.Right == nil {
+			return nil
+		}
+
+		if p.Left == nil || p.Right == nil {
+			if p.Left != nil {
+				return p.Left
+			} else {
+				return p.Right
+			}
+		}
+
+		if p.Left != nil && p.Right != nil {
+			p.Right.Insert(p.Left)
+			return p.Right
+		}
+	}
+
+	return p
+}
+
+func (p *BSTree[T]) Has(newNode *BSTree[T]) bool {
+	if p == nil {
+		return false
+	}
+
+	if p.data.Empty() {
+		panic("can't less nil data")
+	}
+
+	if p.Left != nil {
+		found := p.Left.Has(newNode)
+		if found {
+			return true
+		}
+	}
+
+	if p.Right != nil {
+		found := p.Right.Has(newNode)
+		if found {
+			return true
+		}
+	}
+
+	if p.data.Equal(p.data, newNode.data) {
+		return true
+	}
+	return false
+}
+
+func (p *BSTree[T]) Minimum() *BSTree[T] {
+	if p.Left == nil {
+		return p
+	} else {
+		return p.Left.Minimum()
+	}
+}
+
+func (p *BSTree[T]) Maximum() *BSTree[T] {
+	if p.Right == nil {
+		return p
+	} else {
+		return p.Right.Maximum()
+	}
+}
+
+func (p *BSTree[T]) Data() T {
+	return p.data
+}
+
+func (p *BSTree[T]) ToArray() []T {
+	result := make([]T, 0)
+	p.PreTravel(&result)
+	return result
+}
+
+func (p *BSTree[T]) PreTravel(list *[]T) {
+	if p == nil {
+		return
+	}
+
+	if p.Left != nil {
+		p.Left.PreTravel(list)
+	}
+
+	*list = append(*list, p.data)
+
+	if p.Right != nil {
+		p.Right.PreTravel(list)
+	}
+}
+
+func (p *BSTree[T]) Merge(b *BSTree[T]) *BSTree[T] {
+	if p == nil {
+		return b
+	} else {
+		list := b.ToArray()
+		for i := range list {
+			p.Insert(NewBSTNode(list[i]))
+		}
+	}
+	return p
+}