Every book has a story as to how it came about and this one is no di®erent,
although we would be lying if we said its development had not been somewhat
impromptu. Put simply this book is the result of a series of emails sent back
and forth between the two authors during the development of a library for
the .NET framework of the same name (with the omission of the subtitle of
course!). The conversation started o® something like, \Why don't we create
a more aesthetically pleasing way to present our pseudocode?" After a few
weeks this new presentation style had in fact grown into pseudocode listings
with chunks of text describing how the data structure or algorithm in question
works and various other things about it. At this point we thought, \What the
heck, let's make this thing into a book!" And so, in the summer of 2008 we
began work on this book side by side with the actual library implementation.
When we started writing this book the only things that we were sure about
with respect to how the book should be structured were:
1. always make explanations as simple as possible while maintaining a moder-
ately ¯ne degree of precision to keep the more eager minded reader happy;
and
2. inject diagrams to demystify problems that are even moderatly challenging
to visualise (. . . and so we could remember how our own algorithms worked
when looking back at them!); and ¯nally
3. present concise and self-explanatory pseudocode listings that can be ported
easily to most mainstream imperative programming languages like C++,
C#, and Java.
A key factor of this book and its associated implementations is that all
algorithms (unless otherwise stated) were designed by us, using the theory of
the algorithm in question as a guideline (for which we are eternally grateful to
their original creators). Therefore they may sometimes turn out to be worse
than the \normal" implementations|and sometimes not. We are two fellows
of the opinion that choice is a great thing. Read our book, read several others
on the same subject and use what you see ¯t from each (if anything) when
implementing your own version of the algorithms in question.
Through this book we hope that you will see the absolute necessity of under-
standing which data structure or algorithm to use for a certain scenario. In all
projects, especially those that are concerned with performance (here we apply
an even greater emphasis on real-time systems) the selection of the wrong data
structure or algorithm can be the cause of a great deal of performance pain.

Therefore it is absolutely key that you think about the run time complexity and
space requirements of your selected approach. In this book we only explain the
theoretical implications to consider, but this is for a good reason: compilers are
very di®erent in how they work. One C++ compiler may have some amazing
optimisation phases speci¯cally targeted at recursion, another may not, for ex-
ample. Of course this is just an example but you would be surprised by how
many subtle di®erences there are between compilers. These di®erences which
may make a fast algorithm slow, and vice versa. We could also factor in the
same concerns about languages that target virtual machines, leaving all the
actual various implementation issues to you given that you will know your lan-
guage's compiler much better than us...well in most cases. This has resulted in
a more concise book that focuses on what we think are the key issues.
One ¯nal note: never take the words of others as gospel; verify all that can
be feasibly veri¯ed and make up your own mind.
We hope you enjoy reading this book as much as we have enjoyed writing it.