Algorithms (4th Edition) et plus d'un million d'autres livres sont disponibles pour le Kindle d'Amazon. En savoir plus

Identifiez-vous pour activer la commande 1-Click.
en essayant gratuitement Amazon Premium pendant 30 jours. Votre inscription aura lieu lors du passage de la commande. En savoir plus.
Plus de choix
Vous l'avez déjà ? Vendez votre exemplaire ici
Désolé, cet article n'est pas disponible en
Image non disponible pour la
couleur :
Image non disponible

Commencez à lire Algorithms (4th Edition) sur votre Kindle en moins d'une minute.

Vous n'avez pas encore de Kindle ? Achetez-le ici ou téléchargez une application de lecture gratuite.

Algorithms [Anglais] [Relié]

Robert Sedgewick , Kevin Wayne
4.0 étoiles sur 5  Voir tous les commentaires (1 commentaire client)
Prix : EUR 57,26 LIVRAISON GRATUITE En savoir plus.
o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o
Il ne reste plus que 10 exemplaire(s) en stock (d'autres exemplaires sont en cours d'acheminement).
Expédié et vendu par Amazon. Emballage cadeau disponible.
Voulez-vous le faire livrer le mercredi 23 avril ? Choisissez la livraison en 1 jour ouvré sur votre bon de commande. En savoir plus.


Prix Amazon Neuf à partir de Occasion à partir de
Format Kindle EUR 30,27  
Relié EUR 57,26  

Description de l'ouvrage

9 mars 2011

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, 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 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.

  • Offres spéciales et liens associés

    Produits fréquemment achetés ensemble

    Algorithms + Introduction to Algorithms 3e ISE + The Algorithm Design Manual
    Prix pour les trois: EUR 174,65

    Certains de ces articles seront expédiés plus tôt que les autres.

    Acheter les articles sélectionnés ensemble

    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).

    Détails sur le produit

    • Relié: 992 pages
    • Editeur : Addison Wesley; Édition : 4 (9 mars 2011)
    • Langue : Anglais
    • ISBN-10: 032157351X
    • ISBN-13: 978-0321573513
    • Dimensions du produit: 7,4 x 9,1 x 1,4 cm
    • Moyenne des commentaires client : 4.0 étoiles sur 5  Voir tous les commentaires (1 commentaire client)
    • Classement des meilleures ventes d'Amazon: 3.450 en Livres anglais et étrangers (Voir les 100 premiers en Livres anglais et étrangers)
    • Table des matières complète
    •  Souhaitez-vous compléter ou améliorer les informations sur ce produit ? Ou faire modifier les images?

    Dans ce livre (En savoir plus)
    Parcourir les pages échantillon
    Couverture | Copyright | Table des matières | Extrait | Index
    Rechercher dans ce livre:

    Quels sont les autres articles que les clients achètent après avoir regardé cet article?

    Commentaires en ligne 

    5 étoiles
    3 étoiles
    2 étoiles
    1 étoiles
    4.0 étoiles sur 5
    4.0 étoiles sur 5
    Commentaires client les plus utiles
    4.0 étoiles sur 5 Livre de référence 18 mars 2013
    Format:Relié|Achat authentifié par Amazon
    Il s'agit d'un ouvrage de référence, très complet. Il couvre de à peu près tous les sujets liés à l'algorithmique, propose des exercies pour entrer dans les détails.

    Je regrette jusqte qu'il soit moins drôle à lire que les ouvrages de la collection _Head fist on_ te que les exercices ne soient pas corrigés (il y a parfois des indications)
    Avez-vous trouvé ce commentaire utile ?
    Commentaires client les plus utiles sur (beta) 4.4 étoiles sur 5  57 commentaires
    248 internautes sur 257 ont trouvé ce commentaire utile 
    5.0 étoiles sur 5 Best algorithms textbook by far 22 mai 2011
    Par Kevin P. Murphy - Publié sur
    "Algorithms" (4th edn) by Robert Sedgewick and Kevin Wayne (published
    by Addison-Wesley in March 2011) is one of the best computer science
    books I have ever read. It should be required reading for all CS
    students and all programmers - it aims to cover the "50 algorithms
    every programmer should know". Below I discuss some of the main
    reasons 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 actual
    source code (written in a subset of Java). The importance of this
    cannot be overstated: it means students can actually use the
    algorithms to solve real problems. This enables a wealth of
    interesting and motivating applications --- from web search to
    genomics --- which are sprinkled throughout the book. (Source code and
    data are available on the book's website.)

    A natural worry with real code is that it will obscure the basic
    ideas. However, by careful useful of abstract data types (classes
    such as queues, bags, hash tables, trees, DAGs, etc), the authors have
    done a masterful job at creating extremely concise and readable

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

    In addition to presenting the code, there are of course accompanying
    English explanations of the methods, which are very clear. One unique
    thing about "Algorithms" is that there are also many detailed worked
    examples, illustrating the behavior of the algorithms while running on
    actual data (something that is hard to do unless you actually
    implement all the algorithms!)

    Another strength is that the book is that exemplifies good software
    engineering practice: write the API first, devise unit tests and/or
    implement applications ("clients") that use the data structure or
    algorithm, and only then worry about how to implement the
    API. Furthermore, multiple implementations of the API are usually
    discussed, with different tradeoffs between simplicity, speed and
    memory use.

    For data structures, it is obviously natural to use classes, but they
    also adopt this approach for many algorithms, esp. graph processing
    ones. This allows the algo to do pre-processing and to store internal
    state, and then to provide a service to the caller. This is more
    general than the standard stateless functional view of algorithms.

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

    An unusual feature of the book is that it contains a lot of empirical
    algorithmics, in addition to theory. That is, it shows actual running
    times of different implementations on problems of different sizes, and
    uses 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 Kindle
    format, which means one just has to carry around an ipad instead of a
    back-breaking tome. (The formatting of the Kindle edition is not
    perfect, however.)

    Not surprisingly, the content of "Algorithms" overlaps a lot with
    CLRS. This is not obvious from the table of contents, which only
    gives a high level view of the book. I have therefore created a more
    detailed 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 in
    the book (e.g., heaps -> priority queues -> Prim's algo for min
    spanning trees). The topics also become more advanced. Consequently,
    the book is best read sequentially. It is worth reading the whole thing.

    Kevin Murphy
    Prof. of Computer Science
    University 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.

    1. Fundamentals

    1.1 Basic programming model
    - Intro to Java
    - APIs and libraries
    - Binary search (recursion)

    1.2 Data abstraction
    - Basics of OOP
    - Avoiding 'wide' interfaces

    1.3 Bags, queues and stacks
    - Generics (known as templates in C++)
    - Iterators
    - Dijkstra's 2 stack algo for evaluating arithmetic expressions
    - Resizing arrays
    - Linked lists, pointers

    1.4 Analysis of algorithms
    - empirical algorithmics
    - big O notation ("linearithmic" as a term for O(N log N))
    - Randomized algorithms
    - Memory usage

    1.5 Case study: Union-find
    - Application: Dynamic connectivity (are p,q in same set?)
    - 3 implementations, culminating in the classic algorithm

    2. Sorting

    2.1 Elementary sorts
    - Selection sort
    - insertion sort
    - shell sort

    2.2 Mergesort
    - Top-down (recursive)
    - Proof that running time is N log N
    - Bottom-up
    - proof that lower bound for sorting requires N log N compares

    2.3 Quicksort
    - implementation
    - analysis
    - 3 way partitioning to speedup case of equal keys
    - lower bound for sorting is N*entropy of key distrib.

    2.4 Priority queues
    - heaps
    - priority queue,
    - top N items from a list using PQ
    - multiway merge of N sorted lists using indexed PQ
    - heapsort
    - comparison of sorting algos (speed, stability, in place, extra space)
    - order statistics/ median finding in O(N) time

    3. Searching

    3.1 Symbol tables (aka associative arrays)
    - ST vs ordered ST (where keys can be compared, so can get min and max)
    - count word frequencies in a large document
    - sequential search through unordered linked list
    - binary search through ordered array

    3.2 Binary search trees
    - BST property (parent is bigger than left child, smaller than right)
    - get and put implementation and analysis O(log N) time
    - find min, delete min, delete any node
    - inorder traversal

    3.3 Balanced search trees
    - 2-3 trees and red-black trees

    3.4 Hash tables
    - hash functions (eg modular hashing with Horner's rule)
    - separate chaining
    - linear probing

    3.5 Applications
    - Deduplication
    - Dictionary lookup
    - inverted index
    - file index
    - sparse matrix vector multipication

    4. Graphs

    4.1 Undirected graphs
    - Adjacency list representation
    - Depth first search
    - Breadth first search
    - single source shortest paths using bfs
    - connected components usign dfs
    - is G acyclic using dfs
    - is G bipartite using dfs
    - Kevin Bacon game (degrees of separation)

    4.2 Directed graphs
    - Multi-source reachability
    - Application to mark-sweep garbage collection
    - Cycle detection using dfs
    - topological sort (reverse of post order)
    - Kosaraju's algo for strongly connected components
    - Transitive closure (all pairs reachability)

    4.3 Min spanning trees of undirected weighted graphs
    - Prim's algo
    - Kruskal's algo

    4.4 Shortest paths in weighted digraphs
    - Dijkstra's algo
    - Shortest paths in weighted (possibly -ve) DAGs
    - Critical path method for scheduling
    - Shortest paths in weighted cyclic digraphs (Bellman-Ford and -ve cycle detection )
    - Application to arbitrage

    5. Strings

    5.1 String sorts
    - key indexed counting (radix sort)
    - least significant digit (LSD) sorting
    - most significant digit (MSD) sorting for variable length strings
    - 3-way string quicksort for repeated prefixes.

    5.2 Tries
    - R-way trie
    - longestPrefixOf
    - Ternary search tries (BST representation of R-way array)

    5.3 Substring search
    - brute force method
    - KMP method
    - Boyer-Moore method
    - Rabin-Karp fingerprint

    5.4 Regular expressions
    - Syntax of regexp
    - Check if string in language using non-deterministic finite automaton

    5.5 Data compression
    - Setup
    - Run-length encoding
    - Huffman compression
    - LZW compression (using tries)

    6. Context

    6.1 Event driven simulation using PQs

    6.2 B-trees

    6.3 Suffix arrays.
    - Find longest repeated substring.
    - Indexing a string (keyword in context)

    6.4 Ford-Fulkerson maxflow.
    - Find shortest augmenting path.
    - Maximum bipartite matching reduces to maxflow
    - maxflow and shortest paths reduce to linear programming

    6.5 NP completeness
    57 internautes sur 61 ont trouvé ce commentaire utile 
    5.0 étoiles sur 5 Updated Review For Fourth Edition 11 avril 2011
    Par Let's Compare Options - Publié sur
    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.
    26 internautes sur 26 ont trouvé ce commentaire utile 
    4.0 étoiles sur 5 My preferred algorithms text 10 mai 2012
    Par Peter Drake - Publié sur
    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.

    * 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 of
    Math.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.)

    * 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.
    19 internautes sur 21 ont trouvé ce commentaire utile 
    5.0 étoiles sur 5 Excellent for re-learning the basics 23 août 2011
    Par Edward A. Averill - Publié sur
    Format:Format Kindle|Achat authentifié par Amazon
    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!
    9 internautes sur 9 ont trouvé ce commentaire utile 
    5.0 étoiles sur 5 Excellent book 13 décembre 2011
    Par G. Kumar - Publié sur
    Format:Relié|Achat authentifié par Amazon
    This is a great book for anyone who knows java and wants to understand Algorithms. This covers lot of basic Data Structures and Algorithms written in Java with generics. I have read lot of data structure and algorithm books, but this one especially is for java programmers. Most of the algorithm books, only cover the basic pseudo code and leave the implementation, but this one gives a complete implementation of most of the famous algorithms. One more thing, I like particularly about the book is the supporting website, which has lot of test data and the author has provided test cases for each of the programs given in the book.

    This is not all, every chapter comes with lot of interesting compilation of exercises and creative problem, which will make your fundamentals clear. I think it is a must read for anyone who wants to really brush up on their data structure and algorithms fundamentals.

    Thanks for writing this great book.
    Ces commentaires ont-ils été utiles ?   Dites-le-nous
    Rechercher des commentaires
    Rechercher uniquement parmi les commentaires portant sur ce produit

    Discussions entre clients

    Le forum concernant ce produit
    Discussion Réponses Message le plus récent
    Pas de discussions pour l'instant

    Posez des questions, partagez votre opinion, gagnez en compréhension
    Démarrer une nouvelle discussion
    Première publication:
    Aller s'identifier

    Rechercher parmi les discussions des clients
    Rechercher dans toutes les discussions Amazon

    Rechercher des articles similaires par rubrique


    Souhaitez-vous compléter ou améliorer les informations sur ce produit ? Ou faire modifier les images?