>> OK. Let's talk a little bit about
project that is based on BST iterators.
Now despite that, we're going to
do the, we're going [inaudible]
with only two-way phrase [inaudible].
So the matter [inaudible] based
iterators we're not going to deal with,
but you're going to get a chance to
explore using ADT [inaudible] iterators
as well as the threaded [inaudible].
So this document is basically
ready for use.
I may have had some details and
clarifications and so on, but I'm,
the basic task will not change.
You're going to have, your
final [inaudible] objectives are
to develop some class templates.
One is going to be in order BT
iterator, BT is for [inaudible].
[Inaudible] BT iterator
and thread BT iterator.
And this is going to be class ten
points, and you got to use those
to implement BST threaded, which,
obviously, means binary circuitry
with threaded iterators, BSTADT, which
is [inaudible] with ADT iterators,
and red black left lean
[inaudible] with ADT iterators.
And this would be a big
project, as I say in here.
If you were having to start [inaudible],
there's a lot of technical engineering
details that you have to get done
and do carefully and correctly,
or things blow up on you.
You're hearing the voice
of experience on that.
So it's not, you could do all that.
We all could do that, but it would
take a month or so, and we don't have
that much time to devote to the project,
and so what I'm doing is giving you
partials on all of these things,
and your task then becomes understand
what is dire and also, of course,
understand what you add
to make everything work,
and while just understanding
the big picture
of how these pieces fit together
is an important part of the task,
and you need to be able to do that.
So there's two sets, two collection of
classes that you've got to deal with.
Virtually iterator classes,
and they're all
in this thing called BT2 [inaudible] H.
The 2 is for two-way nodes as opposed
to three-way nodes, and you've got an
in order BT iterator ten point
threaded and [inaudible].
These type just an abstract
class C as a template parameter,
and basically you program 2C to as if
it had a node with the functionalities
that we have decided we want,
and then when you plug in any
of your [inaudible] classes
in for that, they would work.
So that's a way of defining those
three kinds of iterators in a way
that will make them be able to be
retargeted without rewriting the code
to any [inaudible] classes.
Then we're going to have some
binary [inaudible] classes,
and it's going to be a BSC base,
and that is going to be kind
of an iterator free version
of buyer research tree.
It's going to contain a lot of
functionalities that can be inherited
without change such as the size,
the number of nodes, and the tree.
Being able to find, and we'll go
over a lot of those in a few minutes.
So that's a base class, and it
serves mainly the purpose of a place
that we can store code, and we'll reuse
it by inheritance instead of having
to rewrite a copy of
it into another file.
So BSCASDT is clearly
[inaudible] iterators.
So it's going to inherit
from the BST base class.
The AST thread will also
inherit from a BST base class.
And RVLLT underscore ADT, that
class will inherit from BSTADT.
So your inheritance diagram
here will look like this.
You have base.
You have thread.
You have ADT, and [inaudible]
of ADT we have the RVLLT.
I didn't write all these classes
out, but that's the idea of the base.
BST base stores a lot of the
boilerplate BSTADT and DST thread.
Each inherit this, but to find
iterators in two ways, and, finally,
RVLLT underscore ADT inherits from
BST underscore ADT, and, of course,
there's work to do here in redefining
the insert because you've got to insert
and maintain all the color
structure for red [inaudible],
and you've already had
some experience integrating
that with your order
associative array project.
So this is going to be, to some
extent, plowing over [inaudible],
but also a way of getting a grip on some
of these various concepts
and how they can be used.
So you're also being given an iterate,
a star on the iterator [inaudible],
the BSTADT file, BST thread
plow, the RVLADT file.
So those are start offs, and
really they contain a fair portion
of the code already written.
Obviously, I'm leading
[phonetic] out critical things.
I don't want you to have
to experience [inaudible].
And then you've got your test harness
FBST, which can be [inaudible]
to three different element types
- ent, string, and capital CHAR -
and also three different tree types -
BST, [inaudible] BST, ADT, and RBLTADT.
So that with just commenting
and uncommenting as is my habit.
That one child expands into
nine different test harnesses.
And I just realized that
there's also an MBST.
I didn't write that down,
but I need to do that.
[Inaudible] it's there for you to get.
MBST is, of course, the memory retester
just like we had for [inaudible]
and way back the list, and you basically
run that with a contained amount
of memory, and if it runs
forever, then you're not leaking,
but it also does various technical
tests on the iterators and [inaudible].
So, you know, it test iterators for
if you go forward and then backward,
you get, you come back
where you started.
You know, little rests, [inaudible]
tests like that on the iterators.
So if your iterators are going
astray, that'll detect it.
And also there's all [inaudible] of the
FBST's are compiled for you [inaudible].
And while all six of those are here,
and three more are compiled [inaudible]
RBLT's, MBST's, and [inaudible] MB,
and R, and RVLLT's are, these
are all compiled in that area
of 51 for you to be able to say.
So what you got to do is create the
[inaudible] versions of the start,
the four start files by just, you copy
the star to about 8's and then you begin
to edit without 8's until it's done.
So the way that works, it's like you'd
expect, and so let's just take a look.
[ Background Sounds ]
Now, you know, iterators are
not spectacular to demonstrate.
All they do is provide a different
way to traverse a structure.
So it's not particularly exciting
to see these demonstrations.
What I'm going to do is, of
course, it can be exciting
if your demonstration goes wild on you,
but I'm certain you'd all enjoy that.
So I won't risk it.
But we make all of our [inaudible],
and this is going to make 9F tests,
6M tests, and I think two utilities
that generate random [inaudible].
[ Background Sounds ]
So those are all the
executables that [inaudible].
That's one, two, three, four, five, six,
seven, eight, nine, ten FS6 and tests
and two random object generators.
So what I think might be instructive
is just take a look at some of these,
some of the class start offs
that I've, you know, given.
So I think maybe I'll use the editor.
So let's look first at BST base.
And, by the way, BST
base is fully functional.
I didn't mean [inaudible].
[ Background Sounds and Inaudible ]
Yeah. Not [inaudible], too.
Well, we'll leave that there.
So [inaudible] so I didn't
mean to personalize that.
[Inaudible] there.
So this your BST base class.
[Inaudible] FSU.
Notice I'm pre-declaring BST base
in our iterator, level iterator,
and in case somebody wanted to, like,
come back later, pre-order iterator,
folks are [inaudible], this
should be a BT in there,
you know, [inaudible] BT iterator.
We're not on the final
[inaudible], but you could.
Anyway, so here's the class BST base.
Notice as usual that the
second template argument has,
second template parameter
has a [inaudible] argument,
which is less than.
So this all starts off just like most
classes do with a bunch of terminology
and definitions, and we're defining
in order level [inaudible] types
internally to the base class.
That doesn't mean we're
going to implement all those,
but we're just define what
those words will mean.
OK. This space class is, got a
constructor, a one argument constructor
that takes if you've already
got [inaudible] you want to use.
If there is a copy constructor,
destructor [inaudible] inheritance
environment [inaudible] like a virtual.
I don't really think we would
ever [inaudible], you know,
one time probably [inaudible]
all this stuff,
but if somebody decided they
wanted to, you got to [inaudible].
Assignment operator, and not, instead
of again [inaudible] I've
got begin level order.
That's just a, that's a function,
and it returns the level or iterator,
of course, meaning at the beginning of a
level or reversal, and you got n level r
which returns the end of [inaudible]
reversal as a level r iterator.
And you've got same thing for begin
[inaudible] and in order to begin
for [inaudible] or begin
or end in order.
If I just went and erased the
end order here in these four,
I would be defining official
iterator class or BST base.
I just chose not to do that.
So we're officially BS base doesn't have
quote iterators even though it's got
[inaudible] iterators.
And then finally there's this thing
called begin structural in order,
and that will be needed when you have
to go through a tree and look at all
of the nodes, even those that are dead.
So sometimes when you do structural
stuff in the tree, you have to look
at the node, whether it's
considered alive or dead,
and so that's what this sort of begin
structural kind of thing is for.
My client programs never deal with that.
Client program aren't going to be
dealing with the structural stuff.
So that's we could probably
have made that private,
and it would have been fine, or
protected, and it would have been fine.
Somewhere on a derived class
[inaudible], but not anytime program.
And we've got insert.
Of course, we've decided
[inaudible] remove it's time consuming
and hard to program.
So we're going to have to erase
and [inaudible], and we're going
to have insert, put and
get, erase and clear.
We're going to have now those
little commented out things
if I [inaudible] just to remind all
of us that in a truly functional set,
we're going to need a motion
of iterator and a motion of,
and use that to define lower bound,
upper bound, include functions.
That's going to come
in our derived classes.
But here we've got any
sized number of nodes, high.
We've got traverse.
It refers to [inaudible], the display
function, but it is, you know,
the special class print node and
the special recursive reversal.
We've got dot methods.
We've got a check VHC, which is going
to go through and check the properties
on the buyer research
tree, and prototyping
but not implementing in
this file a check RBLT.
I'm prototyping it in the base
class because it's just simpler
because you've got to really
get in and look at, you know,
you've got to get your hands on
the private data of the base class,