& Data Structures
P.S. Deshpande and O.G. Kakde
Publisher: Charles River Media
- US$59.95, [Amazon.co.uk]
- UK£29.59, [TransAtlantic
Publishers] - UK£35.95
Reviewed: 22nd March 2004
This book is very
much a general programming book - that is, it
doesn't obviously fit the content of this website
(multimedia programming), however, as you should
know - algorithms and related data structures are
a very important concept that any good programmer
needs to know about.
The majority of
the time, there is no point 're-inventing the
wheel' while programming - as such programmers
tend to learn a stock set of algorithms and
remember which is the right one for the right
occasion. Such that a book like this that covers
almost all of these algorithms/structures will be
of considerable use should you either not know
your algorithms, or just need a reference to
refresh your memory.
book is quite clearly divided up into three
sections; whilst they are to be read in order they
operate in a fairly independent way. That is, you
can quite easily jump to one of the three sections
and use it as a reference section should you need
first section covers the 'C' programming language
- this being the language that this book is
expressed in. An important thing to note regarding
this type of book is that a language is needed to
express the book, yet the concepts/theory is often
applicable in a wide range of languages. The
overview of 'C' is a respectable 164 pages - not
the most in depth coverage ever written, but good
enough for someone familiar with programming but
not necessarily 'C' programming.
second section is where it gets interesting -
covering the five main categories of data
structure (and their associated algorithms) in a
fairly generalized and high-level way. This is the
real meat of this text - where it explains the
concepts that are foundations to the vast majority
of modern programming. Covering a total of 265
pages, it has a good coverage of each area. The
bulk of the source code is contained in the third
section, but there is still plenty to be found in
this section - mostly to back up the concepts
covered by the text.
third section is probably the best part with
regards to using this book as a reference source.
It is the same page count as section two, but
easily twice as much code. The chapter headings
for part three match up with those in part two;
except this time all of the sub-sections are
specific 'problems' related to the main topic.
Each respective problem (e.g. 'Topological Sort'
under 'Problems in Graphs') starts with a complete
code listing for the solution followed by an
explanation of the code. There isn't a huge
description or proof - it's pretty much just the
facts. This in my opinion is what makes this book
stand out as very few similar books include such a
comprehensive (and applied) coverage of just
the algorithms without including a few pages of
thoughts on it's uses and correctness.
much a text book
book is written by academics and quite obviously
intended towards the students that may be taking
their courses (or generally any students taking
related courses). As such it reads from cover to
cover as a text book, rather than the style of the
many commercial books reviewed on this website.
rarely have any problem with reviewing text books
with regards to using them outside of the academic
'window', but in this case there is an obvious
lack of 'filler' and continuity - something I see
as essential when dealing with commercial titles.
To put it simply, it would be a bit disjointed if
you were to read this book from cover-to-cover,
there is no introduction as such - no
foundation/backgrounder regarding what the book is
about (there isn't really anything much about the
authors either), and the jumps between chapters
and sections is a little sharp.
more expect this to be a recommended text for a
degree module, whereby a chapter is quoted as
'recommended reading' on the last slide for the
lecture. This is quite clear by the lack of
general overview and introduction - I get the
impression that fundamentals such as 'Big-Oh'
notation would be covered in the lecture rather
than in this book. This also matches the styling
of the third section where there is no
introduction to the specific problems that are
shown - rather, the lecturer could say "for
more information on ____ please refer to page ___
in the course text".
criticisms of this being a university text book,
it is far from being unreadable. The good
structure is matched by a clear and concise
explanation of concepts in the text. The
explanations can get very complex at times -
particularly when the authors discuss the
time/space complexities for algorithms, but it is
Diagrams are one
of the most important methods for explaining how
algorithms work. Explanation and source code can
only go so far - and our brains are very good at
understanding things from animations/pictures.
When I had to learn this subject at university I
found that a good use of slides showing
step-by-step analysis was the easiest way to get
my head around things. This book is reasonably
good on that front - not perfect, but equally not
bad. Diagrams are used quite widely, but there are
still a few places that they could be more heavily
used. However, one aspect that is often under used
in these books is that of colour - some of these
diagrams would be a lot, lot clearer if the
important parts were highlighted in some way.
This book is
written quite clearly for university-level
students on software engineering related courses.
So if you fit that category then it's worth your
while purchasing this book. If you're not
university/professional level programming, or just
doing programming as a hobby then there are better
and easier to read texts - by all means have a
look at this book, but you'll probably find that
it isn't the best choice for you.
Well presented, good use of diagrams and
Not very useful for those who want
Excellent 3-part structure.
Too much of a supporting text to be used
solely on its own.
Covers almost every major algorithm/ADT.
Uses a slightly 'dated' language now; most
people seem to prefer using C++ over C.
Has a problems/solutions section, useful
as a reference.
No colour diagrams: A missed opportunity?
Source code included on CD.