• Updated and revised to include the use of Java for programming examples, this book provides readers with a thorough and clear introduction to the difficult concept of recursion
• Uses a broad range of examples to illustrate the principles used in recursion and how to apply them to programming
• Features imaginative examples along with various exercises and their solutions

• Updated and revised to include the use of Java for programming examples, this book provides readers with a thorough and clear introduction to the difficult concept of recursion
• Uses a broad range of examples to illustrate the principles used in recursion and how to apply them to programming
• Features imaginative examples along with various exercises and their solutions

To understand recursion, you first have to understand recursion.

If reading the statement above gives you a mild headache, you’re not alone. Recursion is not only one of the most important concepts in the computer science curriculum; it’s also one of the most challenging to understand.

Now in Thinking Recursively with Java, author and award-winning teacher Eric Roberts, demystifies this often-frustrating topic by equipping you with effective problem-solving strategies that enable you to "think recursively.” Based on Roberts’s now classic text, Thinking Recursively (Wiley 1986), this 20th anniversary edition now uses Java, making recursion even more relevant to today’s students. 

Features

• Learn how to apply recursive techniques, so you can succeed in advanced CS courses that depend on the use of recursive strategies.
• The book’s ample selection of examples and exercises (more than the typical general text) enables you to work through as many problems as you need to master recursive techniques.
• Examples now use Java, making the book compatible with modern approaches to introductory computer science.
• Expanded chapters on recursive backtracking and graphical applications support interesting examples enabled by current technology.
• The code in the book is fully compatible with the libraries produced by the ACM Java Task Force, as well as with other standard approaches to teaching Java.

About the Author

Eric Roberts is Professor of Computer Science and John and Cynthia Gunn University Fellow in Undergraduate Education at Stanford University. He is widely recognized as an expert teacher and has won numerous teaching awards at Stanford. He was the principal author of the ACM/IEEE-CS report on Computing Curricula 2001 and received the ACM-SIGCSE Award for Outstanding Contributions to Computer Science Education in 2003.

• Updated and revised to include the use of Java for programming examples, this book provides readers with a thorough and clear introduction to the difficult concept of recursion
• Uses a broad range of examples to illustrate the principles used in recursion and how to apply them to programming
• Features imaginative examples along with various exercises and their solutions

Superb
I don’t program in Java, mainly c++. If you program in any c-style language you will find this book insightful in Thinking about recursion. The examples are great and the book is written in a very nice style. I came upon this book by chance. I owned a second hand copy of the original with included examples in Pascal. I much prefer this edition. To get the most out of this book, I’d recommend you attempt and think about the questions at the end of each of the chapters. The mathematical induction related chapter was eye opening and very enjoyable. I’d recommend any text that Eric Roberts has written, he is obviously gifted in his ability to educate and make it so rewarding in the process.

Thank you
Gary

Good for students, less for real world
Many pages spent in academic formulas make this book good for students only.

A good book on recursion implemented in Java
In mathematics and computer science, recursion specifies a class of objects or methods by defining a few very simple base cases or methods, and then defining rules to break down complex cases into simpler cases. Of the books out there on recursion, this really is a very good one. However, I think that the author should have used another title. The name "Thinking Recursively with Java, 20th Anniversary Edition" will get you laughed out of the geeks club, of which I am a charter member, since Java has only been around since 1995. It reminds me of the heyday of the Internet bubble when I once saw a group of programmers advertising that they had been "programming in Java since 1989". Of course, what the author really means is that this is the 20th anniversary edition of his classic book "Thinking Recursively", which was published in 1986. In fact, this book has the exact same number of chapters with the exact same names as the original. The author does a good job of comparing the procedural approach to the recursive approach, and then initially offers up the recursive solutions for the familiar and classic Tower of Hanoi problem plus some problems on permutations and sorting that are best solved by recursion. Of course, you can find this information in most good algorithm textbooks. Where the book really excels is in later chapters when it includes recursive solutions to graphical applications and even uses Java’s graphical API’s to do so. This book contains quite a bit of mathematics as well as Java code, so the reader should already be proficient in Java programming as well as discrete mathematics. This book could serve as a textbook since besides its many examples it includes exercises with solutions.
I notice that Amazon does not show the table of contents for this book, so I do that here:
1. The Idea of Recursion.
2. Mathematical Preliminaries.
3. Recursive Functions.
4. The Procedural Approach.
5. The Tower of Hanoi.
6. Permutations.
7. Sorting.
8. Recursive Backtracking.
9. Graphical Applications.
10. Recursive Data.
11. Implementation of Recursion.

can be elegant and concise
This little book is a minor classic. First published 20 years ago, it gave an extended explanation of recursion, which is a vital concept in computer science. Of course, Java did not exist back then, so that edition used Pascal for the example code. But Pascal has undergone a severe downturn. Hence this second edition has code in Java.

Classic pedagogic examples like the Towers of Hanoi are shown to yield to a recursive assult. The code examples are concise. Not atypical of recursive methods. If you find the entire idea of recursion to be a little weird, you can focus on the text’s examples. Unlike code for, say, GUI building, which is often voluminous, recursion is subtler. And far more elegant, if you appreciate this type of abstraction.

Roberts also brings up fractals. Another trendy topic. He shows that recursion and fractals are a very natural fit. The concept of self-similarity that underpins fractals is so easy to express in a recursive routine. If you understand recursion by this point in the text, a bonus may be the nice insight this gives into fractals.

The only minor dissenting point is that there seems to be no discussion about when you should not code a recursive solution, even if such a method is possible. If you have a large data set, that triggers a stack or heap overflow, due to repeated, recursive method calls, where each call pushes return address information for that method onto a stack. I have had to rewrite sections of my own code, that were originally recursive, due to this.