- File Size: 2968 KB
- Print Length: 222 pages
- Simultaneous Device Usage: Unlimited
- Publisher: O'Reilly Media; 1 edition (July 7, 2017)
- Publication Date: July 7, 2017
- Sold by: Amazon.com Services LLC
- Language: English
- ASIN: B073SJBWKD
- Text-to-Speech: Enabled
- Word Wise: Not Enabled
- Lending: Not Enabled
- Amazon Best Sellers Rank: #588,627 Paid in Kindle Store (See Top 100 Paid in Kindle Store)
Think Data Structures: Algorithms and Information Retrieval in Java 1st Edition, Kindle Edition
Use the Amazon App to scan ISBNs and compare prices.
The Amazon Book Review
Book recommendations, author interviews, editors' picks, and more. Read it now
Enter your mobile number or email address below and we'll send you a link to download the free Kindle App. Then you can start reading Kindle books on your smartphone, tablet, or computer - no Kindle device required.
To get the free app, enter your mobile phone number.
Customers who bought this item also bought
From the Publisher
The Philosophy Behind the Book
Data structures and algorithms are among the most important inventions of the last 50 years, and they are fundamental tools software engineers need to know. But in my opinion, most of the books on these topics are too theoretical, too big, and too 'bottom up'.
Mathematical analysis of algorithms is based on simplifying assumptions that limit its usefulness in practice. Many presentations of this topic gloss over the simplifications and focus on the math. In this book I present the most practical subset of this material and omit or de-emphasize the rest.
Most books on these topics are at least 500 pages, and some are more than 1,000. By focusing on the topics I think are most useful for software engineers, I kept this book under 150 pages.
Too 'bottom up'
Many data structures books focus on how data structures work (the implementations), with less about how to use them (the interfaces). In this book, I go 'top down', starting with the interfaces. Readers learn to use the structures in the Java Collections Framework before getting into the details of how they work.
Finally, some books present this material out of context and without motivation: it’s just one damn data structure after another! I try to liven it up by organizing the topics around an application—web search—that uses data structures extensively, and is an interesting and important topic in its own right.
This application motivates some topics that are not usually covered in an introductory data structures class, including persistent data structures with Redis.
I have made difficult decisions about what to leave out, but I have made some compromises. I include a few topics that most readers will never use, but that they might be expected to know, possibly in a technical interview. For these topics, I present both the conventional wisdom as well as my reasons to be skeptical.
This book also presents basic aspects of software engineering practice, including version control and unit testing. Most chapters include an exercise that allows readers to apply what they have learned. Each exercise provides automated tests that check the solution. And for most exercises, I present my solution at the beginning of the next chapter.
About the Author
Allen B. Downey is a Professor of Computer Science at Olin College of Engineering. He has taught at Wellesley College, Colby College, and U.C. Berkeley. He has a Ph.D. in Computer Science from U.C. Berkeley and Master’s and Bachelor’s degrees from MIT.
Would you like to tell us about a lower price?
There was a problem filtering reviews right now. Please try again later.
Although the book is not thick, as some have said, it is written straight to the point, with dense information on each page. And the exercises have been great to force myself into getting into the details of the language. I feel this book is worth a semester or two of an intermediate Java college course.
Though the book is a thin, lightweight volume, it is packed with helpful information and code that illustrates the power under the hood of the ubiquitous Java. Any serious student, or professional practitioner, of Java would benefit from a reading of this book. It highlights such storage essentials as linked lists, arrays, hash maps, as well as binary trees, list traversals and Big O Notation. The latter refers to a code’s efficiency measured by how many calculations and processor work is required for each method, function or class in a program. Understanding and implementing the most efficient code will help programmers not simply have code that works, but that also is lean and mean resource wise.
I really enjoyed seeing not simply explanations of code but the code itself. Also, once a concept is explained it must be understood to make headway with the succeeding lessons. While I would recommend this book to anyone who wishes to learn how to write efficient, powerful Java code, it’s probably best suited for someone with at least a familiarity of Java, object oriented programming, and data structures (especially lists and hashes or maps).
I like how it's clearly written for someone who is beyond the beginner level when it comes to coding (no slog through basic data types like so many other coding books I've read), and is looking for a more formal discussion of data structures.
Writing is concise and clear, well-structured, and each section includes sample code and a basic exercise (not a lot of nuance here, though -- if you're looking for a bunch of exercises like what you'd find in a textbook, this isn't the book for you) to check your understanding. I think the author succeeds in his stated goal of covering a lot of material without getting too far into the weeds of theory, basic building blocks, etc.
My one complaint is that it's a bit slim (physically, it's not even 200 pages). It covers a lot and does a surprisingly good job of bringing depth to the discussion, but if you were to have difficulty with something it'd be hard to get yourself unstuck with this book.
This is not a reference book. This teaches basic computer science (great for a college student). Although we think of this as college education, many software developers use pre-built libraries without a solid comprehension of what they are doing or how. If a software developer takes the time to work through this book they will have a much better understanding of "Java Collections" (and the performance implications of using one data structure vs another).
Although this is a great book, I believe it could be better by including a summary and reference so that it would remain of value in future years after the student has studied the theory and design behind the provided collection classes in Java.
The author is an excellent writer.
I’m impressed enough with what I learned and how enjoyable the learning was, that after writing this review, I’m going to take a look at what other books Downey has to offer.