Mastering Algorithms with C (Paperback)

by Kyle Loudon (Author)
Key Phrases: geometric algorithms, pointer manipulation, destroy operation destroys, Return Value, Description Macro, Public Interface (more...)

Editorial Reviews

Amazon.com Review
Written with the intermediate to advanced C programmer in mind, Mastering Algorithms with C delivers a no-nonsense guide to the most common algorithms needed by real-world developers.

The highlight of the book has to be its concise and readable C functions for all the algorithms presented here, including basics like linked lists, stacks to trees, graphs, and sorting/searching algorithms. The C functions that implement these algorithms are clearly printed and remarkably easy to read. You can use this sample code directly or adapt it into your C/C++ code.

Although mathematical concepts like Big-O notation are discussed, the authors don't get bogged down in the computer science theory surrounding algorithms. Instead, they present the most tried-and-true algorithms available today in an efficient format. Besides introducing each algorithm, they describe how each is used in computing today, along with a short demo application. Some of these samples are quite low-level, such as a virtual memory manager implemented with linked lists. Most examples are more of general interest, such as a graphing example that counts network hops.

Each section ends with questions and answers about how the algorithms work, along with references to other algorithms (both in the book and from other sources). The authors concentrate on the most useful algorithms available today and don't try to cover every available variation. Busy readers will appreciate the intelligent selection--and efficient presentation--used here.

There are a number of books on C algorithms, but Master Algorithms with C is one of the most concise and immediately useful. It's a perfect choice for the working C/C++ programmer who's in a hurry to find just the right algorithm for writing real-world code. --Richard Dragan

Topics covered: Algorithm efficiency, pointer basics, arrays, recursion, Big-O Notation, linked lists, stacks, queues, sets, hash tables, trees and B-trees, searching, heaps and priority queues, graphs, sorting and searching algorithms, numerical methods, data compression, Huffman coding, LZ77, data encryption, DES, RSA, graph algorithms, minimum spanning trees, geometric algorithms, and convex hulls.

From Library Journal
Although older than some of the current languages, C still is one of the best general purpose programming languages around. Loudon's book discusses C pointers, recursion, data structures from lists and stacks to trees and graphs, sorting and searching, and encryption. This is not a beginner's manual but will work well for programmers wanting to refresh their C techniques and for those moving from another language to C.
Copyright 1999 Reed Business Information, Inc.

See all Editorial Reviews

Product Details

• Paperback: 560 pages
• Publisher: O'Reilly Media, Inc.; Pap/Dis/CD edition (August 5, 1999)
• Language: English
• ISBN-10: 1565924533
• ISBN-13: 978-1565924536
• Product Dimensions: 9.1 x 7 x 1.1 inches
• Shipping Weight: 1.8 pounds (View shipping rates and policies)
• Average Customer Review: 3.4 out of 5 stars See all reviews (15 customer reviews)
• Amazon.com Sales Rank: #61,692 in Books (See Bestsellers in Books)

  Popular in these categories: (What's this?)

  #1 in	Books > Computers & Internet > Programming > C > Algorithms
  #7 in	Books > Computers & Internet > Computer Science > Artificial Intelligence > Human Vision & Language Systems
  #13 in	Books > Computers & Internet > Programming > C > Tutorials

Customer Reviews

Most Helpful Customer Reviews

25 of 27 people found the following review helpful:

5.0 out of 5 stars Exceptional writing, elegant code, great examples, September 13, 1999

By A Customer

Mastering Algorithms in C is the most readable algorithms book I've ever encountered. Not only does the author have a tremendous command of English, he has a writing style that is simply a pleasure to read. The author also deserves mention as having one of the cleanest coding styles I've come across. Having taught and worked with computers for over 15 years, I've seen many. It is no easy feat to present the subject of algorithms using real C code in a consistently elegant manner. This book does it wonderfully. Another feature of the book that works exceptionally well is its detailed presentation of interesting (and I emphasize interesting) real-world examples of how various data structures and algorithms in the book are actually applied. I'm a computer science type, so I especially enjoyed the examples about virtual memory managers, lexical analyzers, and packet-switching over the Internet. But the book includes many other examples of more general interest. Students will find all of the examples particularly insightful. Although most of the code in the book does make use of many of the more advanced features of C, an inordinate number of comments have been included which should help even the feeblest of programmer carry on. In addition, there are two great chapters on pointers and recursion. Exceptional writing, elegant code, great examples, not to mention a lot of entertainment value -- O'Reilly has another winner here. I highly recommend it.

23 of 25 people found the following review helpful:

5.0 out of 5 stars Fantastic addition to any personal libriuary., March 9, 2000

By	B. S. Clewett - See all my reviews (REAL NAME)

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.

35 of 40 people found the following review helpful:

4.0 out of 5 stars Helpful book on algorithms using C, March 1, 2001

By	Dr. Lee D. Carlson (Baltimore, Maryland USA) - See all my reviews (TOP 100 REVIEWER)    (REAL NAME)

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.