Okay next we're gonna look at another

extension of geometric algorithms to

process slightly more complicated objects
and then we'll see an important
application. This is called interval
search. So now instead of points, our data
is intervals. So this is, we'll start with
one dimension as before and right away you
can see that it's a more complicated
problem than we've been dealing with. So
we want to support the following
operations. We wanna be able to insert an
interval. So an interval is just a left
endpoint, right endpoint of a
1-dimensional data or points on the line.
We wanna be able to Insert an interval
search for an interval, delete an interval
but the main thing is we want the interval
intersection query. So given a query
interval, we want to find all intervals in
the data structure that overlap that
interval or find any interval we'll start
with that simpler problem. So how are we
going to support that? So this is the API
in Java code [cough], so We, have,
intervals, so instead of one key we have
two, which is left and right end points of
the interval for input. And [inaudible],
and then we have delete, and then we have
intersects. And again simplify the code,
we are going to make the non degeneracy
assumption that no two intervals have the
same left end point. [cough] and, [cough].
Easy, easy to fix but, but we don't
simplify the code. So now we'll look at a
data structure called an interval search
tree that helps to solve this problem.
And, it's a extremely, simple algorithim,
but surprisingly, complicated to
understand, so we'll go slowly. So the
first thing is what we're going to do is
use the left end point of each interval as
the binary search tree key. So our, eh,
our node stored intervals, but we only use
our left end point as the key. So this is
the binary search tree that's built from
those five intervals, six intervals in our
example. Seventeen, nineteen is at the
root, so everybody with a le ft end point
less than seventeen is to the left, the
left end point greater than seventeen is
to the right and so forth. So that's a
binary search tree built, from those
intervals. So that's easy. I just build a
binary search tree. I just use, the left
end point, as the search key. But we're
also in the, each node of the tree, we're
gonna store, not just the interval. But
we're gonna store the, largest endpoint in
the subtree rooted at that node. So at
every node, we're gonna store the maximum
endpoint and subtree rooted at that node.
So at the root, the maximum endpoint or
the rightmost point covered by an
interval, is 24. So we [inaudible] 24 at
the root, and, of course, the right
subtree. And the left subtree. The max end
point is that eighteen so that's what we
store for the associated data with the
note to the left of the root and so forth.
So. We going to have to, that's data that
we're going to have to maintain when we do
an insert and it's data that we'll use
when we're doing an interval-intersection
search. So let's take a look at an
insertion into an interval search tree
with a demo. All right, so, the, insertion
algorithm is pretty simple. We do the BST
insertion, just so we have to do that,
update of the maximum in each node on the
search path. So, to insert 16/22 in this
tree, while we use the, left endpoint as
the search key, sixteen is the left
endpoint of our insert interval [cough].
We compare that with seventeen and
therefore go left. How sixteen is bigger
than five so we go right. Now sixteen is
bigger than fifteen so we go right. And
that's null, so that's where we insert our
new, interval. [sound]. So now, we're
gonna go back up the tree. And, for every
node that we encounter, it could be that,
our right endpoint of our interval, is
bigger than what was there. So we have to
check, all the way up the path, the
maximum in each node on the path. So we
have to check each node, to see if 22 is
bigger, and, for the three nodes to the
left it is bigger than eighteen. For the
node at the root, it's not. That stays to
be 24. So, it's just binary tree
insertion, but then after the insertion on
the way up, we go ahead and, check, if the
maximum that we have is bigger than the
maximum there and update it if necessary.
So easy to code. [sound]. Alright, so now
about, how do we do a, a search. So the
searches is definitely more complicated
and kind of mysterious, but let's look at
the rules for search in an interval search
tree. Alright so now we're gonna look to
see if we have an intersection what a. We
want to find just. Any interval that
intersects this query interval 23 25.
We're not gonna try to find them all we'll
get back to that in a minute. Try to find
any interval that intersects our query
interval. So let's, let's see what we have
to do. So first thing is if At the root,
we have an intersection, then we're done.
We just return. In this case, 2325 does
not intersect, 1719. So, we have to go
down the tree somewhere. So left subtree
is [inaudible] right, okay? Otherwise, we
have to check whether the max endpoint in
the left subtree is less than, the low
point in our interval. [inaudible] it's
easy to see, well, if that's the case,
then we're not gonna find an intersection.
In the left. The maximum end-point in the
left is 22, and we're looking for 23, and
we're not gonna find anything there, so we
just wanna go right. So in this case we'll
go right 22, 23 no inter sectional left,
so we go right and now we do find an
intersection 21, 24 does intersect with
23, 25 because 23 is in the middle there,
so we find an intersection. Now on the
other hand, let's say they were looking
for 1214, so no intersection. So. All the
algorithm says is that, if you didn't go
right, go left. So let's go left, in this
case. So we weren't able to show that
there was no intersection, on the left.
So, so we're gonna go left. In this we
compare twelve fourteen to five eight, so
now we apply the same rules. Does it
intersect? No, it doesn't intersect. So
should we go left. Well no, the maximum,
end point in the left node is eight. So we
can have intersection there, so we gonna
go right, [inaudible] to twelve and go
right. So, now does twelve, fourteen
intersect fifteen, eighteen it does not so
there's no intersection so now what do we
do. Should we go left no the max in point
on left is ten so we shouldn't go left. So
we're going to go right. Those 12-14
intersect 16-22. It does not, So, now, the
left end point's null. And so we're just
gonna go right. And there's no
intersection. So in both cases we just
went along one path in the tree to
determine whether or not there was an
interval or intersection. Let's look at
one more example. 21, 23. So let's see. 21
thru 23 to seventeen, nineteen. They do
not intersect, so now, what are we gonna
do next? Well we're gonna compare the left
sub-tree, and it's Not, 22 falls within
our interval so it's not less than'r' so
there might be an intersection there so we
better go to the left, so we do go to the
left. Now we compare against 5-8, and
there's no intersection. So now, we're
gonna go left to right. Well, we're gonna
go to the right, because, the max endpoint
in the left subtree is eight, and our
interval's 21, so no intersection on the
left. So we're gonna go right.
Intersection 21231518. They do not
intersect. So now, do we go left or right?
Again ten is less than our left endpoint
21. So we better go to the right. [cough].
And now 2123 does intersect 1622, so we
return and intersection. Again one path
through the tree to determine an
intersection. So from these rules you can
see that the man of code required to
implement this intersecting inter role is
extremely low. Just check for an
intersection, if we find it ret urn if
left is no we go right. Otherwise if the
max is less than low we go right.
Otherwise we go left. Could hardly be
simpler. Really amazingly simple and
efficient algorithm. We should convince
ourselves really that it always works and
so we'll spend just a moment on a short
proof. So let's look at the, the cases
that could happen. So first thing is if
the search goes right. Then there's no
intersection on the left. And that's easy
to convince ourselves of that just from,
from what we did in the demo. Of course,
if the last sub-tree's empty, there's no
intersection there. But if the max
endpoint in the left sub-tree is less than
low, that means every interval in the left
sub-tree has a max endpoint less than mah,
low, and so therefore it can't intersect.
So if you go right, there's no
intersection in the left. Any possible
intersection would have to be in the
right, And then the other point is that if
you go left, then either there's an
intersection there, or there's no
intersections at all. So Lets suppose that
there is no intersect, and that's
equivalent to saying, if there is no
intersection in the left then there is no
intersection in the right. So lets look at
it if there is no intersection in the
left, since we went to the left and then
we have got, low less than max. But, for
any interval, in the right subtree, its
got to appear after. Low. Be, because
since there's no intersections in the left
sub tree high has gotta be less than C.
Where, because they're sorted by left N
point. And then that means that C-s got to
be less than A if it is in the right, so
therefore there can't be any interesection
in the right either. No intersection in
the left means no intersections at all, so
those two cases is enough to show that
this algebroid finds an intersection, if
there is one. And the other thing we can
do with this is just use a red-black BST
to guarantee that we solved this in time
proportional to log in. So insert, find,
delete, and find any interval that
intersects. All take time, guaranteed,
proportional to log in. And if we wanna
find all intervals we just have to run the
algorithm fur Each interval that's, until
we come up against no intersection, so
it'll take time proportional to R log N if
there's R intervals that intersect. The
theoretical best that you could possibly
do would be R plus log N but in practice R
log N is quite efficient. This is an easy
and very efficient algorithm to solve this
interval search problem and as we'll see
this algorithm. It's applicable to an
important application that we'll see in a