Main Site Links Resources Tutorials
News VB Gaming Code Downloads DirectX 7
Contact Webmaster VB Programming Product Reviews DirectX 8
  General Multimedia Articles DirectX 9

C & Data Structures
Author: P.S. Deshpande and O.G. Kakde
Publisher: Charles River Media
ISBN: 1-58450-338-6
Purchasing: [Amazon.Com] - US$59.95, [] - UK£29.59, [TransAtlantic Publishers] - UK£35.95
Reviewed: 22nd March 2004

Front Cover Shot:


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.


The 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 to.

The 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.

The 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.

The 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.

Very much a text book

This 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.

I 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.

I'd 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".

Writing style

Despite my 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 manageable.

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.

In Conclusion

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.

Good Things Bad Things
• Well presented, good use of diagrams and explanations. • Not very useful for those who want Object-Oriented techniques.
• 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.  


DirectX 4 VB © 2000 Jack Hoxley. All rights reserved.
Reproduction of this site and it's contents, in whole or in part, is prohibited,
except where explicitly stated otherwise.
Design by Mateo
Contact Webmaster