Binary search for an ArrayBuffer - algorithm

Question

So, I have an ArrayBuffer[Signal], in which each Signal has a timestamp (the array is sorted by this timestamp). I want to binary search and return a Seq[Signal] of signals that are inside a certain range. Now it is done with linear search, basically because I come from Java and I'm a newbie in Scala. Which is the best way to do it?
Here's the code:
private def getSignalsFromCache(mapId: String, mac: String, startTime: Long, endTime: Long): Seq[Signal] = {
val signals = getCache(VehicleWithMap(mapId, mac))
val result: ArrayBuffer[Signal] = new ArrayBuffer[Signal]()
if (signals.isEmpty) {
return signals
}
var startIndex: Int = 0
if (startTime > signals.head.timestamp) {
while (startIndex < signals.size && signals(startIndex).timestamp < startTime) {
startIndex += 1
}
}
var finished: Boolean = false
var currentIndex = startIndex
while (!finished && currentIndex < signals.size) {
val timestamp = signals(currentIndex).timestamp
if (timestamp > endTime) {
finished = true
}
else {
result += signals(currentIndex)
}
currentIndex += 1
}
result
}

Answer 1

You can use dropWhile & takeWhile.
That way, you can save all the mutability and iterations.
Note: This is still linear, but it is more functional and more common in Scala.
private def getSignalsFromCache(mapId: String, mac: String, startTime: Long, endTime: Long): Seq[Signal] =
getCache(VehicleWithMap(mapId, mac)
.dropWhile(_.timestamp < startTime)
.takeWhile(_.timestamp <= endTime)
}
(make sure of test it first, you may need to play a bit with the conditions).

Answer 2

You can use Searching to do a binary search.
import scala.collection.Searching._
val signalWithLowerBoundTimestamp = ???
val signalWithUpperBoundTimestamp = ???
val lower = signals.search(signalWithLowerBoundTimestamp)(
Ordering.by(_.timestamp)).insertionPoint
// If the upper bound is an exact match, add one
// to make sure it's included in the slice.
val upper = signals.search(signalWithUpperBoundTimestamp)(
Ordering.by(_.timestamp)) match {
case Found(i) => i + 1
case InsertionPoint(i) => i
}
val result = signals.slice(lower, upper)

Answer 3

I don't know scala, but here's a binary search that you can compare more functional-styled answers with. I don't think there's any shame in it. Note that there's no advantage to doing a binary search for the end index, since you have to copy the elements anyway:
private def getSignalsFromCache(mapId: String, mac: String, startTime: Long, endTime: Long): Seq[Signal] = {
val signals = getCache(VehicleWithMap(mapId, mac))
var startIndex: Int = 0
var endIndex: Int = signals.size
while(startIndex<endIndex) {
var testIndex: int = startIndex + (endIndex-startIndex)/2
if (signals(testIndex).timestamp < startTime) {
startIndex = testIndex + 1
} else {
endIndex = testIndex
}
}
while(endIndex < signals.size && signals(endIndex).timestamp <= endTime) {
endIndex = endIndex + 1
}
signals.slice(startIndex, endIndex)
}
Note that I included signals at the end with timestamp == endTime, because that's what you did... that makes the interface a little weird, though. Normally a method like this would be written to return signals with startTime <= timeStamp < endTime, so maybe you want to think about changing that.