|
|
Introduction to Algorithms (Hardcover)
by Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, Clifford Stein
| Category:
Combinatorics, Mathematics, Science, Textbooks |
| Market price: ¥ 700.00
MSL price:
¥ 628.00
[ Shop incentives ]
|
| Stock:
Pre-order item, lead time 3-7 weeks upon payment [ COD term does not apply to pre-order items ] |
MSL rating:
 Good for Gifts |
| MSL Pointer Review:
An academic masterpiece, this book is the definitive reference for data structures and algorithms with rigorous coverage of the most widely used algorithms. |
| If you want us to help you with the right titles you're looking for, or to make reading recommendations based on your needs, please contact our consultants. |
Detail |
Author |
Description |
Excerpt |
Reviews |
|
|
|
Author: Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, Clifford Stein
Publisher: The MIT Press; 2nd edition
Pub. in: September, 2001
ISBN: 0262032937
Pages: 1184
Measurements: 9.1 x 8.1 x 2 inches
Origin of product: USA
Order code: BA01536
Other information: ISBN-13: 978-0262032933
|
|
Rate this product:
|
|
- Awards & Credential -
The first edition won the award for Best 1990 Professional and Scholarly Book in Computer Science and Data Processing by the Association of American Publishers. |
|
- MSL Picks -
Known in computer science circles as CLR (for the authors) or simply, "The White Book", Introduction to Algorithms by Cormen, Leiserson, and Rivest is the de-facto standard text for algorithms and data structures. It covers all the basic subjects (big-O notation, trees, graphs, etc...) as well as a few intermediate subjects (amortized analysis, matroids, etc...). Of course, this book is not the be-all and end-all of computer science nor does it pretend to be. It touches on NP-completeness only lightly and all but omits randomization; but if you wanted a text on NP-completeness, you would be reading Garey & Johnson and if you wanted randomization you'd go to Motwani & Raghavan. But if you need a reference on data structures and algorithms, this is the book for you.
Now, some have complained that while this book is an excellent reference that it is a poor text to learn from. I beg to differ. I concede that it is certainly more demanding than many other introductory texts, but this is a boon not a curse. By remaining true to computer science's mathematical heritage, Cormen et al. force the reader to become accustomed to rigourous, formal reasoning, something which is unfortunately absent in many computer science curricula. The authors present the concepts cleanly and clearly, without the distraction of any specific programming language/paradigm. Perhaps it is this removal from a familiar C/C++/Java/flavour-of-the-month/etc... milieu which makes some readers nervous. But it is precisely this separation which forces the reader up into the realm of abstraction where computer science truly resides.
(From quoting Jose Berlin, USA)
Target readers:
A book every computer science student should own.
|
|
- Better with -
Better with
Combinatorial Optimization: Algorithms and Complexity [UNABRIDGED]
:
|
|
Customers who bought this product also bought:
 |
Combinatorial Optimization: Algorithms and Complexity [UNABRIDGED] (Paperback)
by Christos H. Papadimitriou, Kenneth Steiglitz
Published in 1952, this books is a masterpiece on Combinatorial Optimisation. |
 |
Design Patterns: Elements of Reusable Object-Oriented Software (Addison-Wesley Professional Computing Series) (Hardcover)
by Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides
A modern classic in the literature of object-oriented development, it's a book of design patterns that describe simple and elegant solutions to specific problems in object-oriented software design. |
 |
Designing Interfaces: Patterns for Effective Interaction Design [ILLUSTRATED] (Paperback) (Paperback)
by Jenifer Tidwell
Do you want to design attractive, easy-to-use interfaces but aren't sure how? This book will help you. |
 |
JavaScript: The Definitive Guide [ILLUSTRATED] (Paperback) (Paperback)
by David Flanagan
If you want to learn JavaScript the "right" or "computer-science" way, you only need this book - covering everything from simple variables to complex AJAX coding. |
 |
The C++ Programming Language (Special 3rd Edition) (Hardcover)
by Bjarne Stroustrup
Presents the complete C++ language and a discussion of design and software development issues. Provides an emphasis on tutorial aspects aimed at the serious programmer. |
 |
Peopleware : Productive Projects and Teams, 2nd Ed. (Paperback)
by Tom Demarco, Timothy Lister
The book made a clear and compelling augument that the human factor, not technology, makes or breaks a software development effort. |
 |
Code Complete, Second Edition (Paperback)
by Steve McConnell
Focusing on actual code construction, but touching on every aspect of software engineering including psychology/behavior, this book is an essential reading for every and all developers. |
 |
The Pragmatic Programmer: From Journeyman to Master (Paperback)
by Andrew Hunt, David Thomas
A classic reading on programming ranking with Code Complete and The Mythtical Man-Month. |
 |
Rapid Development (Paperback)
by Steve McConnell
A succinct, well organized and must-read collection of the lessons learned and best practices in software engineering over the last three decades. |
 |
The Mythical Man-Month: Essays on Software Engineering, 20th Anniversary Edition (Paperback)
by Frederick P. Brooks
Focusing on the human elements of software engineering, this classic offers insight for anyone managing complex development projects. |
 |
Head First Design Patterns (Head First) [ILLUSTRATED] (Paperback)
by Elisabeth Freeman, Eric Freeman, Bert Bates, Kathy Sierra
Written in a typically Head First refreshing style, this is one of the easiest to read and absorb among the major reference sources for design patterns. |
 |
The C++ Standard Library: A Tutorial and Reference (Hardcover)
by Nicolai M. Josuttis
Extremely well organized and well written, this book is an excellent reference to advanced C++ features. |
 |
Eric Meyer on CSS: Mastering the Language of Web Design (Paperback) (Paperback)
by Eric A. Meyer
A collection of 13 redesign projects, each illustrating different aspects of CSS layout techniques and HTML, with a philosophy, a way of thinking, and a collection of ideas underneath. |
|
|
Thomas H. Cormen is Associate Professor of Computer Science at Dartmouth College.
Charles E. Leiserson is Professor of Computer Science and Engineering at the Massachusetts Institute of Technology.
Ronald L. Rivest is Andrew and Erna Viterbi Professor of Computer Science at the Massachusetts Institute of Technology.
Clifford Stein is Associate Professor of Industrial Engineering and Operations Research at Columbia University.
|
|
From Publisher
The first edition won the award for Best 1990 Professional and Scholarly Book in Computer Science and Data Processing by the Association of American Publishers.
There are books on algorithms that are rigorous but incomplete and others that cover masses of material but lack rigor. Introduction to Algorithms combines rigor and comprehensiveness.
The book covers a broad range of algorithms in depth, yet makes their design and analysis accessible to all levels of readers. Each chapter is relatively self-contained and can be used as a unit of study. The algorithms are described in English and in a pseudocode designed to be readable by anyone who has done a little programming. The explanations have been kept elementary without sacrificing depth of coverage or mathematical rigor.
The first edition became the standard reference for professionals and a widely used text in universities worldwide. The second edition features new chapters on the role of algorithms, probabilistic analysis and randomized algorithms, and linear programming, as well as extensive revisions to virtually every section of the book. In a subtle but important change, loop invariants are introduced early and used throughout the text to prove algorithm correctness. Without changing the mathematical and analytic focus, the authors have moved much of the mathematical foundations material from Part I to an appendix and have included additional motivational material at the beginning.
|
| Topics covered: Overview of algorithms (including algorithms as a technology); designing and analyzing algorithms; asymptotic notation; recurrences and recursion; probabilistic analysis and randomized algorithms; heapsort algorithms; priority queues; quicksort algorithms; linear time sorting (including radix and bucket sort); medians and order statistics (including minimum and maximum); introduction to data structures (stacks, queues, linked lists, and rooted trees); hash tables (including hash functions); binary search trees; red-black trees; augmenting data structures for custom applications; dynamic programming explained (including assembly-line scheduling, matrix-chain multiplication, and optimal binary search trees); greedy algorithms (including Huffman codes and task-scheduling problems); amortized analysis (the accounting and potential methods); advanced data structures (including B-trees, binomial and Fibonacci heaps, representing disjoint sets in data structures); graph algorithms (representing graphs, minimum spanning trees, single-source shortest paths, all-pairs shortest paths, and maximum flow algorithms); sorting networks; matrix operations; linear programming (standard and slack forms); polynomials and the Fast Fourier Transformation (FFT); number theoretic algorithms (including greatest common divisor, modular arithmetic, the Chinese remainder theorem, RSA public-key encryption, primality testing, integer factorization); string matching; computational geometry (including finding the convex hull); NP-completeness (including sample real-world NP-complete problems and their insolvability); approximation algorithms for NP-complete problems (including the traveling salesman problem); reference sections for summations and other mathematical notation, sets, relations, functions, graphs and trees, as well as counting and probability backgrounder (plus geometric and binomial distributions). |
|
A guest reviewer (MSL quote), USA
<2008-11-02 00:00>
For years, I've looked for a single algorithms book that would cover all of the bases and provide an up-to-date replacement for the 3 Knuth volumes. The 2001 edition of CLR is it. I had looked at earlier versions of CLR and somehow not seen what I wanted; seemed too much like a enumeration of algorithms rather an explanation of them. But what the other reviewers say about CLR is definitely true of this edition. Its the one you want on your shelf to accompany your career in software or computer science.
The reviewers who knocked off stars for being difficult were probably also correct; this book is not for community college course with students who earned Cs in math and programming courses. In fact, I question the word "introduction" in the title. Yes, it only assumes minimal math and programming knowledge, but it goes a long ways into the topic. Sure, it might not cover some exotic academic topics or some very specialized topics, but if you are a software engineer it has all you are likely to want or need in your practical work (until there are new research results that prove important in industry) unless you work in area that requires specialized algorithms.
One topic regretablly omitted from this book, and most other books on algorithms, is extendible hashing, hashing techniques that support an arbitrary, unkown amount of data. Papers by Fagin and Litwin describe such methods. |
A guest reviewer (MSL quote), USA
<2008-11-02 00:00>
The first reason: you're taking a course and this is the text. The second reason: you are a working professional and think it might be useful. I have comments for each reason.
If you are taking a course, there is a good chance you will hate this book. This reminds me a lot of the Feynman Lectures of Physics: rapturously admired by people who have already mastered the material; a bit on the brain-numbing side for those who have never seen this stuff before.
This book (despite its bulk) is actually very concise in its treatment of topics. This means that you'll be reading along and suddenly realize it has left you behind. On the other and, it is also very precise, which means your problem is that you missed something. Fortunately, because it is concise, whatever that is is bound to be in the last page or so.
My advice to the student is this: learn to live with the Zen of this book, and you won't hate it. Simply accept that this book will take you on numerous short trips from mystification to epiphany. When you find yourself lost, back up a few paragraphs and really apply yourself. If this were easy stuff, everybody would do it.
For the professional, realize that this is NOT a cookbook. Don't go to this book to examine what an implementation of heap sort in C might look like, although users of languages like Python might be able to use some of the book's treatments of things like graph algorithms that way.
This is a book about designing algorithms, not implementing them. If you need to design an algorithm (much more likely in today's sophisticated, networked, massive data centric applications), this is your text. It is comprehensive, and has useful reviews of things like infinite series and probability that you're probably a bit rusty on.
This is a kind of book a professional wants when his job is giving his company a competitive edge at doing really, really hard stuff. It's not for people who buy books with names like "Visual Basic for Dummies".
If you are a teacher, I would say this: be prepared for students who don't like this book. However this book will get the job done, and will be something students who go on to advanced work will want to keep.
Kleinberg and Tardos, although not the kind of textbook you keep for the rest of your life, may be a better choice on the undergraduate level for several reasons. First, it introduces the material in a more gentle, pedagogical manner. Second, it makes more of an effort to introduce topics using somewhat realistic sounding problems; for me this is neither here nor there but students may be less likely to wonder "why are we studying this?" Third, it has solved exercises. Fourth, it's designed to fit conveniently into an undergraduate curriculum between a data structures course and a computation theory course.
That said, when ten years hence your student runs across a dynamic programming problem and remembers he studied this in school, it is CLRS that will get him back up to speed most quickly. |
|
|
|
|
