Added new methods & improved error handling

Author: Alokzh

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

@@ -48,6 +48,14 @@ CTBinarySearchTreeTest >> testAsArray [
 	self assert: result equals: #(20 30 40 50 70)
 ]
 
+{ #category : 'tests' }
+CTBinarySearchTreeTest >> testAtIfAbsent [
+
+	tree addAll: #(50 30 70).
+	self assert: (tree at: 30 ifAbsent: [ #notFound ]) equals: 30.
+	self assert: (tree at: 99 ifAbsent: [ #notFound ]) equals: #notFound
+]
+
 { #category : 'tests' }
 CTBinarySearchTreeTest >> testBSTValidation [
 
@@ -186,12 +194,13 @@ CTBinarySearchTreeTest >> testEmptyTreeOperations [
 ]
 
 { #category : 'tests' }
-CTBinarySearchTreeTest >> testFindMinMax [
+CTBinarySearchTreeTest >> testFirstLast [
 
 	tree addAll: #(50 30 70 20 80).
-	
-	self assert: tree findMin equals: 20.
-	self assert: tree findMax equals: 80
+	self assert: tree first equals: 20.
+	self assert: tree last equals: 80.
+	self assert: CTBinarySearchTree new first isNil.
+	self assert: CTBinarySearchTree new last isNil
 ]
 
 { #category : 'tests' }
@@ -362,16 +371,20 @@ CTBinarySearchTreeTest >> testRemoveNonExistentElement [
 { #category : 'tests' }
 CTBinarySearchTreeTest >> testRemoveRoot [
 	"Root with no children"
+
 	tree add: 50.
 	tree remove: 50.
 	self assert: tree isEmpty.
-	
+
 	"Root with two children"
 	tree clear.
-	tree addAll: #(50 30 70 20 40 60 80).
+	tree addAll: #( 50 30 70 20 40 60 80 ).
 	tree remove: 50.
 	self assert: tree size equals: 6.
 	self deny: (tree includes: 50).
+	
+	self assert: (tree includes: 60).
+	self assert: tree root contents equals: 60
 ]
 
 { #category : 'tests' }

src/Containers-BinarySearchTree/CTBSTAbstractNode.class.st

@@ -57,12 +57,24 @@ CTBSTAbstractNode >> findMax [
 	^ self subclassResponsibility
 ]
 
+{ #category : 'searching' }
+CTBSTAbstractNode >> findMaxNode [
+
+	^ self subclassResponsibility
+]
+
 { #category : 'searching' }
 CTBSTAbstractNode >> findMin [
 
 	^ self subclassResponsibility
 ]
 
+{ #category : 'searching' }
+CTBSTAbstractNode >> findMinNode [
+
+		^ self subclassResponsibility
+]
+
 { #category : 'accessing' }
 CTBSTAbstractNode >> height [
 

src/Containers-BinarySearchTree/CTBSTNilNode.class.st

@@ -57,12 +57,24 @@ CTBSTNilNode >> findMax [
 	^ nil
 ]
 
+{ #category : 'searching' }
+CTBSTNilNode >> findMaxNode [
+
+	^ self
+]
+
 { #category : 'searching' }
 CTBSTNilNode >> findMin [
 
 	^ nil
 ]
 
+{ #category : 'searching' }
+CTBSTNilNode >> findMinNode [
+
+	^ self
+]
+
 { #category : 'accessing' }
 CTBSTNilNode >> height [
 

src/Containers-BinarySearchTree/CTBSTNode.class.st

@@ -73,18 +73,29 @@ CTBSTNode >> elementsLessThan: anObject into: aCollection [
 
 { #category : 'searching' }
 CTBSTNode >> findMax [
+^ self findMaxNode contents
+]
+
+{ #category : 'searching' }
+CTBSTNode >> findMaxNode [
 
 	^ right isEmpty
-		ifTrue: [ contents ]
-		ifFalse: [ right findMax ]
+		ifTrue: [ self ]
+		ifFalse: [ right findMaxNode ]
 ]
 
 { #category : 'searching' }
 CTBSTNode >> findMin [
 
+	^ self findMinNode contents
+]
+
+{ #category : 'searching' }
+CTBSTNode >> findMinNode [
+
 	^ left isEmpty
-		ifTrue: [ contents ]
-		ifFalse: [ left findMin ]
+		ifTrue: [ self ]
+		ifFalse: [ left findMinNode ]
 ]
 
 { #category : 'accessing' }
@@ -166,38 +177,33 @@ CTBSTNode >> predecessorOf: anObject [
 
 { #category : 'removing' }
 CTBSTNode >> removeThisNode [
-
-	"Remove this node and return replacement using standard BST algorithm"
-		| successorValue |
-	"Case 1: Leaf node (no children)"
-	(left isEmpty and: [ right isEmpty ]) 
-		ifTrue: [ ^ CTBSTNilNode new ].
-	
-	"Case 2: Only one child"
+	"Remove this specific node and return its replacement.
+	The caller is responsible for linking the replacement into the tree."
+	| successor |
+	"Case 1 & 2: Leaf or single child. Return the non-empty child or the nil node."
 	left isEmpty ifTrue: [ ^ right ].
 	right isEmpty ifTrue: [ ^ left ].
-	
-	"Case 3: Two children - replace with inorder successor"
-	successorValue := right findMin.
-	contents := successorValue.
-	right := right removeValue: successorValue.
+
+	"Case 3: Two children. Replace contents with inorder successor's contents,
+	then remove the successor node from the right subtree."
+	successor := right findMinNode.
+	self contents: successor contents.
+	self right: (right removeValue: successor contents).
 	^ self
 ]
 
 { #category : 'removing' }
 CTBSTNode >> removeValue: anObject [
-
-	"Remove node with anObject value and return the new subtree root"
-	
+	"Find the node with anObject and remove it, returning the new root of this subtree."
 	anObject < contents ifTrue: [
-		left := left removeValue: anObject.
+		self left: (left removeValue: anObject).
 		^ self ].
-	
+
 	anObject > contents ifTrue: [
-		right := right removeValue: anObject.
+		self right: (right removeValue: anObject).
 		^ self ].
-	
-	"Found the node to remove"
+
+	"Found the node to remove. `removeThisNode` will return the replacement."
 	^ self removeThisNode
 ]
 

src/Containers-BinarySearchTree/CTBinarySearchTree.class.st

@@ -56,6 +56,14 @@ CTBinarySearchTree >> asArray [
 	^ result asArray
 ]
 
+{ #category : 'accessing' }
+CTBinarySearchTree >> at: anObject ifAbsent: aBlock [
+
+	| result |
+	result := root search: anObject.
+	^ result ifNil: [ aBlock value ] ifNotNil: [ result ]
+]
+
 { #category : 'removing' }
 CTBinarySearchTree >> clear [
 
@@ -124,20 +132,22 @@ CTBinarySearchTree >> elementsLessThan: anObject [
 	^ result
 ]
 
-{ #category : 'searching' }
-CTBinarySearchTree >> findMax [ 
+{ #category : 'accessing' }
+CTBinarySearchTree >> findMax [
 
-	^ self isEmpty 
-		ifTrue: [ nil ]
-		ifFalse: [ root findMax ]
+	^ root findMax
 ]
 
-{ #category : 'searching' }
+{ #category : 'accessing' }
 CTBinarySearchTree >> findMin [
 
-	^ self isEmpty 
-		ifTrue: [ nil ]
-		ifFalse: [ root findMin ]
+	^ root findMin
+]
+
+{ #category : 'accessing' }
+CTBinarySearchTree >> first [
+
+	^ self findMin
 ]
 
 { #category : 'accessing' }
@@ -146,6 +156,22 @@ CTBinarySearchTree >> height [
 	^ root isEmpty ifTrue: [ 0 ] ifFalse: [ root height ]
 ]
 
+{ #category : 'testing' }
+CTBinarySearchTree >> ifEmpty: aBlock [
+
+	^ self isEmpty
+		ifTrue: [ aBlock value ]
+		ifFalse: [ self ]
+]
+
+{ #category : 'testing' }
+CTBinarySearchTree >> ifNotEmpty: aBlock [
+
+	^ self isEmpty
+		ifFalse: [ aBlock value: self ]
+		ifTrue: [ self ]
+]
+
 { #category : 'enumerating' }
 CTBinarySearchTree >> inOrderDo: aBlock [
 
@@ -155,7 +181,7 @@ CTBinarySearchTree >> inOrderDo: aBlock [
 { #category : 'testing' }
 CTBinarySearchTree >> includes: anObject [
 
-	^ (root search: anObject) notNil
+	^ (self at: anObject ifAbsent: [ nil ]) notNil
 ]
 
 { #category : 'initialization' }
@@ -171,6 +197,12 @@ CTBinarySearchTree >> isEmpty [
 	^ root isEmpty
 ]
 
+{ #category : 'accessing' }
+CTBinarySearchTree >> last [
+
+	^ self findMax
+]
+
 { #category : 'enumerating' }
 CTBinarySearchTree >> postOrderDo: aBlock [
 
@@ -198,18 +230,17 @@ CTBinarySearchTree >> remove: anObject [
 	^ self
 		  remove: anObject
 		  ifAbsent: [
-		  self error: 'Element not found: ' , anObject printString ]
+		  NotFound signalFor: anObject in: self ]
 ]
 
 { #category : 'removing' }
 CTBinarySearchTree >> remove: anObject ifAbsent: aBlock [
 
-	| originalSize |
-	originalSize := self size.
+	(self includes: anObject) ifFalse: [ ^ aBlock value ].
+
 	root := root removeValue: anObject.
-	^ originalSize = self size 
-		ifTrue: [ aBlock value ]
-		ifFalse: [ anObject ]
+	root parent: nil. "The new root has no parent"
+	^ anObject
 ]
 
 { #category : 'removing' }