Customer Reviews

Practical Algorithms in C++

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

 

 

Overall, this book may have something to offer as a basic introduction to algorithms for persons with little or no college exposure to computer science, but I would not recommend it . There are some important topics, most notably trees, which are inexplicably omitted, while other topic contain incorrect information. The author starts most chapters by explaining a naive or "brute-force" implementation of an algorithm, and then proceeds to improve on it. Such an approach is fine, but most chapters spend too much time on the naive solution, and not enough time on the efficient solution. The chapters on sorting and hashing are good. Nothing particularly exciting in these chapters, but it is a good overview of the basic techniques. My main objection to this book is in some of the more advanced chapters. The chapter on text searching, for instance, does not deal with regular expressions, on the ground that such matters are beyond the scope of the book. The a! uthor then spends an entire chapter discussing finite state machines (FSA's), without mentioning the equivalence between regular expressions and finite state machines. Also missing is the insight that some of the text searching algorithms discussed in another chapter are actually specialized FSA's. The result is an entire chapter covering a complicated subject, but without showing any practical use. The worst chapter in the book is the chapter on prime numbers and factors. Had this chapter been replaced with a decent chapter on search trees (which are noticeably absent from the book), I may have actually recommended the book. Many statements in this chapter are simply wrong, and what is covered is often trivial. The topic of prime numbers itself is important in a book on algorithms due to its connection with cryptography, but this connection is not mentioned at all. Furthermore, the algorithms presented are completely useless for any cryptographic purpose. Since thi! s is not a book on number theory, the fact that state of th! e art algorithms are omitted should not be considered a serious shortcoming. However, the incorrect statements in the chapter are inexcusable and leads me to question whether the other chapters (covering random numbers, graph algorithms, heaps, etc.) also contain similarly inaccurate information. The source code is heavy on the use of templates, but light on the other object-oriented constructs (ex. inheritance, polymorphism) available in C++. Even so, this is an improvement on most C++ algorithms books which claim to have C++ code, but in reality only contain C code. In summary, this book is not yet ready for prime time. None of faults of the book are beyond repair, and a subsequent edition addressing these shortcomings could result in a much needed introductory algorithms book. The source code presented appears to work fine as advertised, but I would advise against relying on the information in the book in deciding which algorithms are suited for a particular purp! ose.

The first reviewer missed the division of Flamig's work. He split the work into two books, Practical Data Structures and Practical Algorithms. I recommend both books to my computer science students for their work. Flamig does not talk about regular expressions = FSA, but that is a not too important to me.

This book is the single best introduction to practical computer algorithms that I've found, book, magazine, or otherwise. While the code is all C++ (good code style too), the information is easily understood and represented in Java or another object-oriented language. Highly recommended for new or experienced developers.

This is not one of those highly academic books that analyze a particular problem and solution in agonizing detail but don't really give you any useful source code. Its got useful code with brief but thorough discussions of the pro/cons/gotchas. I picked up this book because I need a CRC algorithm -- not difficult to do, but I was very pressed for time -- and it took me all of 10 minutes to find the particular version of the algorithm to suit my needs and plug it in! This one will stay on my book shelf for a long time.