Book Description
Algorithm Design introduces algorithms by looking at the real-world problems that motivate them. The book teaches a range of design and analysis techniques for problems that arise in computing applications. The text encourages an understanding of the algorithm design process and an appreciation of the role of algorithms in the broader field of computer science.
Customer Reviews:
slightly better than corman.......2007-06-11
best undergraduate handbook about algorithms i've seen so far.
examples are much less artificial than in cormen (introduction to algorithms)
great text.......2007-05-28
This is a great text as it teaches you the major techniques for designing efficient algortihms and how to solve real-life problems using algorithms rather than just presenting polished but inscrutable solutions to abstract problems
One of the better introduction algorithm books.......2006-12-10
With algorithms not a strength of mine (although I am a computer scientist student), I was quite happy that our professor switched to this book away from the MIT Press book. The first few chapters were exactly what I needed in order to finally get a grasp of key algorithm analysis and design concepts. As the book progressed to more difficult chapters, their explanations became less and less clear and seemed to rely more on text than on nice diagrams and graphics. A few complaints I have about the book: no mention of the Master Method in the dynamic programming chapter, NP-Complete explanation confusing, and no published errata that I could find. Although I have a few complaints about the book, it is one of the better books for being introduced to algorithms. It needs a little tuning now and then as some explanations are not so clear, but you'll find even more complicated explinations in other algorithm books.
Truly great book on algorithm design.......2006-03-18
I use this book in a course and I am immensely pleased with it. I must point out, though, that this is a very theoretical book. There is not much code and the authors use rather high-level psuedo code for what's there. However, it is great at explaining concepts and what the generic algorithms actually do. So it does its job quite brilliantly. If you need more code, you might want to pick up the Sedewick books, although the code could be better commented and organized if you asked me.
Extremely Wordy.......2005-09-15
This book is not concise; also the pseudocode syntax used in the book is annoying.
If you enjoy reading for the sake of reading then you might enjoy this book.There are better books out there by Knuth, Corman and Aho that cover the same topics as this one.
Book Description
Using the Java programming language, author Adam Drozdek highlights three important aspects of data structures and algorithms. First, the book places special emphasis on the connection between data structures and their algorithms, including an analysis of the algorithms' complexity. Second, the book presents data structures in the context of object-oriented program design, stressing the principle of information hiding in its treatment of encapsulation and decomposition. Finally, the book closely examines data structure implementation. Overall, this practical and theoretical book prepares students with a solid foundation in data structures for future courses and work in design implementation, testing, or maintenance of virtually any software system.
Customer Reviews:
Excellent book for data structures using java.......2000-10-05
I was looking for a latest edition of a book on data structures using Java. Lafore, Martin etc. are good texts but since collection API has introduced in jdk 1.2, those books seems to be obsolete. This book discusses new API and classes provided by java environment, so we need not to be bogged down by writing the unnecessary code. I feel this book is good for professionals in the industry as well as students of computer science. Algorithms are dealt with in detail with all the mathematical proofs involved, regarding efficiency and complexity. Various data structures are discussed with sufficient number of examples. Its a language specific book on data structures and algorithms, so if you are looking for a general book ar if you are working with any other language you will be dissappointed but surely a good book for java programming language.
Average customer rating:
- Depressing
- The gears on the cover dont even work!
- Anonymous
- Very unhelpful book
- I normally buy books because they contain information...
|
Practical Introduction to Data Structures and Algorithms, Java Edition
Clifford A. Shaffer
Manufacturer: Prentice Hall
ProductGroup: Book
Binding: Hardcover
 General
| Java
| Programming
| Computers & Internet
| Subjects
| Books
Beginner's Guides
| Java
| Programming
| Computers & Internet
| Subjects
| Books
General
| Algorithms
| Programming
| Computers & Internet
| Subjects
| Books
Data Structures
| Algorithms
| Programming
| Computers & Internet
| Subjects
| Books
General
| Introductory & Beginning
| Programming
| Computers & Internet
| Subjects
| Books
General
| Programming
| Computers & Internet
| Subjects
| Books
General
| Languages & Tools
| Programming
| Computers & Internet
| Subjects
| Books
General
| Computers & Internet
| Subjects
| Books
General
| Databases
| Computers & Internet
| Subjects
| Books
Java & Databases
| Databases
| Computers & Internet
| Subjects
| Books
Beginning & Introductory
| Databases
| Computers & Internet
| Subjects
| Books
General
| Software
| Computers & Internet
| Subjects
| Books
Mathematics
| Professional Science
| Professional & Technical
| Subjects
| Books
| Applied
| Chaos & Systems
| Geometry & Topology
| Mathematical Analysis
| Mathematical Physics
| Number Systems
| Pure Mathematics
| Transformations
| Trigonometry
Data Structures
| Computer Science & Information Systems
| New & Used Textbooks
| Stores
| Books
Programming Languages
| Computer Science & Information Systems
| New & Used Textbooks
| Stores
| Books
All Titles
| Qualifying Textbooks - Fall 2007
| Stores
| Books
Computers & Internet
| Qualifying Textbooks - Fall 2007
| Stores
| Books
Professional
| Qualifying Textbooks - Fall 2007
| Stores
| Books
ASIN: 0136609112 |
Book Description
The author, Cliff Shaffer provides a superior learning tool for those who desire more rigorous data structures and an algorithm analysis book utilizing Java. While the author covers most of the standard data structures, he concentrates on teaching the principles required to select or design a data structure that will best solve a problem. The emphasis is on data structures, and algorithm analysis, not teaching Java. Java is utilized strictly as a tool to illustrate data structures concepts and only the minimal, useful subset of Java is included.
Customer Reviews:
Depressing.......2007-07-14
This book gave me no hope for Analysis of Algorithm and Data Structures class, i have yet to find another book to assist me in this area. the book was so-what easy to read, but the explanation of the concepts is really horrible, dont waste ur money
The gears on the cover dont even work!.......2006-03-21
I have Dr Shaffer as my professor and he is just as boring in real life as his book. He has told us that some of the code segements are broken to make his students figure them out. DONT buy this book... It's not worth the money.
Anonymous.......2006-02-15
I would not reccomend this book for learning about data structures. With incomplete code and scampy sections on core area material, it seems to serve more as a workbook than anything else. In addition to this I find it to be poorly worded which has often caused me to overlook important details or have to read a sentence multiple times to understand what the author is saying. What saves this from being a one star product is the fact that if you do know the material, it can help you review structures but even then, the ackward wording still can slow down a quick read.
Very unhelpful book.......2005-11-29
Dr. Shaffer attempts to address the difficult topic of data structures and fails. Consistently he glosses over important points, or does not describe the implementation of data structures (the buffer pool, for example, is especially poor) adequately and leaves the hapless student confused and frustrated. For a computer scientist who already understands the subject this book may contain a few good points. Indeed, I was able to follow the sections where I had previous training, but when I studied material new to me, I was out of luck.
If you are unlucky enough to have a university that uses this text, consider trying to find a better book to get yourself an adequate understanding of this important subject, because Dr. Shaffer's text won't do that for you.
I normally buy books because they contain information..........2004-11-05
...but this was a mandatory book for my university's two-course Data Structures & Algorithms sequence that all computer scientists and computer engineers must take.
Coming in with a good deal of programming experience, I find that this book is not as clear or as complete as it could be. The sample code snippets throughout tend to be awkwardly implmented with obscure variable names and obtuse datatyping, and more often than not represent 'a' way of accomplishing a task rather than 'the best' way. Finding better ways of doing things is normally left for exercises at the end of the chapter; the answers are not included with the book.
Also, many significant details or comments are skimmed over or are ommitted from the text. Many important (and complex) observations are left as exercises - but again, the answers are not included, so there is no way of validating your answers.
Further, this book is targeted at the C++ language. It is obscene to discuss data structures and algorithms without mentioning the free, prepackaged, and optimized code of the C++ Standard Template Library. Indeed, this book and the code it includes would have benefitted from the ingenious architecture and software engineering behind the STL.
I really hope the campus bookstore will buy this one back when I'm done with it.
Book Description
* Provides a comprehensive introduction to data structures and algorithms, including their design, analysis, and implementation
* Each data structure is presented using ADTs and their respective implementations
* Helps provide an understanding of the wide spectrum of skills ranging from sound algorithm and data structure design to efficient implementation and coding of these designs in C++
Wiley Higher Education
Customer Reviews:
Meh..........2007-08-22
While I think that the other reviewers might be a little too harsh on this book, it definitely leaves a lot to be desired. It is not written very well at all (confusing language and sentence structure) and skims over important topics while going into too much detail on pointless ones. There is still a lot that can be learned from this book, but I would recommend checking out the alternatives.
Not a self-study tool.......2005-12-23
This book is very bad unless you have a good teacher to supplement. I used this book only to understand concepts that I wasn't clear on during the class lectures. In short, a horrible book if you want to self-teach but not too bad if you just want it as a supplement.
Worst Textbook I've Ever Used.......2005-12-05
This is honestly one of the worst if not the worst textbooks i have ever used. I am a computer science major at the University of Buffalo and was required to use this book for a course with the same name. This book is full of useless examples that demonstrate the easiest of concepts while there are huge holes in coverage of harder concepts in the book. The end of the chapter exercises are terrible and are not explained in the chapters preceding them. Stay away from this text.
I would give it 0 stars if I could.......2005-07-24
This is a very frustrating book. The writing is horrible, there are no sample exercises in the book so when you go to do an assignment from the exercises, there is no example of how to approach the problem. There is a "hint database" on their online website that gives you one line of how to approach a problem, but even that is hit or miss and can make things even more confusing. In short, I didn't learn any more about data structures than I didn't already know from my previous courses.
If you are looking for a book that explains things in a much better format, look for the Data Structures and Algorithm Analysis in C++ by Weiss. It explains things so much better.
Don't waste your money on this, and if you have to buy it for a class, definitely buy used. I'm selling mine back to the school bookstore!!
The worst DSA book ever written!.......2005-03-02
This is one of the dozens of Data Structures and Algorithms books in the market and till now the worst I've ever seen. I have taken two DSA courses in my undergrad years, and now as a grad, I'm TAing that course.
The theoretical treatment of the book is superficial and too childish. Yet, there's too little practical value. They discuss the unnecessary linked list implementations of trees which is quite confusing for students. I am also amazed that they do not mention finding or removing an element in a BST. And, more importantly there's too little discussion of graphs.
I don't understand those professors trying to bog down students with useless details and complicated C++ codes. Rather, they should give the intuition and the theory behind the data structures and algorithms. Weiss' book is much better than this one. But, even that is obsessed with doing tricky things with C++.
Anyway, to sum up: This book is a garbage. Stay away unless it's required for the course you're taking in case you may need to do homeworks and such.
Book Description
Using the C++ programming language, author Adam Drozdek highlights three important aspects of data structures and algorithms. First, the book places special emphasis on the connection between data structures and their algorithms, including an analysis of the algorithms' complexity. Second, the book presents data structures in the context of object-oriented program design, stressing the principle of information hiding in its treatment of encapsulation and decomposition. Finally, the book closely examines data structure implementation. Overall, this practical and theoretical book prepares students with a solid foundation in data structures for future courses and work in design implementation, testing, or maintenance of virtually any software system.
Customer Reviews:
Absolutely the best C++ DS&A book.......2006-08-30
On my bookshelf right now I have 13 books on DS&A using C++. Every time I am in need of a new type of data structure or algorithm, and quickly scan through each of them to determine which seem to have the most relevant information, and also which have useable source-code. Drozdek's book is almost always the book I end up selecting to learn a new topic.
Without a doubt, Drozdek's DS&A book is the most complete and well-written of its kind. It includes a chapter of graphs, which many books surprisingly omit. Also, as of the 3rd edition, it includes a chapter on string matching. As far as I know, this is the *only* C++ DS&A book to dive into this subject.
Surprisingly (because of such a broad-scoped book), the material presented in the string matching chapter is modern and incredibly useful. I found the coverage of suffix tries to be excellent. According to Professor Drozdek (via email correspondence), this chapter is actually a compressed version of what was to be an entire C++ book on string matching. Apparently no publisher would touch such a 'specialized' book. How short-sighted of them!
I work in a research-intensive company focused on developing cutting-edge algorithms to solve difficult modern problems. We do the majority of our coding in C++, which is what originally attracted me to Drozdek's book. Since then, I have referred several colleagues to this book, all of which now use it regularly and are loving it.
My only complaint about this book is that it doesn't discuss primality or random-number generation at all. So many algorithms rely heavily on one or both of these, so I find it strange that this book (and most others) completely ignore them.
As for the reviewer who negatively commented "worst written educational book I have ever read", this person obviously bought Drozdek's book expecting to learn C++ and not DS&A. If you're looking to learn C++, I recommend "C++ Primer Plus (5th Edition)" by Stephen Prata (ISBN: 0672326973). Despite its awkward title and oft-maligned publisher, it really is an excellent book for learning C++ (and also as a reference for an experienced programmer).
Depending on your needs, you might look into supplementing Drozdek's book with Robert Sedgewick's books 'Algorithms in C++'. His books do not go as deep as Drozdek does, but he provides an enormous number of fully implemented algorithms that don't exist in any other C++ DS&A book. Be sure to get the 3rd edition; it is much improved over the 2nd.
Here's a complete TOC of Drozdek's book (3rd edition):
Table of Contents
1. Object-Oriented Programming Using C++
2. Complexity Analysis
3. Linked Lists
4. Stacks and Queues
5. Recursion
6. Binary Trees
7. Multiway Trees
8. Graphs
9. Sorting
10. Hashing
11. Data Compression
12. Memory Management
13. String Matching
Appendices
A: Computing BIG-O
B: Algorithms in the Standard Template Library
C: NP-Completeness
Clear, easy to follow explanations and practical illustrations in C++.......2006-08-28
Although I have bought this book for its C++ emphasis for DSA, I have found it very good at teaching DSA itself. It has very clear explanations, well chosen examples, and depth enough coverage with along clear and easy to understand code illustrations in C++. The book teaches the topics in an incremental manner by making connections among different related DS and algorithms, which are helpful in understanding the theory.
Its layout for teaching a topic consists of three parts: 1) Introducing the data structure or algorithms with an informal language. It relates it with other similar ones, and explains the differences. 2) It shows C++ implementation (it does not have C++ codes for all DS and A's; however, I think what it has is enough for such a book) and explanations, even some alternative implementations. 3) It has complexity analysis for the algorithm, and any drawbacks. Drozdek has concluded the each chapter with an case study and provides full implementation in C++.
I have extensively studied Cormen's book of "Introduction to Algorithms", which I really like, however, this book is much better at teaching the fundamentals of the DSA topics and has better figures although Cormen's book is more in-depth and has more topics covered, and more academic. If you are looking at more implementation of the DSA with some in-depth theory, Drozdek's book is more useful. If you need more academic study on DSA, Cormen's book would be more helpful (in fact, I suggest both of them).
Another thing I like in this book is its chapter for Memory Management. Although this is an OS topic, it covers it since many DSA requires dynamic memory allocations, and I think it is good at teaching the basics of data structures and algorithms used in memory management.
In short, I strongly suggest this book to programmers who wants to understand DSA and CS students, and also the ones want to have a reference book. I think C++ codes are extra for those who are programming in C++.
Contrary to prior belief.......2006-01-25
I had Weiss's book on dsa in c++, and this book surpasses it in terms of clarity and accuracy (both books are comparable in breadth and depth). The previous reviewer fails to notice that this book is about data structures and algorithms, and not C++ (although having a C++ book next to this one couldn't hurt either). So think of this book as a much better version of Weiss's book.
worst written educational book I have ever read.......2006-01-21
The book is written at a level way above the average student. After having 2 years of C++ and breezing through them, this book explains little and asks a lot at the end. May be a good book for people using C++ daily in the work environment, but I have actually bought a seperate book to learn from rather than this one.
Clear and concise, good examples, not too heavy.......2002-12-22
This book was used in my Junior-level Advanced Data Structures and Algorithms course. This was the first semester that we used this book and people seemed to like it. Apparently, the old textbook for my class had too much code and not enough explaination. The author presents most of the algorithms in pseudo-code as apposed to a full implementation, but the code exaples are plentiful.
This book will get you learning advanced topics in data structures and algorithms in no time. I learned a lot from this book, and read the first 10 chapters. The scope of topics discussed is large and is presented in top-down fashion. There were even several topic areas that we didn't have time to spend on, like self-organizing lists, networks, self-balancing trees, data compression, and garbage collection.
I was tempted to only give 4 stars in this review because there are a painful number of typos/errors in this text. I was usually able to see beyond the errors, but it made it more difficult than it should have been. A new edition should seriously address this.
A full grasp of C++ is necessary to read through this book, but that should be given when studying general data structures and algorithms. A C++ reference will be very helpful when doing programming assignments because this is not a book on the language.
This book will probably always be on my shelf. Even though all of the code is in C++, which is not eternal, it does not rely heavily on the language. Most of the algorithms are given in pseudo-code, and the data structures are developed independent of the laugage choice. I still plan on reading the sections that we skipped in class. I would recommend this text to any computer science student.
Customer Reviews:
I'm fed up with these books.......2006-03-22
I bought these two book for one reason: to get help implementing algorithms. Since there is lot of code in these books, I thought this would be a good pick. I was wrong. The author is consistently leaving out details vital to understanding the code. He also makes a big deal about abstract data types. This is gloriously of the case. If the readers are supposed to understand the code, transperency would be a more intelligent goal for the author. There are no comments in the code what so ever (yes, this is actually true, not even in the on-line code). The on-line code to this book is a total mess. You would be able to implement all the algorithms from scratch in less time than it would take you to try an piece together the code the author has left for you.
The pity is that there are very few other algorithm books that have real code. Demand a new edition from the author and don't by this one unless you can avoid it.
Best of the bunch.......2004-08-19
I had to teach this subject and this book seemed the best of the bunch though still not ideal. Why does the author have to use meaningless variable names (i,j,k), do comments make the code run more slowly. My main criticism is the examples and I would recommend the author use professional coding practices, comment the code, use meaningful variable names and structure it for readability. Else recommended for this subject
The best book for beginners.......2002-07-26
Sedgewick's 'Algorithms in C' is undeniably the best book for beginners studying about algorithms and data structures. The text is clear, lucid, and the programming examples are very well documented. The exercises and problems stimulate thoughts and help in developing a better understanding of the subject. All the key aspects of the subject are sufficiently addressed, and discussed in the best possible way. It's the code in the book that I love the most, it can be compiled on almost any compiler without almost any change being made to it. I would strongly recommend this book as a textbook to all beginners embarking on a study of data structures and algorithms.
Lucid thought process - excellent coverage & examples.......2002-07-25
I have quite a few books on algorithms and C programming, and this probably takes the cake. Sedgewick writes clearer than perhaps anyone on the subject. The book is filled to the gills with tiny 20 line (complete) programs that do amazing things - such as the program to compute all the prime numbers less than N (provided as input). These examples are typically given to illustrate some point (such as using dynamic array allocation for storing which numbers are prime) - but the short, concise algorithms given in the examples are learning aids as well (i.e. - I didn't know you could calculate a list of primes so easily, and I can probably take this knowledge and use it somewhere else). The reader is challenged to alter the examples (instead of using an array to store which numbers are prime, use a bitmap). Because the examples are small, compact, and easy to read, this provokes one to actually sit down and try and play with them. In contrast, I also have the Algorithms In C O'Reilley book by Kyle Loudon and after reading the Sedgewick title, I'm throwing that away. That book spends 1/3 of the chapter describing the algorithms, and then spends the rest of it in user-interface code examples. Of course, all the user interfaces for all the examples in the book are pretty much the same, so the whole book is filled with redundant useless code. More analysis, less filler, please. As Sedgewick was a student of Knuth, I consider his books as the practical guide to Knuth's tomes (which seem out of date - do we really need algorithm analysis on external storage these days??), which are filled with rigorous mathematical analysis. I highly recommend this book(s) -- actually there are two, with the second volume covering graphs. I wish my University had used these texts in programming / algorithm analysis courses. I really don't have any negative commentary -- other than the nitpick that his coding style is very compact and skeletal --> main(){ for(...) do_something;} However, since the examples are so small, it hardly matters.
Book Description
Robert Sedgewick has thoroughly rewritten and substantially expanded andupdated his popular work to provide current and comprehensive coverage ofimportant algorithms and data structures. Christopher Van Wyk and Sedgewickhave developed new C++ implementations that both express the methods in aconcise and direct manner, and also provide programmers with the practicalmeans to test them on real applications. Many new algorithms are presented, and the explanations of each algorithmare much more detailed than in previous editions. A new text design anddetailed, innovative figures, with accompanying commentary, greatly enhancethe presentation. The third edition retains the successful blend of theory andpractice that has made Sedgewick's work an invaluable resource for more than250,000 programmers! This particular book, Parts 1-4, represents the essential first half of Sedgewick'scomplete work. It provides extensive coverage of fundamental data structuresand algorithms for sorting, searching, and related applications. Although thesubstance of the book applies to programming in any language, theimplementations by Van Wyk and Sedgewick also exploit the natural matchbetween C++ classes and ADT implementations. Highlights
Expanded coverage of arrays, linked lists, strings, trees, and other basic
data structures Greater emphasis on abstract data types (ADTs), modular programming, object-oriented programming, and C++ classes than in previous editions
Over 100 algorithms for sorting, selection, priority queue ADT implementations, and symbol table ADT (searching) implementations
New implementations of binomial queues, multiway radix sorting, randomized BSTs, splay trees, skip lists, multiway tries, B trees, extendible hashing, and much more Increased quantitative information about the algorithms, giving you a
basis for comparing them Over 1000 new exercises to help you learn the properties of algorithms Whether you are learning the algorithms for the first time or wish to have up-to-date reference material that incorporates new programming styles with classic and new algorithms, you will find a wealth of useful information in this book.
Customer Reviews:
I wish I had this when I was in college.......2007-07-24
This book puts most of my college textbooks to shame. Not that they were bad, but really this is a step above. Sedgewick is a master at distilling difficult concepts into just a few lines of code, and then talking the reader through all of the implications of any design decision. For a professional who needs to reacquaint himself with the basic principles of algorithms, and needs some simple code to get started on coding a solution, this cannot be beat. While I am not in school anymore, I feel this can also be a great supplemental text for any serious Computer Science university student, although it's possible that the focus on C++ implementations may not be ideal for curricula where Java is the mainstay.
One of the factors that I did not see mentioned in other reviews is that Sedgewick's visual representations of the algorithms are phenomenal. In older algorithms textbooks, these have always been represented by small diagrams--if any--that show what happens when an algorithm is used to attack a small problem (say, a linked list with 10 nodes). This text shows a visual representation of those small cases, but then goes the extra mile to show visual representations of the same algorithm when scaled to a variety of massive inputs. These representations are a great tool for comparing the scalability of various algorithmic approaches against one another.
Crunch Time.......2002-03-31
When you are ready to take the bold step into algorithms, this book is a great second step. I say second step because I think it helps if you read "teach yourself algorithms in 21 days" before this book.
This book deals with a good number of algorithms and does not shy away from reasonable analysis. The book helped a lot when I was having problems with putting a good harsh function together.
The chapter on recursion is also very good too.
In order to write decent code you have to know about this difficult/painful subject and this book takes some of that pain away.
Good documentation of basic data structures.......2001-10-27
I purchased this book to refresh my memory on data structures with templates. It is well written in most spots and provides excellent examples. I would recommend this book to any intermediate c++ programmer who wishes to learn/relearn advanced data structures such as Linked Lists,Hash,QuickSort,etc....
C++ Algorithms.......2001-10-22
This book is full of great information on C++ algorithms. There are many excellent examples, and the author presents the gammit as far as topics. They really open up your mind to possibilities. The reading at times is rough going, though (very dry). Sample code or examples to download may be found at the publisher's website instead of the one printed in the book.
Excellent, Exhaustive (but not rigorous).......2001-10-21
If you're looking for an exhaustive, upto-date reference/textbook for
fundamental, searching and sorting algorithms, then this is one of
the very best available.
Sedgewick has split his popular book into two volumes, with Graph
algorithms being hifted to the second volume. Moreover, many advanced
topics like computational geometry, fft, number theoretic algorithms
etc, which were introduced in the previous edition, seem to be missing
now - so the breadth of coverage seems to have reduced, which is a pity.
However, the depth has increased instead - i doubt that even Knuth
covers more sorting algorithms ! In particular, there are several
recent algorithms and data structures which are treated in greater
detail here than by Knuth. Of course, Knuth analyses all the
algorithms he presents in rigorous and exhaustive detail, which
this book doesn't.
Moreover, the book has many new algorithms and presents the state of the
art in sorting and searching algorithms, giving it a distinct advantage
over the older books.
Sedgewick makes it very clear in the preface that the emphasis is on
the practical importance of the algorithms, so esoteric algorithms which
are important 'only in theory' may find no mention. Also the emphasis is
more on the design of algorithms than on their analysis.
The number of (exercise!!) problems has multiplied manifold in this edition
to become more than most competing textbooks. Problems are graded by
difficulty level to help you choose the ones relevant to your needs.
The exposition is clear and authoritative - Prof. Sedgewick is a leading
authority in the field of algorithms and a student of Donald Knuth.
He has a gift for making difficult concepts seem simple, and the great
illustrations in the book go a long way in explaining the behaviour of
the algorithms.
For the practising professional, this is an ideal reference, since it'll
help you select the best algorithm for your task without bogging you
down with heavy mathematics.
The reasearcher, on the other hand, may benefit by gaining unique insights
from a master of the area, while using other books for the detailed
analysis of algorithms, including prehaps Sedgewick's own book on the
analysis of algorithms(with Flajolet).
A caveat - the code may not be 'ready to run'. It's better not to rely
on this book to provide you with usable code - if that is what you want,
perhaps the books by Drozdek/Weiss/Heileman/Rowe might be better choices.
If you want C code rather than C++, then the C version of this book is
a good choice, since the code provided is of 'K & R' class and therefore
a delight to read.
Of course, if you're looking for a language independent coverage,
then 'Introduction to algorithms' by Cormen,Leiserson and Rivest is
possibly the best book which combines rigor with comprehensive coverage
of the most important algorithms. Look out for the newly released
second edition.
And if you want a more rigorous and equally exhaustive coverage of
sorting and searching, go for Knuth vol.3 - still the authoritative
reference, though it may require more hard work on the reader's part.
Otherwise, invest in this and you won't be disappointed.
Book Description
Data Structures and Algorithms in Java, Second Edition is designed to be easy to read and understand although the topic itself is complicated. Algorithms are the procedures that software programs use to manipulate data structures. Besides clear and simple example programs, the author includes a workshop as a small demonstration program executable on a Web browser. The programs demonstrate in graphical form what data structures look like and how they operate. In the second edition, the program is rewritten to improve operation and clarify the algorithms, the example programs are revised to work with the latest version of the Java JDK, and questions and exercises will be added at the end of each chapter making the book more useful to readers.
Download Description
Data Structures and Algorithms in Java, Second Edition is designed to be easy to read and understand although the topic itself is complicated. Algorithms are the procedures that software programs use to manipulate data structures. Besides clear and simple example programs, the author includes a workshop as a small demonstration program executable on a Web browser. The programs demonstrate in graphical form what data structures look like and how they operate. In the second edition, the program is rewritten to improve operation and clarify the algorithms, the example programs are revised to work with the latest version of the Java JDK, and questions and exercises will be added at the end of each chapter making the book more useful to readers.
Customer Reviews:
Good book for beginners BUT...........2007-01-17
I found this book to be very useful to learn data structures even with minimum Java knowledge. The chapters are well written so that it's very easy to understand the matter quickly.
BUT: Many of the source codes are incomplete or even missing! I have no problem with typing source code from the book but if the author shows source codes where important methods are missing (delete method on 2-3-4 Trees) or even whole data structures are only explained in theory (Red Black Trees) without any piece of source code and at the end of the chapter tells us to find such stuff out by ourself I'm starting to wonder what do I paid the 45$ for?! I don't need a book for telling me to try to find out stuff by myself! I'm buying a book exactly for the matter to tell me the things that I can't find out by myself!
No Java source codes available.......2006-10-08
One major problem with this book, particularly for beginners like me, is that the Java source codes are UNAVAILABLE. To try the code in the book, you have to type, which obviously is a tremendous wate of time and frustration. There are no alternative. Hope that the author may immediately act to resolve the issue. Considering the amount of frustration that I have gone through, even two stars are a generous rating for this book. Now I am looking for other data structure books which are rated good and provide source codes.
Best book to read about data structures and algorithms with little to no knowledge about them.......2006-08-10
This book for people who do know little to nothing about data structures and algorithms in a programming language. If you do not know much about data structures and algorithms then the mere thought of learning them on your own can make you afraid of them. On top of that there aren't many books written in Java that talk about them. But this book makes learning it as easy as having an ice cream. As the title suggests, all algorithms and code examples have been written in Java. If you laready know Java then it is very easy to understand the chapters and the examples.
The chapters start off with good introduction to a topic and then as it progresses, the code is shown. After that the code is explained as well. The code that used in each chapter is further explained using a workshop applet. For example, in the chapter in Linked Lists, if you run the workshop applet you can actually see how the nodes are being added and deleted from the list. This makes learning even simpler.
Algorithmic complexities are also explained clearly and concisely without going too deep into the mathematics part of it.
This book is a good reference manual for people who already know these concepts and wanna keep something handy to browse through it.
But primarily, I would recommend this book for people with knowledge in Java and little to no knowledge in data structures and algorithms.
Applet Source Files.......2005-03-15
I just purchased the book. I download
the files of this book from the publisher website. I notice
that applet demonstration workshops in the book only contain
class files and html files. I just wonder if the original
java source files for applet workshops can also be posted in the
publisher website, which will facilitate the learning process,
since readers can modify the soruce files, and to see how the
applet results might change.
Very good book.......2005-02-16
Very good book. Very clear explanations with minimal use of jargons. The visual workshops is a very good aid. Definitely recommended!
Customer Reviews:
An okay book!.......2007-05-23
It is just an okay book, not extraordinary in any way. Especially, this is certainly not for the novice in this topic, i.e., it is certainly not a good introductory book. So if you are new to data structures and algorithms, stay away from this book, go for some good introductory book.
For the advanced readers, it is an okay book. Better books are available, e.g., books by Cormen et al. and Robert Sedgewick.
The book is written in a way not very intersting or engaging. The algorithms are not explained in detail. Often things are left unexplained or assumed that the reader already knows it. Algorithms are presented in pseudocode, which causes problems especially for the readers familiar to some particular programming language.
Excellent Book.......2007-05-17
This book explains very clearly the subjects of data structures and algorithms. Its in-depth coverage is very intuitive and easy to follow unlike other literature that is often tedious or esoteric.
The only complaint I have is the choice of the programming language. Pascal is a language of the past. A new edition using C will make this book simply a gem.
A JEWEL.......2006-01-15
Perfect book. Nice and small. You can buy it cheap too, it's old. But it's full of the meat and potatoes, no fluffy Java source code. Sure, it uses Pascal, but it's not that hard to understand Pascal code even if you never programmed in Pascal (me neither). What matters is the discussions behind the scenes. It covers the whole range of what you should know and it's concise. They don't write books like this anymore.
A classic text book on Data Structures........2005-05-19
I believe two books make a classic collection in data structures - one was the data structures book by sartaj sahni (his first edition book many years ago - I haven't looked at his recent books). That was the book I had to study when I was an undergrad student. Now I was entrusted with the task of teaching Data Structures and after looking at several books, this is the one I chose (may be because it comes most close to the style of teaching using psuedo-pascal that I grew up with).
I believe psuedo languages are the best way to learn concepts of any computer science area without getting bogged down in the nitty gritty of a language's syntax and semantics. I found the problems at the end of the chapters to be thoughtful and not extremely hard for undergraduate students. This book also goes into brief mathematical aspects of analysing the complexity of algorithms where necessary. The mathematical analysis is usually the part that most undergrad students moan and groan about, but they better get used to it IMO, if they wish to elevate themselves from the ranks of "a programmer" to an software / algorithm designer.
I have to agree that this book can be extremely hard for the weaker students in the class who have never had any programming or basic college algebra exposure. For all others, this book should be great.
The best introduction to the field - a pleasure to read.......2002-02-10
A textbook by Aho/Hopcroft/Ullman is sort of a guarantee of quality -
and this one is no exception. These people are among the greatest
researchers and teachers in Computer Science, and this book is a
great opportunity to 'learn from the masters'.
As an introduction to the fascinating field of Data Structures and
Algorithms, this is perhaps the best textbook you'll find out there.
Starting with the basics, the authors develop the concepts in a
natural manner. Array, lists and stacks soon give way to binary trees,
heaps and then more advanced data structures. All data structures are
introduced with proper motivation in terms of the kind of problems
that they are useful in solving.
The basic algorithms in searching, sorting, and graphs are then presented
in detail, followed by a chapter on algorithm analysis techniques, and
one on design paradigms such as dynamic programming, backtracking, divide
and conquer, greedy approach, and local search. The book ends with chapters
data structures and algorithms for external storage and memory management.
This is a textbook, and therefore you can expect a fair amount of maths
in the analysis of algorithms, without which you can only do hand-waving.
All algorithms are explained, with detailed examples and illustrations -
this is one of the easiest books to follow in theoretical computer science.
All algorithms are presented in pseudocode, which makes it easier to
understand things at an abtract level without getting bogged down in
language specific technical details, and the pseudocode is very clear
and concise, making it an easy task to adapt it to any given language.
An additional plus-point is its size - weighing in at less than 450
pages, this is a 'backpack friendly' book which you can easily carry
around, unlike many others on the subject.
The only caveat is that the book is almost 20 years old, so you won't
find the more recent topics like red-black trees, skip lists etc.
I'd suggest using this book for an introduction to the basics, with the
book by Cormen et al (if you want the maths) or Sedgewick (if you don't
want the maths) as excellent supplements as well as advanced references.
I must confess to having a weak spot for this book, since it introduced
me to algorithms and i fell in love with the subject. However, i think
most people who've read it would agree that it is a classic among Computer
Science textbooks which has stood the test of time.
Book Description
Michael Goodrich and Roberto Tamassia, authors of the successful, Data Structures and Algorithms in Java, 2/e, have written Algorithm Engineering, a text designed to provide a comprehensive introduction to the design, implementation and analysis of computer algorithms and data structures from a modern perspective. This book offers theoretical analysis techniques as well as algorithmic design patterns and experimental methods for the engineering of algorithms.
Market: Computer Scientists; Programmers.
Customer Reviews:
Egh! Good science bad english.......2006-10-25
I'm a grad. student using this book, and understanding the written language amounts to same sensation as you would get during root canal. While examples are concise, pseudo-code is excellent, despite the few actual examples in Java, it covers vast range of topics rather well. But for crying out loud, hire an editor for the next edition that will break down paragraph long sentences and introduce some readability to the text! For that reason I tend to gravitate to my undergrad books for my current studies.
An excellent textbook.......2005-03-15
After researching a variety of alternatives, I settled upon using Algorithm Design by Goodrich and Tamassia to teach a junior-level algorithms course and the experience has been quite positive.
While instructor material grows a bit sparse in the last half or third of the book, it's still quite useful. The slides are great and many of the problems have solutions available. Moreover, the solutions tend to be correct (I've only found two mistakes, which may be covered in the up-to-date errata).
The layout of the sections and chapters is quite natural and easy to adapt to your own course, although the last third of the book is essentially an assortment of topics that didn't fit in anywhere else. I would advise bringing some of those topics in to the course early on as diversions from the main material, which admittedly can get a little dry.
For the most part, the book is well written with interesting and adequete end of chapter problems. There are relatively few Java-based examples, but we skipped over them anyhow -- the pseudo-code is quite acceptable. Goodrich and Tamassia give a broad survey of topics, but cover them in enough depth and with enough rigor for an undergraduate course where CLR(S) would be overkill. I recommend it.
A good introduction text to algorithms.......2002-12-18
I would not consider this book as the ultimate book for algorithms as the title suggests. :-) However, it is a very readable book, and filled with brief, but concise observations. Do not get me wrong. This book also has very detailed explanations of fundamental data structures and algorithms.
Also, the best part of the book is that it lists good references for further readings. I loved this book. I would suggest this book to others. Math hints at the back of the books are useful, and some excercises are quite brain challenging. I think it is a great practice for students, but it is not so fun when students get it for assignments. :-)
Good Fundamentals.......2002-07-01
There are many good books with this title or similar ones. This is probably one of the better ones for your bookshelf and for use in academia. The examples are written in Java (a current language) and they are easy to read. The presentation is clean and illustrative. The authors have a good track record for expertise and papers published, and you get the sense that it is more real-world than most similar books.
Books:
- Allyn & Bacon Guide to Writing, Brief Edition, The (4th Edition) (MyCompLab Series)
- Applying UML and Patterns: An Introduction to Object-Oriented Analysis and Design and Iterative Development (3rd Edition)
- Basic English Grammar, Third Edition (Full Student Book with Audio CD and Answer Key)
- Basic Italian: Learn to Speak and Understand Italian with Pimsleur Language Programs (Simon & Schuster's Pimsleur)
- Beginner's French Reader
- Berlitz French Phrase Book (Berlitz Phrase Books)
- Berlitz German Phrase Book (Berlitz Phrase Book)
- Blood Fever (The Young James Bond, Book 2)
- Cassell's Contemporary Spanish: A Handbook of Grammar, Current Usage, and Word Power
- CINEMA 4D 10 Workshop
Books Index
Books Home
Recommended Books
- Me to We: Finding Meaning in a Material World
- History: Fiction or Science
- Asymmetric Information in Financial Markets: Introduction and Applications
- Don't Look Now: A Novel
- Fee-Only Financial Planning: How to Make It Work for You
- How Porcupines Make Love III: Readers, Texts, Cultures in the Response-Based Literature Classroom
- History: Fiction or Science
- Quick Reference to Iras, 2002
- Environmental and Natural Resource Economics: A Contemporary Approach
- H.M. Pulham, Esquire
Introduction to Algorithms
Probability and Computing: Randomized Algorithms and Probabilistic Analysis
Introduction to the Design and Analysis of Algorithms (2nd Edition)
Algorithms
Approximation Algorithms
