Art of Computer Programming, Volume 1: Fundamental Algorithms (3rd Edition) (Hardcover)

~ (Author)

Editorial Reviews

Amazon.com Review

This magnificent tour de force presents a comprehensive overview of a wide variety of algorithms and the analysis of them. Now in its third edition, The Art of Computer Programming, Volume I: Fundamental Algorithms contains substantial revisions by the author and includes numerous new exercises.

Although this book was conceived several decades ago, it is still a timeless classic. One of the book's greatest strengths is the wonderful collection of problems that accompany each chapter. The author has chosen problems carefully and indexed them according to difficulty. Solving a substantial number of these problems will help you gain a solid understanding of the issues surrounding the given topic. Furthermore, the exercises feature a variety of classic problems.

Fundamental Algorithms begins with mathematical preliminaries. The first section offers a good grounding in a variety of useful mathematical tools: proof techniques, combinatorics, and elementary number theory. Knuth then details the MIX processor, a virtual machine architecture that serves as the programming target for subsequent discussions. This wonderful section comprehensively covers the principles of simple machine architecture, beginning with a register-level discussion of the instruction set. A later discussion of a simulator for this machine includes an excellent description of the principles underlying the implementation of subroutines and co-routines. Implementing such a simulator is an excellent introduction to computer design.

In the second section, Knuth covers data structures--stacks, queues, lists, arrays, and trees--and presents implementations (in MIX assembly) along with techniques for manipulating these structures. Knuth follows many of the algorithms with careful time and space analysis. In the section on tree structures, the discussion includes a series of interesting problems concerning the combinatorics of trees (counting distinct trees of a particular form, for example) and some particularly interesting applications. Also featured is a discussion of Huffmann encoding and, in the section on lists, an excellent introduction to garbage collection algorithms and the difficult challenges associated with such a task. The book closes with a discussion of dynamic allocation algorithms.

The clear writing in Fundamental Algorithms is enhanced by Knuth's dry humor and the historical discussions that accompany the technical matter. Overall, this text is one of the great classics of computer programming literature--it's not an easy book to grasp, but one that any true programmer will study with pleasure.

Product Description

The bible of programming theory and practice is being updated for the first time in more than 20 years. The book is concerned with information structures--the representation of information within a computer, the structural interrelations between data elements and how to work with them efficiently, and applications to simulation, numerical methods and software design.

See all Editorial Reviews

Product Details

• Hardcover: 672 pages
• Publisher: Addison-Wesley Professional; 3 edition (July 17, 1997)
• Language: English
• ISBN-10: 0201896834
• ISBN-13: 978-0201896831
• Product Dimensions: 9.2 x 6.8 x 1.5 inches
• Shipping Weight: 2.5 pounds (View shipping rates and policies)
• Average Customer Review: 4.2 out of 5 stars  See all reviews (49 customer reviews)
• Amazon.com Sales Rank: #177,036 in Books (See Bestsellers in Books)

Customer Reviews

Most Helpful Customer Reviews

22 of 22 people found the following review helpful:

5.0 out of 5 stars Excellent update of a timeless classic - *Required Reading*, November 10, 1997

By	[e-mail] (Kirk Hays) (Portland, Oregon, USA) - See all my reviews

Anyone who aspires to be a transcendent programmer must own (and use) Knuth. I've used my 20 year old TAOCP vol. 1 so many times over the years that it lays flat at any page.

The updated volume 1 is more of the same - a classic revisited, revamped, restored. It is odd to handle something so familiar, yet so crisp.

Those who dislike MIX will be unimpressed - to them, I say that you don't learn by doing the same vanilla thing time and again, but rather by wrestling with unfamiliar concepts and architectures. Many times my fellow programmers will find themselves roadblocked in an unfamiliar situation, while I often can see the unobvious solution - I attribute this ability to a wide experience with unconventional solutions, including extensive study of Knuth's TAOCP.

If you're serious about your programming abilities, you *must* own (and study) this book! Frankly, if computer science were taught as an apprenticeship, this would be the journeyman's manual. I've required the many programmers I've trained over the years to own and study TAOCP, and they've all come to appreciate it's layered approach to problems - you can read Knuth at many levels, from algorithm reference to meta-analysis of an entire class of problems.

If there is a Koran, Bible, or Tao of Computer Science, this is it. The only thing close is Aho's "Dragon Book," and it's specific to compilers.

20 of 21 people found the following review helpful:

5.0 out of 5 stars Excellent book for learning fundamental algorithms well., August 15, 1999

By	Noah Stein ([e-mail]) (Connecticut, USA) - See all my reviews

I read this book when I was a sophomore in high school and I thought it was excellent. Prior to reading the book, I had wanted for a long time to write a program to evaluate standard mathematical expressions. I had even tried once before, but I didn't know enough about what I was doing to be really successful. Somewhere in the second chapter in a discussion of lists, doubly-linked-lists, and binary trees, a good solution came to me, and I implemented it right after I finished reading the book. It worked very well. This book helped me to accomplish the major goal-project of my computer programming career so far, and I definately think it is worth reading for anyone wanting a really advanced understanding of fundamental algorithms. Now I know to many advanced means total [over]use of fully encapsulated C++ objects, which this book doesn't have, but this book gives an advanced understanding, which is infinitely more valuable than classes. If you understand OOP and you understand this book, you should be able to combine the two just fine. Lastly, I'd like to comment on the use of MIX. I read almost none of the MIX assembly code when I read this book. The little I looked at I looked at because I wanted to see what assembly was like in the 60's. But you can understand everything he's trying to say by his explanations of the algorithms, the assembly code is only for clarification, and you don't have to read it. I also believe that everyone who's been using fully encapsulated classes for their entire programming career should learn an assembly language sometime. Just like this book, it will teach you how to think.

15 of 15 people found the following review helpful:

5.0 out of 5 stars The bible of computer science just got better!, November 29, 1997

By A Customer

Knuth has finally updated the three completed volumes ofhis exceptional "The Art of Computer Programming" series,correcting errors and updating the topics to includestate-of-the-art algorithms while retaining the basicstrengths and weaknesses of the books. This comes as arelief to many old-time programmers who, watching Knuth's20-year diversion in pursuit of typographic perfection, hadbecome convinced he was NEVER going to get around tocompleting the remaining four volumes of the series.

The series's strength is its exhaustive survey and deepscientific analysis of the many algorithms applicable tothe areas of computer science covered. No other book orseries comes close in providing the reader with the toolsto understand and develop algorithms and to choose amongthe alternatives available when faced with a programmingchallenge requiring an algorithmic solution.

Knuth's primary weapon for analysis is mathematics and hedoesn't hesitate in beating algorithms to death with abarrage of equations; in fact, on a few pages a reader canfind up to thirty summation signs. So a warning is inorder: readers with math anxiety are likely to be reducedto a state of insensate palpitation. Yet the books containvery little calculus or other higher mathematics and thus acollege sophomore should be able to follow the discussion.Also, the reader can skip all the proofs on first readingand simply trust that Knuth is telling the truth.

Surprisingly, the series contains much background materialon the history of computer science and quite a bit of wryhumor. It is about as lively as can be expected of a seriesso deeply technical.

The series's greatest weakness is the MIX assemblylanguage, which Knuth uses to illustrate algorithms, almostalways after first describing them in English. Althoughassembly language is necessary in order to maintain Knuth'sdeconstructionist approach, MIX is deeply rooted in the1960s concept of a computer, with no stack orgeneral-purpose registers. Worse, a reader returning to thebook after letting it lie fallow will find the MIXinstruction mnemonics are needlessly cryptic (What do"ENNX" and "JBUS" mean!?). Perhaps Knuth will update theinstruction set or improve the mnemonics in a futureedition.

To sum up, I'd like to repeat some advice that was given tome in 1974 and is still true today: "If you want to be aprogramming technician, read about the latest programmingfad. If you want to be a computer scientist, read Knuth."

-- Glenn Fawcett