Basic Binary Search Tree Implementation with Tests

src/Containers-BinarySearchTree-Tests/CTBinarySearchTreeTest.class.st

@@ -4,6 +4,93 @@ A CTBinarySearchTreeTest is a test class for testing the behavior of CTBinarySea
 Class {
 	#name : 'CTBinarySearchTreeTest',
 	#superclass : 'TestCase',
+	#instVars : [
+		'tree'
+	],
 	#category : 'Containers-BinarySearchTree-Tests',
 	#package : 'Containers-BinarySearchTree-Tests'
 }
+
+{ #category : 'running' }
+CTBinarySearchTreeTest >> setUp [
+	super setUp.
+	tree := CTBinarySearchTree new
+]
+
+{ #category : 'tests' }
+CTBinarySearchTreeTest >> testAddMultipleElements [
+
+	tree add: 50.
+	tree add: 30.
+	tree add: 70.
+	self assert: tree size equals: 3
+]
+
+{ #category : 'tests' }
+CTBinarySearchTreeTest >> testAddSingleElement [
+
+	tree add: 42.
+	self deny: tree isEmpty.
+	self assert: tree size equals: 1
+]
+
+{ #category : 'tests' }
+CTBinarySearchTreeTest >> testEmpty [
+
+	self assert: tree isEmpty.
+	self assert: tree size equals: 0
+]
+
+{ #category : 'tests' }
+CTBinarySearchTreeTest >> testHeight [
+
+	self assert: tree height equals: 0.
+
+	tree add: 50.
+	self assert: tree height equals: 1.
+
+	tree add: 30.
+	self assert: tree height equals: 2.
+
+	tree add: 70.
+	self assert: tree height equals: 2
+]
+
+{ #category : 'tests' }
+CTBinarySearchTreeTest >> testInOrderTraversal [
+
+	| result |
+	tree add: 50.
+	tree add: 30.
+	tree add: 70.
+	tree add: 20.
+	tree add: 40.
+
+	result := OrderedCollection new.
+	tree inOrderDo: [ :each | result add: each ].
+	self assert: result asArray equals: #( 20 30 40 50 70 )
+]
+
+{ #category : 'tests' }
+CTBinarySearchTreeTest >> testIncludes [
+
+	tree add: 50.
+	tree add: 30.
+	tree add: 70.
+
+	self assert: (tree includes: 50).
+	self assert: (tree includes: 30).
+	self assert: (tree includes: 70).
+	self deny: (tree includes: 99)
+]
+
+{ #category : 'tests' }
+CTBinarySearchTreeTest >> testIsLeaf [
+
+	tree add: 50.
+	self assert: tree root isLeaf.
+
+	tree add: 30.
+	self deny: tree root isLeaf.
+	self assert: tree root left isLeaf
+]

src/Containers-BinarySearchTree/CTBSTAbstractNode.class.st

@@ -1,9 +1,78 @@
 "
-I represent Abstract Node for BST
+I represent an abstract node for Binary Search Tree.
 "
 Class {
 	#name : 'CTBSTAbstractNode',
 	#superclass : 'Object',
+	#instVars : [
+		'parent'
+	],
 	#category : 'Containers-BinarySearchTree',
 	#package : 'Containers-BinarySearchTree'
 }
+
+{ #category : 'adding' }
+CTBSTAbstractNode >> addChild: anObject [
+
+	^ self subclassResponsibility
+]
+
+{ #category : 'accessing' }
+CTBSTAbstractNode >> contents [
+
+	^ self subclassResponsibility
+]
+
+{ #category : 'accessing' }
+CTBSTAbstractNode >> contents: anObject [
+
+	self subclassResponsibility
+]
+
+{ #category : 'accessing' }
+CTBSTAbstractNode >> height [
+
+	^ self subclassResponsibility
+]
+
+{ #category : 'enumerating' }
+CTBSTAbstractNode >> inOrderDo: aBlock [
+
+	^ self subclassResponsibility
+]
+
+{ #category : 'testing' }
+CTBSTAbstractNode >> isEmpty [
+
+	^ self subclassResponsibility
+]
+
+{ #category : 'testing' }
+CTBSTAbstractNode >> isLeaf [
+
+	^ self subclassResponsibility
+]
+
+{ #category : 'accessing' }
+CTBSTAbstractNode >> parent [
+
+	^ parent
+]
+
+{ #category : 'accessing' }
+CTBSTAbstractNode >> parent: aNode [
+
+	parent := aNode
+]
+
+{ #category : 'accessing' }
+CTBSTAbstractNode >> search: anObject [
+
+	^ self subclassResponsibility
+]
+
+{ #category : 'accessing' }
+CTBSTAbstractNode >> size [
+
+	^ self subclassResponsibility
+]

src/Containers-BinarySearchTree/CTBSTNillNode.class.st

@@ -1,9 +1,66 @@
 "
-I represent Nill Node for BST
+I represent a nil node for Binary Search Tree.
 "
 Class {
 	#name : 'CTBSTNillNode',
 	#superclass : 'CTBSTAbstractNode',
 	#category : 'Containers-BinarySearchTree',
 	#package : 'Containers-BinarySearchTree'
 }
+
+{ #category : 'adding' }
+CTBSTNillNode >> addChild: anObject [
+
+	^ CTBSTNode new
+		contents: anObject;
+		parent: self parent;
+		yourself
+]
+
+{ #category : 'accessing' }
+CTBSTNillNode >> contents [
+
+	^ nil
+]
+
+{ #category : 'accessing' }
+CTBSTNillNode >> contents: anObject [
+
+	"Do nothing for nil node"
+]
+
+{ #category : 'accessing' }
+CTBSTNillNode >> height [
+
+	^ 0
+]
+
+{ #category : 'enumerating' }
+CTBSTNillNode >> inOrderDo: aBlock [
+
+	"Do nothing for nil node"
+]
+
+{ #category : 'testing' }
+CTBSTNillNode >> isEmpty [
+
+	^ true
+]
+
+{ #category : 'testing' }
+CTBSTNillNode >> isLeaf [
+
+	^ false
+]
+
+{ #category : 'accessing' }
+CTBSTNillNode >> search: anObject [
+
+	^ nil
+]
+
+{ #category : 'accessing' }
+CTBSTNillNode >> size [
+
+	^ 0
+]

src/Containers-BinarySearchTree/CTBSTNode.class.st

@@ -1,9 +1,111 @@
 "
-I represent Node for BST
+I represent a node for Binary Search Tree.
 "
 Class {
 	#name : 'CTBSTNode',
 	#superclass : 'CTBSTAbstractNode',
+	#instVars : [
+		'contents',
+		'left',
+		'right'
+	],
 	#category : 'Containers-BinarySearchTree',
 	#package : 'Containers-BinarySearchTree'
 }
+
+{ #category : 'adding' }
+CTBSTNode >> addChild: anObject [
+
+	anObject < contents
+		ifTrue: [ left := left addChild: anObject ]
+		ifFalse: [ anObject > contents
+			ifTrue: [ right := right addChild: anObject ] ].
+	^ self
+]
+
+{ #category : 'accessing' }
+CTBSTNode >> contents [
+
+	^ contents
+]
+
+{ #category : 'accessing' }
+CTBSTNode >> contents: anObject [
+
+	contents := anObject
+]
+
+{ #category : 'accessing' }
+CTBSTNode >> height [
+
+	^ 1 + (left height max: right height)
+]
+
+{ #category : 'enumerating' }
+CTBSTNode >> inOrderDo: aBlock [
+
+	left inOrderDo: aBlock.
+	aBlock value: contents.
+	right inOrderDo: aBlock
+]
+
+{ #category : 'initialization' }
+CTBSTNode >> initialize [
+
+	super initialize.
+	left := CTBSTNillNode new parent: self.
+	right := CTBSTNillNode new parent: self
+]
+
+{ #category : 'testing' }
+CTBSTNode >> isEmpty [
+
+	^ false
+]
+
+{ #category : 'testing' }
+CTBSTNode >> isLeaf [
+
+	^ left isEmpty and: [ right isEmpty ]
+]
+
+{ #category : 'accessing' }
+CTBSTNode >> left [
+
+	^ left
+]
+
+{ #category : 'accessing' }
+CTBSTNode >> left: aNode [
+
+	left := aNode.
+	aNode parent: self
+]
+
+{ #category : 'accessing' }
+CTBSTNode >> right [
+
+	^ right 
+]
+
+{ #category : 'accessing' }
+CTBSTNode >> right: aNode [
+
+	right := aNode.
+	aNode parent: self
+]
+
+{ #category : 'accessing' }
+CTBSTNode >> search: anObject [
+
+	contents = anObject ifTrue: [ ^ contents ].
+	^ anObject < contents
+		ifTrue: [ left search: anObject ]
+		ifFalse: [ right search: anObject ]
+]
+
+{ #category : 'accessing' }
+CTBSTNode >> size [
+
+	^ 1 + left size + right size
+]