Customer Reviews

Data Structures with C++

5 star:		(6)
4 star:		(1)
3 star:		(1)
2 star:		(3)
1 star:		(2)

 

 

The book itself is great and illustrates the core concepts well.
The code examples are grossly out of date (were talking 1990's) and completely ruins the beautiful text by adding confusing, poorly written code examples to reinforce good literature.

If you are buying this to learn data structures as a reference, great.
If you expect usable code examples this is not the book for you.
Highly Microsoft Visual Studio Centric. Not ANSI C++.

My note to the author's / publisher: You need to keep up with the times. This is technology and it moves quickly. Otherwise future-proof your code as much as possible.

The book is close to 900 pages of 14 chapters. You can get all source in book from ftp site. Covers the Data Structures well with clear explainations of "HOW" and "WHY" things work in the implementation of code. Has many written excercises(with answers), and also lots of programming excercises for practice. This is truly a book that leaves you with the answers you seek, and the text is under- standable unlike other text books that try to explain the complexities of data structures, and leave you wondering what is going on. You will understand what is going on with this BOOK!! It is a C++ book. It is a BOOK you can curl up with and enjoy reading it! I strongly suggest it to universities and programmers in the real world!!!!!!!!! J Franzmeier USA

This was a required text book for a college class. The first problem I had was trying to read the blocks of code. For some reason the background of the block was shaded and made the text almost unreadable. Then as I progressed through the chapters I started noticing errors. a typo here, an incorrect image there... it made me doubt the validity of the information I was receiving. I never found any factual errors (but what do I know, I'm a college student).

IMO 16 errors, including the wrong answers in the chapter review questions, are too many for a 2nd edition that costs over $100.00

having read 1st four chapters, i find Ford and Topp are stingy in examples and theory.
You'd better do all the programming exercises at the end of chapter since that's where the value of this book lies.
Thinking in C++ Vol.1 and 2 have better reference material. Please buy Bruce Eckels' "Thinking in C++"!

Ford and Topp have done an excellent job of creating a text with plenty of hands-on examples. Almost all of the examples compiled correctly with Microsoft Visual C++ with very few changes. A few examples did have minor errors that were easily fixed. If you want a "hands-on" guide to data structures, this book worked for me.

Besides all of the actual C++ examples, the authors include good illustrations and answers to selected exercises. I used this textbook for my Data Structures class and several of the students commented on how they planned to keep the book for future reference.

This text is for sophomore-level students, but as the authors claimed it's a good read for professionals as well, a reason being that a professional of many years may not have learned data structures together with designs and implementations in C++ with STL. Going back five to ten years, the book in its current form could not have existed, which is why it's beneficial for the professional to read it.

As a professional, I envy the current college students who are lucky to have this book as the text of one of their courses. A student is also given a semester to digest its content, to do the exercises and projects at the end of each chapter, which is not usually possible for a professional. On the other hand, because of years of experience and perhaps plus college background, things students usually and sometimes must do aren't necessary for the professional, who should be able to read through the book in considerably shorter period of time.

In summary, it's a great read on the subjects, though one star is taken off for its imperfection such as mistakes in the code and less than superior presentation of some materials.

I've always got this book open somewhere in my office. Even if another book is assigned for your ACM-CS2 curriculum course, go ahead and buy this as a supplement (be sure to download the source code from the authors' website). The cost is justified because you'll use it going forward in your studies/career. Other books teach the abstract concepts, but this text teaches you how to implement them.

Because of physical problems with this book, the authors' programming style, and lack of a proper audience, I just can't recommend it. There are just too many problems and too few positives for the book to be worthwhile.

First, the physical problems with the book: in my case, the binding appears to be bad. As I took it out of its plastic wrapping, I noticed a gap between the cover spine and the glued/sewn binding of the actual pages. It looks like the glue that was supposed to hold the two parts of the book together failed. Turning the pages causes a lot of snapping, crackling, and popping and I worry that the binding will break. Second, it seems like the book uses too small a font (these old eyes don't focus like they used to). Oddly, if I compare the font size to that in other textbooks, it looks comparable. I'm not sure, but I think the publisher used a slightly smaller line spacing and either a lighter ink or darker paper. Whatever it is, it makes reading the book a bit hard. That's pretty subjective and minor, but more aggravating is that the publisher used an even lighter (gray) font for the code segments. This makes the code even harder to read than the text. Again, I'm not certain, but it also looks like the font in the code sections is even smaller than the font in the text. And finally, the authors don't use any color in their code. It's hard to distinguish the actual code from the comments. This makes reading the code difficult.

Next, I highly disagree with the authors' coding style. Essentially, I consider it sloppy. In general, they don't write their class methods to ensure data integrity (and that's one of the big advantages of classes (which are at the core of this book)). Also, the authors tend to directly access private class members within the class methods instead of using the class' already defined public methods that do the same thing (get/set). I know this is allowed, but it's still bad software engineering: you should re-use code wherever possible. Similarly, and worse, the authors violate the principles of data hiding by writing classes with public data members instead of with private data members and public get/set methods. I also have a problem with the authors using "using namespace std;" in their code. Since this exposes all of the C++ standard library methods to the program, it can lead to conflicts. I understand that in a teaching environment this might be good for keeping the focus on the topic at hand instead of "cluttering up the code" with nuances, but the authors make no reference to this rationale. They just blindly use that line in all their code. I'd much prefer they explicitly did a "using std::whatever;" when they needed it. What's especially bad is that they do this in all the HEADERS they provide for their examples (not just in the "main" programs). Anyone who uses any of those headers automatically ends up with all the namespace names included in their code. And, finally, not only are the authors lax in their object oriented programming, they're also lax in their structured programming: they routinely, and without comment, use break statements to jump out of the infinite for-loops (which are feats in themselves) they set up to handle their file input.

Finally, and most importantly, the authors don't seem to have a grasp on who their audience is. In the Preface and the start of the first chapter, they specifically state that the readers should already be familiar with objects and classes from a first course in C++. They note that they aren't about to review old topics, but, instead, will pick up where that left off. However, most of the book is a re-hashing of basic C++ programming. For instance:

- Chapter 1 is a review of programming classes (and, thus, objects) in C++.

- Chapter 2 discusses 1) software design, 2) handling runtime errors, 3) object composition, and 4) operator overloading.

- Chapter 3 covers templates and recursion. The algorithms discussed are those usually presented in C++ programming courses: selection sort, sequential search, binary search, tower of hanoi, and greatest common divisor.

- Chapter 5 goes over pointers, pointer arithmetic, dynamic memory allocation, constructors and destructors.

- Chapter 7, stacks. Chapter 8, queues. Chapter 9, linked lists. Chapter 10, binary trees. Chapter 13, inheritance and abstract classes.

All of this is what I consider to be basic C++ (see Deitel's "C++ How to Program" book to find references to all those things). I just can't see how anyone could learn even the rudiments of C++ without having covered those topics. I could be wrong (in which case, since I've provided my rationale for my rating, you'll at least know what to ignore in this review). But, for all intents and purposes, the authors don't really start teaching anything new until after page 500 (Chapter 10) in a 1000 page (16 chapter) book. And even there, I was so irritated with the various problems I noted above, that I kept wondering how much credence to put in the authors' presentation.

So, in a nutshell, because of the physical problems with the book itself, the sloppiness of the authors' programming style, and their mis-identification of the audience, I can't recommend this book. I rate it at only 2 stars out of 5.

As a side note, at the time I bought this book, Florida State University (FSU) used it in their COP 4530: "Data Structures, Algorithms & Generic Programming" course. They've now switched to a book called "Data Structures & Algorithms in C++," 3e, by Drozdek. I don't know anything about that book, but based solely on this book, FSU did the right thing.

This book presented the material on data structures in a clear and concise manner. The written exercises were appropriate for the subject matter at hand and they enhanced comprehension of the material in the chapters. This book teaches the abstract concepts of Data Structures, while also teaching how to practically go about implementing them in C++. Particularly useful is the concept of an abstract data type, and the emphasis on separation of implementation from specification. The bottom up approach to Data Structures is brilliant, this book is a must for college students. This was my Data Structures textbook, it was excellent!

This book contains the essential of computer programming. Pure OOP and complete data stucture. Lot of example and easy to grasp. Recommended!!!