This fourth edition of Robert Sedgewick and Kevin Wayne’s Algorithms is the leading textbook on algorithms today and is widely used in colleges and universities worldwide. This book surveys the most important computer algorithms currently in use and provides a full treatment of data structures and algorithms for sorting, searching, graph processing, and string processing -- including fifty algorithms every programmer should know. In this edition, new Java implementations are written in an accessible modular programming style, where all of the code is exposed to the reader and ready to use.

The algorithms in this book represent a body of knowledge developed over the last 50 years that has become indispensable, not just for professional programmers and computer science students but for any student with interests in science, mathematics, and engineering, not to mention students who use computation in the liberal arts.

The companion web site, algs4.cs.princeton.edu contains

An online synopsis

Full Java implementations

Test data

Exercises and answers

Dynamic visualizations

Lecture slides

Programming assignments with checklists

Links to related material

The MOOC related to this book is accessible via the "Online Course" link at algs4.cs.princeton.edu. The course offers more than 100 video lecture segments that are integrated with the text, extensive online assessments, and the large-scale discussion forums that have proven so valuable. Offered each fall and spring, this course regularly attracts tens of thousands of registrants.

Robert Sedgewick and Kevin Wayne are developing a modern approach to disseminating knowledge that fully embraces technology, enabling people all around the world to discover new ways of learning and teaching. By integrating their textbook, online content, and MOOC, all at the state of the art, they have built a unique resource that greatly expands the breadth and depth of the educational experience.

Descriptions du produit

Biographie de l'auteur

Robert Sedgewick has been a Professor of Computer Science at Princeton University since 1985, where he was the founding Chairman of the Department of Computer Science. He has held visiting research positions at Xerox PARC, Institute for Defense Analyses, and INRIA, and is member of the board of directors of Adobe Systems. Professor Sedgewick’s research interests include analytic combinatorics, design and analysis of data structures and algorithms, and program visualization. His landmark book, Algorithms, now in its fourth edition, has appeared in numerous versions and languages over the past thirty years. In addition, with Kevin Wayne, he is the coauthor of the highly acclaimed textbook, Introduction to Programming in Java: An Interdisciplinary Approach (Addison-Wesley, 2008).

Kevin Wayne is the Phillip Y. Goldman Senior Lecturer in Computer Science at Princeton University, where he has been teaching since 1998. He received a Ph.D. in operations research and industrial engineering from Cornell University. His research interests include the design, analysis, and implementation of algorithms, especially for graphs and discrete optimization. With Robert Sedgewick, he is the coauthor of the highly acclaimed textbook, Introduction to Programming in Java: An Interdisciplinary Approach (Addison-Wesley, 2008).

Commentaires client les plus utiles sur Amazon.com (beta)

Amazon.com:
115 commentaires

321 internautes sur 334 ont trouvé ce commentaire utile

Best algorithms textbook by far22 mai 2011

Par
Kevin P. Murphy
- Publié sur Amazon.com

Format: Relié

"Algorithms" (4th edn) by Robert Sedgewick and Kevin Wayne (publishedby Addison-Wesley in March 2011) is one of the best computer sciencebooks I have ever read. It should be required reading for all CSstudents and all programmers - it aims to cover the "50 algorithmsevery programmer should know". Below I discuss some of the mainreasons why I think the book is so good.

Unlike its main rival, "An introduction to algorithms" by Cormen,Leiserson, Rivest and Stein (CLRS), "Algorithms" contains actualsource code (written in a subset of Java). The importance of thiscannot be overstated: it means students can actually use thealgorithms to solve real problems. This enables a wealth ofinteresting and motivating applications --- from web search togenomics --- which are sprinkled throughout the book. (Source code anddata are available on the book's website.)

A natural worry with real code is that it will obscure the basicideas. However, by careful useful of abstract data types (classessuch as queues, bags, hash tables, trees, DAGs, etc), the authors havedone a masterful job at creating extremely concise and readableimplementations.

Using real code also forces one to address important implementationdetails that are easy to overlook. For example, it is well known thatmergesort requires auxiliary memory. In the CLRS pseudocode, theyallocate temporary storage space inside their merge routine. Inpractice it is much more efficient to allocate temporary storage spaceonce, and then pass this in as a pointer to the merge function (or letit be a private member of the mergesort class). Where else can youlearn such important tricks?

In addition to presenting the code, there are of course accompanyingEnglish explanations of the methods, which are very clear. One uniquething about "Algorithms" is that there are also many detailed workedexamples, illustrating the behavior of the algorithms while running onactual data (something that is hard to do unless you actuallyimplement all the algorithms!)

Another strength is that the book is that exemplifies good softwareengineering practice: write the API first, devise unit tests and/orimplement applications ("clients") that use the data structure oralgorithm, and only then worry about how to implement theAPI. Furthermore, multiple implementations of the API are usuallydiscussed, with different tradeoffs between simplicity, speed andmemory use.

For data structures, it is obviously natural to use classes, but theyalso adopt this approach for many algorithms, esp. graph processingones. This allows the algo to do pre-processing and to store internalstate, and then to provide a service to the caller. This is moregeneral than the standard stateless functional view of algorithms.

Each section of the book has a large number of exercises, classifiedinto "simple", "creative" and "experimental". Solutions to someexercises are available online.

An unusual feature of the book is that it contains a lot of empiricalalgorithmics, in addition to theory. That is, it shows actual runningtimes of different implementations on problems of different sizes, anduses this to supplement traditional theoretical analysis.

A small bonus relative to CLRS is that the book is slightly shorter(~ 1000 pages instead of 1300). In addition it is available in Kindleformat, which means one just has to carry around an ipad instead of aback-breaking tome. (The formatting of the Kindle edition is notperfect, however.)

Not surprisingly, the content of "Algorithms" overlaps a lot withCLRS. This is not obvious from the table of contents, which onlygives a high level view of the book. I have therefore created a moredetailed list of topics (see below).

The overall ordering and flow of the book is great: ideas (and code)that are introduced early on get re-used in several places later inthe book (e.g., heaps -> priority queues -> Prim's algo for minspanning trees). The topics also become more advanced. Consequently,the book is best read sequentially. It is worth reading the whole thing.

Kevin MurphyProf. of Computer ScienceUniversity of British Columbia

Below I give a detailed summary of the topics in the book,since this is not apparent from the table of contents.

Other reviews on this fine text are for older editions with pseudo code. Sedgewick and Wayne have completely revised this new Fourth Edition with plentiful Java scripts for a vast range of applications. A brand new website at Princeton is dedicated to this book and has visualizations, much more code, exercises, answers, bib links, full implementations of many problems, and a complete online summary and synopsis of the book.

The authors suggest this is for a second course in CS, but many serious students, whether independent or in undergrad, will find it useful for self teaching as well. In fact, the new website has self teaching resources if you are "going it alone" in your initial study of algorithms.

Algos cannot really be separated from their underlying data structures, and a serious new addition to this printing and edition is a much better backgrounder on the most up to date data structures, using hyper modern examples like Amazon and Google.

This book covers the basics, and is not an encyclopedia or reference book. It has a lot of detailed descriptions and visuals, and takes the time to be sure the student "gets" the point. In a way, it is in competition with Sedgewick's own Algorithms in C++, Parts 1-4: Fundamentals, Data Structure, Sorting, Searching (Pts. 1-4), which is now in its third edition, and more terse, advanced and encyclopedic. If you want a thorough understanding of the whole field, you probably need both if you're just starting out in the field.

If you're a beginning programmer, and want to get into the underlying logic of sorts, searches, graphs, strings and other fundamentals that drive modeling and the web, this is the place to start.

55 internautes sur 58 ont trouvé ce commentaire utile

My preferred algorithms text10 mai 2012

Par
Peter Drake
- Publié sur Amazon.com

Format: Relié

I've recently switched to this from the Cormen et al. book for the algorithms class I teach at Lewis & Clark College (a small liberal arts college in Portland, OR). The main difference is that this book focuses on practice, where Cormen focuses more on mathematical theory. This book seems a better fit for my students and my style of teaching.

Pros:* Reasonable scope for a semester. Teaching from this book for the first time, I covered four of the six large chapters, plus part of the fifth.* Explanations, diagrams, and examples are clear and concise.* The authors know their stuff and don't hesitate to explain it. For example, they know why a hash table index should be computed as(key.hashCode() & 0x7fffffff) % M(where M is the size of the table) instead ofMath.abs(key.hashCode()) % M* The slides provided on the book website are outstanding.* Examples in the book and on the slides come from a wide variety of applications. They demonstrate cases where using the efficient algorithm really matters.* One of the authors responds quickly to questions and errata. (As with any textbook, be sure to check the website and write the corrections into your copy.)

Cons:* The code does not always follow Java style conventions. For example, the authors will use non-private fields and one-letter, upper-case variable names. The many classes provided are all in the default package. It is not clear how much of this stems from deliberate decisions in the name of clarity and conciseness and how much from the authors not being "native" Java speakers.* Some of the proofs are a bit laconic ("immediate from inspection of the code").* The authors use an unusual ~ notation instead of the more widely-used Big-Theta/Big-O notation (although the latter is explained in passing). The ~ notation is more precise, as it does not omit the constant factor, but students may need additional practice with the standard notation.

Let me say first of all that I purchased the first printing of this text a little over a year ago. I actually like this book and believe that if you can identify the errors, it is a sufficiently instructive text.

However, between the first printing and the current third (3rd) printing, the authors have corrected over 105 errors in the book. Now, if this were a novel, it wouldn't be such a big deal. But people are using this book to learn material that will hopefully serve as a foundation for further learning. So not only does the error rate result in a waste of time but you are sometimes harming your learning process by absorbing information that is just plain wrong.

Please note that if you purchase the Kindle version of this book, your problems will compound even further since there is no quick way to annotate the many errors in the text. What this means is that before you can even begin learning the material from the book, you are first forced to sit with all 3 errata printing sheets, and manually insert comments throughout the Kindle text....for 105+ coding and textual errors! You are, in essence, re-authoring large swathes of the textbook before you can even use it!

Oh, but wait.... I forgot to mention that the Kindle version does not have PAGE NUMBERS?!! So, even with the errata in-hand (which reference errors by paper book page number), you are often unable to find the precise location of the error... particularly when the error is from a code example.

Having to correct dozens upon dozens of errors by hand for a book this size (with no page numbers!) before you can use it is INEXCUSABLE and borders on fraud. Authors and Amazon both seem very eager to chuck these electronic books at customers but from what I've seen, very little (if anything) is done by either party to ensure that electronic versions of these books receive errata updates. Either Amazon needs to address this, or authors need to work with Amazon to provide corrected, updated ePub versions of these texts to customers that have purchased them.

20 internautes sur 22 ont trouvé ce commentaire utile

Excellent for re-learning the basics23 août 2011

Par
Edward A. Averill
- Publié sur Amazon.com

Format: Format Kindle
Achat vérifié

After 20 years doing kernel level programming and device drivers, process control systems and other realtime work, most of my algorithm knowledge has vanished from disuse. So now I'm moving back into higher-level work and I was in trouble!

This books covers it all, and it's far more readable than the Knuth books I grew up on. I really appreciate the implementation examples as well, a few unclear spots became obvious when I looked at the code.

For anyone shifting gears and needing to freshen up their programming basics, I highly recommend this book!