<< 1 >>
Rating: 
Summary: Helpful book on algorithms using C
Review: C programming is still with us because of its high performance ability and this book outlines several algorithms using the language. It begins with a classification of algorithms as randomized, divide-and-conquer, dynamic programming, greedy and approximation. Some algorithms the author states defy classiification but he does not give examples. Pointers are discussed in the next chapter, and covers how to avoid dangling pointers, memory allocation, pointers to data structures, function parameters, double pointers, and generic and function pointers. The chapter is clearly written and diagrams are used frequently to illustrate the uses and properties of pointers. The author in particular gives an excellent explanation of how C can simulate call-by-reference parameter passing. This capability in C can be a source of trouble to the newcomer to C. The author does not however discuss triple pointers in this chapter, in spite of their great utility in computational geometry and computational radiology. Void pointers and casting are discussed in detail though, and the author does a good job. Only a cursory discussion of function pointers is given; I would have preferred many more examples to be given. Recursion and tail-recursion are discussed in Chapter 3, with the factorial function used to illustrate the differences. Computational complexity and the O-notation are covered in the next chapter, with the treatment pretty sparse but clear. Linked lists, extremely useful in all areas of engineering and science, are discussed effectively in Chapter 5. Eleven linked list macross, thirteen doubly linked list macros, and eight circular list macros are discussed and the complexity of each given. Virtual memory and paging are given as examples of applications of linked lists. The author moves on to stacks in the next chapter with several stack macros outlined. FIFO queues are discussed but in view of their importance in network modeling not enough examples are given. A very interesting overview of how to implement sets as a data type in C is given in Chapter 7. I was not aware that such a construction could be done effectively in C so this chapter was of particular interest to me. All of the usual set operations are implemented using a number of diffrent macros. A clever set covering algorithm is given at the end of the chapter. Hashing and chain hash tables as arrays of linked lists are outlined in the next chapter. Hash functions are used heavily in such areas as cryptography and the author does a fine job of outlining their implementation. After a good discussion of trees, heaps, priority queues, and graphs, the author begins in the third part of the book with the actual implementationof many useful algorithms. The chapter on numerical methods could be more in depth because of its immmense importance and because C has been one of the best performers for the the time intensive calculations in this area. Huffman encoding and other compression algorithms are also treated with some detail. Several macros for bit operations are given and the ones discussed are helpful for the next chapter on encryption algorithms. The DES and RSA algorithms are treated in this chapter, but unfortunately elliptic curve encryption algorithms are not. The book ends with a fairly good overview of graph algorithms and algorithms in computatational geometry. This is really a pretty good book and gives a good overview of some very important algorithms, and all within a little over 500 pages. The only major omission was the lack of exercises/problems at the end of each chapter.
Rating: 
Summary: good, concise algorithm book ruined by comment
Review: compare to most algorithm/data structure books out there, this book is not as complete as those, but it's much easier to read, and diagrams in this book is well drawn and much eaiser to follow. Why would I only give it 3 stars? One thing really ruined this book - obviously the publisher/editor/author try to increase the total page number by putting ridiculously big comment block in sample code(single line comments takes about 5 lines, all surrounded by '*' and spaces) This made the sample code difficult to read, imagine a 5 line function has to be printed in 2 or 3 pages.
Rating: 
Summary: Stuff I have never seen before!
Review: I have read a half-dozen or more books pertaining to C Algorithms, and most of them were the same. This touched on the usual stuff - sorting, hashing, linked lists, etc. But it touched on these subjects in ways that are so general purpose that the sample code can be used with little modification! It also adds a couple of new things such as Set algorithms and an explaination of how to pass functions as paramenters to functions. There could have been a few more examples, and he could have explained some of his material in plain english, instead of engineerese. Overall the book is excellent, and I will refer to it often.
Rating: 
Summary: A small collection of over-commented code
Review: I hoped to find a broad overview of existing algorithms. Instead I got a small collection of over-commented code. It is true that this book contains some algorithms not discussed in similar books, but it also doesn't contain many algorithms that I consider a part of a programmer's standard toolbox. For example, there is no mention of string matching and searching. The author discusses an implementation of the LZ77 compression algorithm, but doesn't even give a hint as to the workings of related (better) algorithms. There is an implementation of the RSA public key encription, but no mention on how the private encription/public decription counterpart works. The discussion on hash tables only covers hash tables with linked lists, and not the easier to implement double hashing. And I could go on and on. But the most annoying thing about the book is the author's commenting style, which render the code itself unreadable. Almost every instruction is commented by a 5-line high, 80-column wide comment block, exactly in the way that Rob Pike makes fun of in his "Notes on Programming in C" article, where he says: "Don't laugh now, wait until you see it in real life." In short, I would only recommend this book to people wanting to learn some basic algorithms, but already have a strong sense of correct programming style.
Rating:
Summary: Fantastic addition to any personal libriuary.
Review: Just what I needed. One of those books I had to ring in sick to work, sit at home and read. Writing commercial c applications for the Internet, I was looking for a book to give me assistence with my coding. What I found was something which caused me to go back and rewrite a lot of my work! Starting by explaining exactly how memory is managed when calling fuctions, going on to explain, in english, how many commonly used stuctures in c work. Everything from hash tables to encryption. A good read for anybody interested in how code works. Essential for anybody wishing to write quality programs. The best bit. This comes with c libruaries uncompiled with examples, fully explained in the text. Many of which I have used. Reliable, easy to implement and dramatically increase the quality of my code. Want a easy to use binary search tree? A few minutes work and it's there. I also emaild the author, who was more than happy to help with a question. Personally speaking, one of the best computer books I have ever bought.
Rating:
Summary: pretty concise and covers enough ground
Review: Sure, we all have learnt algorithms back in school. We know the fundamentals, we can talk about them, no sweat. But when it comes the time to actually write out an algorithm in C, we all struggle like George W writing SAT. That's why an algorithm book with real useable sample codes is very useful. O'Reilly has a good reputation for pumping out reference books, but there are, inevitably, hits and misses in the series. This volume is a hit. It covers most frequently used everyday algorithms without going into some obscure and generally useless NP-class problems. Full example codes are given on a floopy for easy porting.
Rating:
Summary: Good book, but HORRIBLE CODING STYLE!!!
Review: The book contents is good, the algorithms presented are more or less well explained and the implementeations themselves are not bad (but could be better).
Unfortunately this book has 2 mayor problems:
Sometimes you need an implementation of an algorithm for which you already know the inner-workings, just need quick code instead of reinvening the wheel yourself... the book will not allways give you that, it will sometimes build an algorithm based on previous ones! Darn!, I am supposed to go straight to the point I want and get the code without having to read a couple of previous sections.
Second and worst of all is the coding style this guy has. I don't know what the other reviwer that said that the code is great programs in but certainly not in C. The author of the book simply has the worst style ever... look at the comments, a one line comment surrounded by a box!!! give-me-a-break!... where did he learn this? He should read a book about style, perhaps read Code Complete by Steve McConnel or something before attempting to write code. Anyway this is just one of the many style flaws this book has.
If I could I would return it, after all, you can get mostly any implementation from the internet (I had to do that or would have wasted lots of time and... time is money).
If well written, the book would have been 1/2 its size and then it would have been good.
Why 3 stars? Well, in spite of the poor programming style and bad presentation of some algorithms, if you have time and patience, you get someting out of the book. Just don't use the coding style he uses... if you try that at work you would be fired or at least laughed at.
Rating:
Summary: Simply a great book
Review: This is truly a wonderful book, consisting recommendations of implementation on most of the basic and common algorithms.
The book is shaped to be useful both for developers with little experience in C programming and also for professionals wanting to learn some more, and maybe make their programs run faster and with greater stability.
Possibly more than anything this book taught me how to get much better memory consumption and smaller code using small yet very intelegently designed functions. I believe that reading and tryng some of the many examples in this book for your programming needs, would change the way you think in programming, in a way that you would automatically make much more efficiant programs no matter if you write them in C, in C++, in Java, in Perl or any such language for that matter.
Recommended for people that think there might be someting they could improve in their programming especially in C. : )
Rating: 
Summary: Not worth your time or money
Review: To be fair and honest, I have not read this entire book and that is because I've read far better ones. If you are interested in this topic (and if you're a programmer or computer scientist, you should be), look to Robert Sedgewick's excellent "Algorithms in C" in two volumes, or "Mastering Algoritms" by Cormen, Leiserson, Rivest, and Stein. While the algorithms in Cormen, etc.'s book are not in C, they are in a pseudo language that easy to convert to C. I'm really, really glad I looked this book over before flushing my (limited) money away.
Rating:
Summary: Not worth your time or money
Review: To be fair and honest, I have not read this entire book and that is because I've read far better ones. If you are interested in this topic (and if you're a programmer or computer scientist, you should be), look to Robert Sedgewick's excellent "Algorithms in C" in two volumes, or "Mastering Algoritms" by Cormen, Leiserson, Rivest, and Stein. While the algorithms in Cormen, etc.'s book are not in C, they are in a pseudo language that easy to convert to C. I'm really, really glad I looked this book over before flushing my (limited) money away.
<< 1 >>
|
