389 lines
7.6 KiB
Go
389 lines
7.6 KiB
Go
package stringset
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"strings"
|
|
)
|
|
|
|
const testVersion = 3
|
|
|
|
// Set is a slice of strings that you can do set operations on.
|
|
// I decided that I wanted to implement a binary tree for the storage
|
|
type Set struct {
|
|
top SetValue
|
|
}
|
|
|
|
type SetValue struct {
|
|
value string
|
|
left *SetValue
|
|
right *SetValue
|
|
}
|
|
|
|
// New returns an empty Set
|
|
func New() Set {
|
|
s := new(Set)
|
|
s.top = SetValue{}
|
|
return *s
|
|
}
|
|
|
|
// NewFromSlice takes a slice of strings and returns a Set
|
|
func NewFromSlice(s []string) Set {
|
|
ret := New()
|
|
for i := range s {
|
|
ret.Add(s[i])
|
|
}
|
|
ret.balance()
|
|
return ret
|
|
}
|
|
|
|
// Add adds a value to the set
|
|
func (s Set) Add(v string) {
|
|
if s.top.value == "" {
|
|
s.top.value = v
|
|
return
|
|
}
|
|
s.top.Add(v)
|
|
}
|
|
|
|
func (s *Set) PrettyPrint() {
|
|
s.pp(&s.top, 0)
|
|
}
|
|
|
|
func (s *Set) pp(n *SetValue, indent int) {
|
|
if n != nil {
|
|
if n.left != nil {
|
|
s.pp(n.left, indent+4)
|
|
}
|
|
if n.right != nil {
|
|
s.pp(n.right, indent+4)
|
|
}
|
|
for ; indent > 0; indent-- {
|
|
fmt.Print(" ")
|
|
}
|
|
fmt.Println(n.value)
|
|
}
|
|
}
|
|
|
|
// balance balances the binary tree
|
|
func (s *Set) balance() {
|
|
|
|
}
|
|
|
|
func (s *Set) find(v string) *SetValue {
|
|
if s.top.value != "" {
|
|
sv, _ := s.top.find(v)
|
|
return sv
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// findWithParent finds a node with a child value v
|
|
// a return of nil, nil means it's the top node
|
|
func (s *Set) findParent(v string) (*SetValue, error) {
|
|
if s.top.value == v {
|
|
// no parent, it's the top.
|
|
return nil, nil
|
|
} else {
|
|
return s.top.findParent(v)
|
|
}
|
|
return nil, errors.New("Empty Set")
|
|
}
|
|
|
|
func (s *Set) findHome(v *SetValue) {
|
|
if s.top.value == "" {
|
|
s.top.value = v.value
|
|
s.top.left = v.left
|
|
s.top.right = v.right
|
|
return
|
|
}
|
|
s.top.findHome(v)
|
|
}
|
|
|
|
// Delete removes the given value from the set
|
|
func (s Set) Delete(v string) {
|
|
if sv, err := s.findParent(v); err == nil {
|
|
var cmp int
|
|
var delNode, repNode, orphan *SetValue
|
|
if sv == nil {
|
|
// Deleting 'top'
|
|
delNode = &s.top
|
|
if delNode.left != nil {
|
|
repNode = delNode.left
|
|
orphan = delNode.right
|
|
} else if delNode.right != nil {
|
|
repNode = delNode.right
|
|
}
|
|
if repNode == nil {
|
|
// No node to replace it with, we're done
|
|
return
|
|
}
|
|
s.top = *repNode
|
|
} else {
|
|
cmp = strings.Compare(v, sv.value)
|
|
if cmp < 0 && sv.left != nil {
|
|
fmt.Println(" Left: " + sv.left.value)
|
|
// It's the left node
|
|
delNode = sv.left
|
|
} else if cmp > 0 && sv.right != nil {
|
|
fmt.Println(" Right: " + sv.right.value)
|
|
// It's the right node
|
|
delNode = sv.right
|
|
}
|
|
if delNode == nil {
|
|
return
|
|
}
|
|
|
|
if delNode.left != nil {
|
|
repNode = delNode.left
|
|
orphan = delNode.right
|
|
} else if delNode.right != nil {
|
|
repNode = delNode.right
|
|
}
|
|
if repNode == nil {
|
|
// No replacement node, we're done
|
|
return
|
|
}
|
|
if cmp < 0 {
|
|
sv.left = repNode
|
|
} else if cmp > 0 {
|
|
sv.right = repNode
|
|
}
|
|
}
|
|
// If we have an orphaned branch, find it a home
|
|
if orphan != nil {
|
|
s.findHome(orphan)
|
|
}
|
|
}
|
|
}
|
|
|
|
// Has returns if the set contains the given value.
|
|
func (s *Set) Has(v string) bool {
|
|
return s.find(v) != nil
|
|
}
|
|
|
|
// IsEmpty returns whether the set is empty or not.
|
|
func (s *Set) IsEmpty() bool {
|
|
return s.top.value == ""
|
|
}
|
|
|
|
// Len returns the number of values in the set
|
|
func (s *Set) Len() int {
|
|
if !s.IsEmpty() {
|
|
return s.top.Len()
|
|
}
|
|
return 0
|
|
}
|
|
|
|
// Slice returns a string slice of the set
|
|
func (s Set) Slice() []string {
|
|
if !s.IsEmpty() {
|
|
return s.top.Slice()
|
|
}
|
|
return []string{}
|
|
}
|
|
|
|
// String converts the set to a string
|
|
func (s Set) String() string {
|
|
ret := "{"
|
|
if s.top.value != "" {
|
|
ret += s.top.String()
|
|
}
|
|
ret += "}"
|
|
return ret
|
|
}
|
|
|
|
// find looks for a node with value val, it either returns the node
|
|
// or an error stating it couldn't find it.
|
|
func (sv *SetValue) find(val string) (*SetValue, error) {
|
|
if sv.value == val {
|
|
return sv, nil
|
|
}
|
|
cmp := strings.Compare(val, sv.value)
|
|
if cmp < 0 && sv.left != nil {
|
|
return sv.left.find(val)
|
|
}
|
|
if cmp > 0 && sv.right != nil {
|
|
return sv.right.find(val)
|
|
}
|
|
return nil, errors.New("Value not found")
|
|
}
|
|
|
|
// findParent looks for the parent of the node with value val
|
|
// If nil, nil is returned, it _is_ this node.
|
|
func (sv *SetValue) findParent(val string) (*SetValue, error) {
|
|
if sv.value == val {
|
|
// This should only trigger if this is the top node of the tree
|
|
return nil, nil
|
|
}
|
|
cmp := strings.Compare(val, sv.value)
|
|
if cmp < 0 && sv.left != nil {
|
|
if sv.left.value == val {
|
|
return sv, nil
|
|
}
|
|
return sv.left.findParent(val)
|
|
}
|
|
if cmp > 0 && sv.right != nil {
|
|
if sv.right.value == val {
|
|
return sv, nil
|
|
}
|
|
return sv.right.findParent(val)
|
|
}
|
|
return nil, errors.New("Value not found")
|
|
}
|
|
|
|
func (sv *SetValue) findHome(v *SetValue) {
|
|
cmp := strings.Compare(v.value, sv.value)
|
|
if cmp < 0 {
|
|
if sv.left == nil {
|
|
sv.left = v
|
|
} else {
|
|
sv.left.findHome(v)
|
|
}
|
|
} else if cmp > 0 {
|
|
if sv.right == nil {
|
|
sv.right = v
|
|
} else {
|
|
sv.right.findHome(v)
|
|
}
|
|
} else {
|
|
// Discard the top node, find homes for it's children
|
|
if v.left != nil {
|
|
sv.findHome(v.left)
|
|
}
|
|
if v.right != nil {
|
|
sv.findHome(v.right)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (sv *SetValue) Add(v string) {
|
|
cmp := strings.Compare(v, sv.value)
|
|
if cmp < 0 {
|
|
if sv.left == nil {
|
|
sv.left = &SetValue{value: v}
|
|
} else {
|
|
sv.left.Add(v)
|
|
}
|
|
} else if cmp > 0 {
|
|
if sv.right == nil {
|
|
sv.right = &SetValue{value: v}
|
|
} else {
|
|
sv.right.Add(v)
|
|
}
|
|
}
|
|
}
|
|
|
|
// Len returns how many elements are in the branches
|
|
func (sv *SetValue) Len() int {
|
|
ret := 1
|
|
if sv.left != nil {
|
|
ret += sv.left.Len()
|
|
}
|
|
if sv.right != nil {
|
|
ret += sv.right.Len()
|
|
}
|
|
return ret
|
|
}
|
|
|
|
// Has checks if this branch contains the value v
|
|
func (sv *SetValue) Has(v string) bool {
|
|
ret, _ := sv.find(v)
|
|
return ret != nil
|
|
}
|
|
|
|
// String gets a string value of this branch
|
|
func (sv *SetValue) String() string {
|
|
var ret string
|
|
if sv.left != nil {
|
|
ret += sv.left.String() + ", "
|
|
}
|
|
ret += "\"" + sv.value + "\""
|
|
if sv.right != nil {
|
|
ret += ", " + sv.right.String()
|
|
}
|
|
return ret
|
|
}
|
|
|
|
// Slice returns a string slice of all values in the branch
|
|
func (sv *SetValue) Slice() []string {
|
|
var ret []string
|
|
if sv.left != nil {
|
|
ret = sv.left.Slice()
|
|
}
|
|
ret = append(ret, sv.value)
|
|
if sv.right != nil {
|
|
ret = append(ret, sv.right.Slice()...)
|
|
}
|
|
return ret
|
|
}
|
|
|
|
// Equal returns whether the given sets are the same.
|
|
func Equal(s1, s2 Set) bool {
|
|
return s1.String() == s2.String()
|
|
}
|
|
|
|
// Subset returns whether s1 is a subset of s2.
|
|
func Subset(s1, s2 Set) bool {
|
|
if s1.Len() == 0 || s2.Len() == 0 {
|
|
return false
|
|
}
|
|
s1Sl := s1.Slice()
|
|
for i := range s1Sl {
|
|
if !s2.Has(s1Sl[i]) {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
// Disjoint returns whether two sets _do not_ intersect
|
|
func Disjoint(s1, s2 Set) bool {
|
|
s1Sl := s1.Slice()
|
|
for i := range s1Sl {
|
|
if s2.Has(s1Sl[i]) {
|
|
return false
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
// Intersection finds elements that exist in both sets and makes a new
|
|
// set of them
|
|
func Intersection(s1, s2 Set) Set {
|
|
var vals []string
|
|
s1Sl := s1.Slice()
|
|
for i := range s1Sl {
|
|
if s2.Has(s1Sl[i]) {
|
|
vals = append(vals, s1Sl[i])
|
|
}
|
|
}
|
|
return NewFromSlice(vals)
|
|
}
|
|
|
|
// Union gets all elements in both sets and makes a new set with them.
|
|
func Union(s1, s2 Set) Set {
|
|
var vals []string
|
|
vals = append(vals, s1.Slice()...)
|
|
vals = append(vals, s2.Slice()...)
|
|
return NewFromSlice(vals)
|
|
}
|
|
|
|
// Difference returns a Set of all elements in s1 that aren't in s2
|
|
func Difference(s1, s2 Set) Set {
|
|
var vals []string
|
|
s1Sl := s1.Slice()
|
|
for i := range s1Sl {
|
|
if !s2.Has(s1Sl[i]) {
|
|
vals = append(vals, s1Sl[i])
|
|
}
|
|
}
|
|
return NewFromSlice(vals)
|
|
}
|
|
|
|
// SymmetricDifference returns all elements from s1 & s2 that occur in only one of the
|
|
// sets.
|
|
func SymmetricDifference(s1, s2 Set) Set {
|
|
return Union(Difference(s1, s2), Difference(s2, s1))
|
|
}
|