Product Description
In the first book/CD-ROM of its kind, algorithm guru Scott Ladd reveals how Java can implement important data structures to create quick, efficient, professional applications and applets. From sorting and containers to hash tables and file I/O, developers (especially those migrating from C++) will learn how to wring new levels of performance from Java. CD-ROM contains all the compiled source code from the book, Sun Microsystem's JDK 1.1.4, and a trial version of Visual J++ and other third-party Java tools. Part of the Java Masters series.Amazon.com Review
Have you ever muddled through a Java programming job knowingthat if you only had sufficient time, you could find a more efficientway to complete the project? Java Algorithms contains dozens ofhighly practical and efficient routines ready for insertion into yourprograms.

Author Scott Robert Ladd brings you lots of old friends innew clothes. The quicksort, a staple of C, Pascal, and otherlanguages, appears here in Java, as do the Shell sort and otherpopular sorts. (The bubble sort, friend of high schoolcomputer-science students everywhere, is mercifully left out.) You'llalso find math algorithms (including a cool polynomial class), GUIlayout tools, data trees, serialization, compression, and othertopics--all explained in text that's a pleasure to read.

Theauthor's writing strengths become most evident when he explainsstring-search algorithms. Ladd walks you through the behavior of hiscode step by step, making things clear without making you feel as ifyou are being spoken down to. All the code in the book appears on thecompanion CD-ROM, ready to be used piecemeal or included in programsas the coyote.* packages. --David Wall ... Read more

Customer Reviews (7)

Fair treatment
In this book, written at the time of JDK 1.1.1, the author attempts to convey to the reader that the Java programming language is not just for creating applets, but can be used for networking, interprocess communications, scientific programming, and for creating portable graphic interfaces. It is reasonably well-written, but the author should have spent more time on the performance issues in writing stand-alone code in Java. He makes the claim that a Java program can outperform an equivalent program in C++, but he offers no benchmark comparisons to substantiate his claim. This is particularly for his discussion of matrix algebra in Java. His general discussion of algorithms to do various tasks is pretty well-written, and a reader could gain insight into the workings of these algorithms by the perusal of this book.

The author also gives hints on how to improve the performance of Java programs. In the discussion of sorting for example, he explains how to remove recursion in order to implement an iterative scheme for sorting, thus enhancing performance. He is also careful to point out that the presence of primitive types in Java, which cannot be derived from the Object class. Thus it is often required, as the author explains, to create methods to convert arrays of primitive types to arrays of wrapper classes.

The author's discussion of numerical applications in Java is fairly well-written, as he discusses the various numeric data types in Java, and how it does conversions between numeric types. And he points out some of the virtues that Java has in manipulating arrays, one example being that manual range checking need not be done. He does give Java code for the Fast Fourier Transform, but it is too slow to be of practical interest in serious real-world applications.

A reader with background in computational biology and genome sequence analysis might find the author's discussion on Java strings of interest. Java has been used in biological applications, but the software language PERL continues to be dominant in these applications. The author develops explicitly algorithms for string searching in chapter 3, and these could be adapted to biological applications if one is so inclined.

Another topic of interest in the book is the one on high-performance containers. The author recognizes that Java does not provide for the standard data structures like queues and linked lists, so he spends a fair amount of time developing various types of containers.

The author also introduces evolutionary programming and its implementation in Java. This is done via the construction of finite state machines, and the evolutionary algorithm calculates a fitness value for each finite state machine based on its performance. A fun example dealing with robot examples is provided in Java. In addition, a very interesting discussion (with Java source code) is given for random number generation.

The discussions on serialization and serialization in random access files might be useful to the reader who is attempting to write network and database applications in Java or writing JavaBeans applications. There is also an entire chapter devoted to implementing (in Java) the BTree data structure. I was not aware of this data structure before reading the book, so this chapter was interesting reading.

By far the most pleasureful part of the book was the discussion on stellar cartography and star map plotting, from both a personal and educational standpoint. Instructors of astronomy or earth science could easily use the Java implementation in the classroom to illustrate the relevant concepts to students.

do not buy this book
This book is the worst Java book I've ever read.I think it should really be called "How C++ programmers program Java."The "algorithms" are nothing more than the most trivial versions, andthe author's style is to give the code and then say what HE did.There areno examples of good code.It is obvious that the author doesn't reallyknow what he is talking about.

Builds Bad Programming Techniques
This book TROUBLES ME.The author has no concept of good algorithms and data structures.Example: he builds a queue using arrays instead of Linked Lists.The array sets a limit on the amount of structures you can store inthe queue.If you use a Linked List Object you can have unlimited storageand better overall performance and OO design.Try this book instead:"Data Structures & Algorithms in Java".This is a muchbetter text.It is more of a computer science text but written so thereader can absorb all of the concepts.

I bought this book for the stellar cartography coverage
I haven't received the book yet.I just wanted to let anyone who is looking for books that cover stellar cartography (making star maps forastronomy) know that this book is one of the few that actually covers it(that I could find, anyway).If anyone sees this and has suggestions forstellar cartography books, please email me.

useful, but lots of errors
I found this a good book, with practical algorithms, but a bit sloppy,there are a lot of errors, as well in the code (rare) as in the text(often). The explanations aren't allways clear, but with a bit searchingone gets the results... ... Read more

Product Description

* The first exposition on super-recursive algorithms, systematizing all main classes and providing an accessible, focused examination of the theory and its ramifications

* Demonstrates how these algorithms are more appropriate as mathematical models for modern computers and how they present a better framework for computing methods

* Develops a new practically-oriented perspective on the theory of algorithms, computation, and automata, as a whole

Product Description

The Best-Known Algorithms Currently Used in the Data Mining Community
Contributions from recognized leaders in the field

Identifying some of the most influential algorithms that are widely used in the data mining community, The Top Ten Algorithms in Data Mining provides a description of each algorithm, discusses its impact, and reviews current and future research. Thoroughly evaluated by independent reviewers, each chapter focuses on a particular algorithm and is written by either the original authors of the algorithm or world-class researchers who have extensively studied the respective algorithm.

The book concentrates on the following important algorithms: C4.5, k-Means, SVM, Apriori, EM, PageRank, AdaBoost, kNN, Naive Bayes, and CART. Examples illustrate how each algorithm works and highlight its overall performance in a real-world application. The text covers key topics—including classification, clustering, statistical learning, association analysis, and link mining—in data mining research and development as well as in data mining, machine learning, and artificial intelligence courses.

By naming the leading algorithms in this field, this book encourages the use of data mining techniques in a broader realm of real-world applications. It should inspire more data mining researchers to further explore the impact and novel research issues of these algorithms.

Product Description
This book, updated and improved, introduces the mathematics that support advanced computer programming and the analysis of algorithms. The book's primary aim is to provide a solid and relevant base of mathematical skills. It is an indispensable text and reference for computer scientists and serious programmers in virtually every discipline. ... Read more

Customer Reviews (30)

Actually delivers in a readable way
After having had a bad result from other Ronald L. Graham, Erdos on Graphs : His Legacy of Unsolved Problems, books and articles. I was surprised with this book. I think that Dr. Knuth seems to turn what he touches to gold? I kind of wish I had read this one several years ago when
I wasn't as familiar with the material.
I was amazed to find the recursion for the Eulerian numbers of the second type and a host of very useful identities as well.

Great, great math book ...
How often do you get to have two of the giants of mathematics Graham and Knuth co-author (with Patashnik) a book like this - even suitable for high-school students?

Don't let the binding or whatever fools you, this is a serious math book and serious thinking is required.The material is broad and interesting.I think the book can be used as a supplement text to any of the discrete math/algorithm course (or just leisure reading).It will serve you years to come.Extra bonus - the marginal notes.It may be annoying to you or not but I found it funny at times.

I echo the same feeling as some of the readers here - keep this one always within reach.This is a future classic!

enjoying the struggle
really good book, some times it's bit hard to comprehend, but I'm enjoying the struggle.

Long Live Concrete Mathematics!
I had the pleasure of taking the course "Concrete Mathematics" with Ron Graham as an undergrad engineering student at Princeton University in the late 1980s, and in retrospect it was quite possibly the highlight of my academic career. Likewise, this text has a cherished spot in my bookcase even to this day. The material is challenging, sometimes downright frustrating, but good stuff nonetheless... and as others have noted, very useful! The skills gained are specifically tailored for application in fields such as computer science, really a number of disciplines; and complement what one learns in the more "standard" math courses. How many academic texts have become must-haves even beyond your college years? For me, only this one. I'd give it fifteen stars if I could.

A difficult but worthwhile mathematics text
This book's title can be misleading. I would say it is more of an advanced textbook on the mathematics that is a foundation for computer science than a foundational book on the mathematics of computer science. I think this misreading of the title and thus the book's content is what is behind much of the heartache that readers have when trying to tackle it. This book expands on the "Mathematical Preliminaries" portion of "The Art of Computer Programming" series of books by Knuth, and thus this book has a style much like that series of books. The book is complete and clear, but it is also densely packed with lots of theory and proofs and will require much effort and time to understand well. It is really not meant to be an applied mathematics textbook at all. I show the table of contents next. Note that there are exercises at the conclusion of each chapter with solutions in the back of the book. However, most of the exercises are not so simple that you can just glimpse at the solution and figure out how to get from A to B. I recommend it if you have the time. It can really bring out thoughts and the beauty of mathematics that you may not have considered before.

1. Recurrent Problems.
The Tower of Hanoi.
Lines in the Plane.
The Josephus Problem.
Exercises.

2. Sums.
Notation.
Sums and Recurrences.
Manipulation of Sums.
Multiple Sums.
General Methods.
Finite and Infinite Calculus.
Infinite Sums.
Exercises.

3. Integer Functions.
Floors and Ceilings.
Floor/Ceiling Applications.
Floor/Ceiling Recurrences.
'mod': The Binary Operation.
Floor/Ceiling Sums.
Exercises.

4. Number Theory.
Divisibility.
Factorial Factors.
Relative Primality.
'mod': The Congruence Relation.
Independent Residues.
Additional Applications.
Phi and Mu.
Exercises.

5. Binomial Coefficients.
Basic Identities.
Basic Practice.
Tricks of the Trade.
Generating Functions.
Hypergeometric Functions.
Hypergeometric Transformations.
Partial Hypergeometric Sums.
Mechanical Summation.
Exercises.

6. Special Numbers.
Stirling Numbers.
Eulerian Numbers.
Harmonic Numbers.
Harmonic Summation.
Bernoulli Numbers.
Fibonacci Numbers.
Continuants.
Exercises.

7. Generating Functions.
Domino Theory and Change.
Basic Maneuvers.
Solving Recurrences.
Special Generating Functions.
Convolutions.
Exponential Generating Functions.
Dirichlet Generating Functions.
Exercises.

8. Discrete Probability.
Definitions.
Mean and Variance.
Probability Generating Functions.
Flipping Coins.
Hashing.
Exercises.

9. Asymptotics.
A Hierarchy.
O Notation.
O Manipulation.
Two Asymptotic Tricks.
Euler's Summation Formula.
Final Summations.
Exercises.

A. Answers to Exercises.
B. Bibliography. ... Read more

Product Description

A Concise and Practical Introduction to Programming Algorithms in Java has two main goals. The first is for novice programmers to learn progressively the basic concepts underlying most imperative programming languages using Java. The second goal is to introduce new programmers to the very basic principles of thinking the algorithmic way and turning the algorithms into programs using the programming concepts of Java.

The book is divided into two parts and includes: The fundamental notions of variables, expressions and assignments with type checking - Conditional and loop statements - Explanation of the concepts of functions with pass-by-value arguments and recursion - Fundamental sequential and bisection search techniques - Basic iterative and recursive sorting algorithms.

Each chapter of the book concludes with a set of exercises to enable students to practice concepts covered.

Customer Reviews (2)

Very good and practical intro to algorithms and computers science
I see that the author took a great effort to make the material accessible to Java programmers who did not have much exposure to the algorithms and CS.

I suggest it to everyone who want a gentle introduction to the subject and who does not have a strong mathematical or CS background.

simple algorithms
Much of the book is simply about learning java. Mostly for writing procedural programs, as the book really doesn't go much into the ideas of object oriented code. Over half the book is essentially about the grammar of java.

The algorithms covered are elementary and far below the level of Knuth's Art of Computer Programming, The, Volumes 1-3 Boxed Set (2nd Edition) (The Art of Computer Programming Series) (Vol 1-3). They deal with simple structures like linked lists, stacks [first in, first out and first in, last out] and strings.

The book seems best for those students new to java and to computer science in general. ... Read more

Product Description
Filling the void left by other algorithms books, Algorithms and Data Structures provides an approach that emphasizes design techniques. The volume includes application of algorithms, examples, end-of-section exercises, end-of-chapter exercises, hints and solutions to selected exercises, figures and notes to help the reader master the design and analysis of algorithms.This volume covers data structures, searching techniques, divided-and-conquer sorting and selection, greedy algorithms, dynamic programming, text searching, computational algebra, P and NP and parallel algorithms.For those interested in a better understanding of algorithms. ... Read more

Customer Reviews (2)

Excellent Algorithms Book -- For Graduate Students Only
I am a professor who has used book for the last three years for my Algorithms class.I have reviewed many books on the design and analysis of algorithms.It is surprising to me that, on the subject of something as fundamental to computer science as algorithms, that there are so few really good texts--fortunately this is one of them. On the plus side, it has just the right amount of mathematical rigor and is very comprehensive.Of special note the the excellent chapters on Coping with NP completeness and Text Searching.It does have some issues, however.As a previous reviewer pointed out, it is very expensive.In addition, many of the chapter exercises are extremely difficult and there should be selected answers to these in back of the book. This is definitely a graduate text--would not recommend for undergrads.For Professors, I found the instructor materials for this book to be on the thin side, with many gaps in coverage.It could also use a chapter on evolutionary algorithms.Hopefully this will be corrected in a subsequent edition.

Good Introduction to Algorithms
This is actually a pretty decent book, and does a reasonably good job of introducing algorithm analysis and design. I suspect it is not terribly popular because it is very expensive, and does not offer any distinct material that one would otherwise not find in the dozens of other books available on this subject. Nonetheless, I found it enjoyable. ... Read more

Product Description

Algorithmic discrete mathematics plays a key role in the development of information and communication technologies, and methods that arise in computer science, mathematics and operations research – in particular in algorithms, computational complexity, distributed computing and optimization – are vital to modern services such as mobile telephony, online banking and VoIP.

This book examines communication networking from a mathematical viewpoint. The contributing authors took part in the European COST action 293 – a four-year program of multidisciplinary research on this subject. In this book they offer introductory overviews and state-of-the-art assessments of current and future research in the fields of broadband, optical, wireless and ad hoc networks. Particular topics of interest are design, optimization, robustness and energy consumption.

The book will be of interest to graduate students, researchers and practitioners in the areas of networking, theoretical computer science, operations research, distributed computing and mathematics.

Product Description
"Of all the books I have covered in the Forum to date, this set is themost unique and possibly the most useful to the SIGACT community, insupport both of teaching and research.... The books can be used byanyone wanting simply to gain an understanding of one of these areas, orby someone desiring to be in research in a topic, or by instructorswishing to find timely information on a subject they are teachingoutside their major areas of expertise." -- Rocky Ross, SIGACT News"This is a reference which has a place in every computer sciencelibrary." -- Raymond Lauzzana, Languages of Design

The Handbook of Theoretical Computer Science provides professionals andstudents with a comprehensive overview of the main results anddevelopments in this rapidly evolving field. Volume A covers models ofcomputation, complexity theory, data structures, and efficientcomputation in many recognized subdisciplines of theoretical computerscience. Volume B takes up the theory of automata and rewriting systems,the foundations of modern programming languages, and logics for programspecification and verification, and presents several studies on thetheoretic modeling of advanced information processing. The two volumescontain thirty-seven chapters, with extensive chapter references andindividual tables of contents for each chapter. There are 5,387 entrysubject indexes that include notational symbols, and a list ofcontributors and affiliations in each volume. ... Read more

Customer Reviews (2)

Just what you expect from a handbook
This is probably the best or may be the only handbook on theeretical computer science.If one wants to get a good idea on any topic in this field, just open the book and you do not have to run around looking into different books.

On the other hand, this is a huge field, and no handbook can put all of this in one book.I found that many topics that I was looking in were not in good detail at all.For instance I was looking in Fortune's voronoi construction, the terse way of explaining things does not give the reader enough insight.

A book well worth putting on your shelf.
This book is a collection of articles on complexity theory written by a number of very competent authors. The article by Li/Vitanyi on Kolmogorov complexity and the article by Aho on pattern matching in strings stand outin particular. All articles however are very well written and packed fullof useful information, even for readers who are mainly interested inapplications. Extensive references are found at the end of each article,lightening the burden of doing further reading on the topics. ... Read more

Product Description
Mastering Algorithms with C offers robust solutions for everydayprogramming tasks. This book avoids the abstract style of most classicdata structures and algorithms texts, yet provides all the information you need to understand and use common programming techniques. Intendedfor anyone with a basic understanding of the C language, it includesimplementations and real-world examples of each data structure andalgorithm in the text, plus full source code on the accompanying disk. Using both a programming style and a writing style that are exceptionally clean, Kyle Loudon shows you how to use such essential data structures as lists, stacks, queues, sets, trees, heaps, priority queues, and graphs. He shows you how to use algorithms for sorting, searching, numerical analysis, data compression, data encryption, common graph problems, and computational geometry. He also describes the relative efficiency of all implementations.Amazon.com Review
Written with the intermediate to advanced C programmer inmind, Mastering Algorithms with C delivers a no-nonsense guideto the most common algorithms needed by real-world developers.

Thehighlight of the book has to be its concise and readable C functionsfor all the algorithms presented here, including basics like linkedlists, stacks to trees, graphs, and sorting/searching algorithms. TheC functions that implement these algorithms are clearly printed andremarkably easy to read. You can use this sample code directly oradapt it into your C/C++ code.

Although mathematical concepts likeBig-O notation are discussed, the authors don't get bogged down in thecomputer science theory surrounding algorithms. Instead, they presentthe most tried-and-true algorithms available today in an efficientformat. Besides introducing each algorithm, they describe how each isused in computing today, along with a short demo application. Some ofthese samples are quite low-level, such as a virtual memory managerimplemented with linked lists. Most examples are more of generalinterest, such as a graphing example that counts network hops.

Each section ends with questions and answers about how the algorithmswork, along with references to other algorithms (both in the book andfrom other sources). The authors concentrate on the most usefulalgorithms available today and don't try to cover every availablevariation. Busy readers will appreciate the intelligent selection--andefficient presentation--used here.

There are a number of books on Calgorithms, but Master Algorithms with C is one of the mostconcise and immediately useful. It's a perfect choice for the workingC/C++ programmer who's in a hurry to find just the right algorithm forwriting real-world code. --Richard Dragan

Topicscovered: Algorithm efficiency, pointer basics, arrays, recursion,Big-O Notation, linked lists, stacks, queues, sets, hash tables, treesand B-trees, searching, heaps and priority queues, graphs, sorting andsearching algorithms, numerical methods, data compression, Huffmancoding, LZ77, data encryption, DES, RSA, graph algorithms, minimumspanning trees, geometric algorithms, and convex hulls. ... Read more

Customer Reviews (15)

Good book, bad code... it could be better...
Hi:

Well, this book has a lot of very interesting programming issues, like pointers, recursion, linked lists, stacks & queues, trees, etc, etc...
All of these issues are very well explained and have many code examples, but here is the big problem of this book:
The comment style of the code examples is ridiculous!!!
The author used five lines of code when he could use only one!!!
Like this:

/*********************
*
* Absurd comment...
*
*********************/

This makes slower and really uncomfortable the lecture of the code.

Anyway, having this book you'll learn a lot of advanced C programming issues.

Considering 'Algorithms with C'
Things I didn't know when I ordered this book was how structured the book was. It's easy to comprehend and doesn't contain too much unnecessary information. Furthermore, what I also managed to miss was the disc which was included, and this contains more in-depth code, which allows one to check a whole program instead of only a part.
It is definitely a good decision to start with buying this book if you're studying Algorithms with C, since this will truly help and support you on your way.

Probably OK
The book is probably OK, but there are better, much better ones on the subject. I highly recommend looking at "The Algorithm Design Manual", just search Amazon and you'll find it.

good, concise algorithm book ruined by comment
compare to most algorithm/data structure books out there, this book is not as complete as those, but it's much easier to read, and diagrams in this book is well drawn and much eaiser to follow. Why would I only give it 3 stars? One thing really ruined this book - obviously the publisher/editor/author try to increase the total page number by putting ridiculously big comment block in sample code(single line comments takes about 5 lines, all surrounded by '*' and spaces) This made the sample code difficult to read, imagine a 5 line function has to be printed in 2 or 3 pages.

Good book, but HORRIBLE CODING STYLE!!!
The book contents is good, the algorithms presented are more or less well explained and the implementeations themselves are not bad (but could be better).

Unfortunately this book has 2 mayor problems:

Sometimes you need an implementation of an algorithm for which you already know the inner-workings, just need quick code instead of reinvening the wheel yourself... the book will not allways give you that, it will sometimes build an algorithm based on previous ones! Darn!, I am supposed to go straight to the point I want and get the code without having to read a couple of previous sections.

Second and worst of all is the coding style this guy has. I don't know what the other reviwer that said that the code is great programs in but certainly not in C. The author of the book simply has the worst style ever... look at the comments, a one line comment surrounded by a box!!! give-me-a-break!... where did he learn this? He should read a book about style, perhaps read Code Complete by Steve McConnel or something before attempting to write code. Anyway this is just one of the many style flaws this book has.

If I could I would return it, after all, you can get mostly any implementation from the internet (I had to do that or would have wasted lots of time and... time is money).

If well written, the book would have been 1/2 its size and then it would have been good.

Why 3 stars? Well, in spite of the poor programming style and bad presentation of some algorithms, if you have time and patience, you get someting out of the book. Just don't use the coding style he uses... if you try that at work you would be fired or at least laughed at. ... Read more

Product Description
This coherent anthology presents the state of the art in the booming area of online algorithms and competitive analysis of such algorithms. The 17 papers are carefully revised and thoroughly improved versions of presentations given first during a Dagstuhl seminar in 1996. An overview by the volume editors introduces the area to the reader. The technical chapters are devoted to foundational and methodological issues for the design and analysis of various classes of online algorithms as well as to the detailed evaluation of algorithms for various activities in online processing, ranging from load balancing and scheduling to networking and financial problems. An outlook by the volume editors and a bibliography listing more than 750 references complete the work. The book is ideally suited for advanced courses and self-study in online algorithms. It is indispensable reading for researchers and professionals active in the area. ... Read more

Customer Reviews (1)

A very good book for online algorithms
A collection of very good lectures about online algorithms. It is a very good introduction for the begginers. The articles are written in a logical succession, but they are independent each from other. ... Read more

Product Description
Most applications in distributed computing center around a set of common subproblems. Distributed Systems: An Algorithmic Approach presents the algorithmic issues and necessary background theory that are needed to properly understand these challenges.
 
Achieving a balance between theory and practice, this book bridges the gap between theoreticians and practitioners. With a set of exercises featured in each chapter, the book begins with background information that contains various interprocess communication techniques and middleware services, followed by foundational topics that cover system models, correctness criteria, and proof techniques. The book also presents numerous important paradigms in distributed systems, including logical clocks, distributed snapshots, deadlock detection, termination detection, election, and several graph algorithms. The author then addresses failures and fault-tolerance techniques in diverse applications, such as consensus, transactions, group communication, replicated data management, and self-stabilization. He concludes with an exploration of real-world issues, including distributed discrete-event simulation and security, sensor networks, and peer-to-peer networks.
By covering foundational matters of distributed systems and their relationships to real-world applications, Distributed Systems provides insight into common distributed computing subproblems, ... Read more

Customer Reviews (1)

The long-waited book on distributed systems and algorithms
I have been teaching distributed systems and distributed algorithms related courses at graduate level for over 15 years and it is the first time I have come across a book ofa favorable context, right measure and length on this topic. This is a formal book on distributed systems using distributed algorithms approach yet it has a lot of practical concern. It is very concise, right up to the point, says it all but not a single sentence more. It uses a very much different style than its rivals which at one extreme are very verbal at systems and protocols level rather than algorithmic level; and very mathematical with hard to follow proofs at the other. Algorithms are presented in a simple style along with short and sound proofs in this book which makes it very comfortable to follow.

The only criticism I have is that if the graph algorithms part could be extended a bit more to include distributed DFS, BFS algorithms along with distributed independent set and dominating set algorithms, it would reflect the current trends in distributed systems more.
Nevertheless, I think this is the best currently available book on distributed algorithms. After purchasing this book slightly after the beginning of the semester, I ended up modifying all my notes for a current distributed algorithms course to reflect the contents of this book.
... Read more

Customer Reviews (8)

A real gem...
It might seem completely dated with all its examples written in the now outmoded Pascal programming language (well, unless you are one of those Delphi zealot trying to resist to the Java/.NET dominance), but it is still highly recommended.

It is the single book I learnt most from when I was a freshman studying Computer Science at my local University (when Pascal was already declining, I'm not so old ;-). I wish more recent books were as good as this one, but I have not found a single book so focused and, at the same time, so broad in scope as this one.

Wirth covers programming fundamentals (including recursion), many sorting algorithms, data structures (from simple data collections to B-trees and hashing), and basic compiler technology. That is, four books into one (and, surprisingly, this is not a hefty tome.)

Not worth your time if you are a younger programmer
This book was recommended to improve my algorithm skills. However, any younger person (< 30) should not buy this book. It is not an easy read. Might be because it was written in the 70's, but the author constanly uses large and complitcated words for no reason. Also, anyone who's code base is C/C++ will find it hard and annoying to read the books ancient language. I found myself reading each sentense 2 or 3 times just to understand the point. This book might only be $5, but its not worth the savings. Get a book that was printed in the same decade.

A must have book
This book should be on the shelves of every computer science enthusiast and it does not hurt to read it once in a while to reestablish the foundations.

Cornerstone of programming knowledge
I used this book back in university and still apply its techniques today.Unfortunately, someone *borrowed* my copy and I can't get hold of a new one, so: !!!Please reprint!!!!

A Necessary Block of a Programmer's Foundation
With only five chapters and 365 pp, this text presents fundamental datastructures, sorting, the best treatise I've found on recursion, dynamicinformation structures, and language structures & compilers. The dateof the text precludes object-oriented programming, yet the tools presentedhere are welcome adjuncts for Delphi developers. ... Read more

Product Description
All the Visual Basic algorithms you'll ever need and how to use them

This book/CD package arms you with a library of powerful algorithms completely implemented in Visual Basic source code. Just as importantly, it shows you how, when, and where to use them . . . or not to use them. It covers classic VB algorithms as well as the latest VB object-oriented techniques for handling just about any design requirement you'll encounter, such as managing data structures, sorting, searching, hashing, networking, and other important program functions.

In plain English, and with the help of sample code and scads of working examples, VB expert Rod Stephens explains how algorithms work and:
* Describes techniques for selecting the best ones for your projects
* Tutors you in methods for analyzing how they will perform in your programs
* Acquaints you with programming techniques for solving problems as they arise
* Supplies algorithms for most programming situations
* Covers new object-oriented VB algorithms-how they work and how to use them
* Introduces new concepts and techniques for programming in multiple versions of VB.

The CD-ROM supplies you with:
* Source code for all the algorithms described
* Test programs to try them out
* Examples and tests to help you gauge and fine-tune your skills.
Visit the author's comprehensive Visual Basic site at:.Amazon.com Review
This guide shows how to extend Visual Basic (VB) with codethat handles some advanced programming problems, including algorithmsthat you can use every day to write faster and more flexible VBapplications. After an introductory discussion of profiling algorithmsand some techniques to emulate pointers in VB, the author shows how toemulate a variety of data structures, such as linked lists, stacks andqueues, and arrays, along with their implementations in VB.

Besidesthese basic container types, the author also proceeds farther afieldinto a demonstration of trees in VB, including balanced trees. (Thoughyou won't need these data structures for most programs, it'sinteresting to see how they can be written in VB.)

More applicableto real-world problems are the sections on sorting, searching, andhashing in VB. (These algorithms can extend the range of the types ofproblems VB can solve.) This book closes with some network algorithmsand some discussion of object-oriented techniques for VB, includingsome "patterns" or reusable designs for software. With theaccompanying CD-ROM, you can use all the author's algorithms or writeyour own based on the techniques explored here. --RichardDragan ... Read more

Customer Reviews (13)

Does what it says
This book is exactly what it says it is.If you know how to code and just need the algorightms then this is the book for you.If you are learning how to code then this book might be a little difficule for you.

A great book!
This book has thirteen chapters. It covers Lists, Stacks & Queues, Arrays, Recursion, Trees, Balanced Trees, Decision Trees, Sorting, Searching, Hashing, Network Algorithms and Object-Oriented Techniques. The one I'm most interested in is Chapter 8 (Decision Trees), the book has a small Tic-Tac-Toe game and source code. The game has 9 levels of "Artificial Intelligence". I thought I'd find some source code or explanation on chess game when I bought this book. This is the only reason that disappoints me slightly, other than that, it's a great book.

Another little VB gem by Rod Stephens
There aren't many good Advanced VB textbooks out there and most don't bother to teach this stuff, but most Professors or Instructors expect their students to understand sorting algorithms, queues, hashes, binary trees, linked lists, spanning trees, etc.This book was very helpful towards that end.The sample programs are great!Stephens spends more time than usual in explaining the general fundamentals of algorithms and their benefits.He really speaks to the reader.This is not an Advanced VB textbook or reference book.It does a very good job of covering Visual Basic Algorithms.

Zikes
Should have paid more attention in math class. I will bow to others who have written positive reviews, but I just got confused. Like many good computer books though, I will give it another try when my brain frees up some memory.

A very good reference, even if it's not perfect...
Very good reference: fine examples, good clean code.Some bugs in the combinatorial optimization section (branch and bound, etc.) need to be cleaned up (the best isn't always picked).Still, it's a very useful book. ... Read more

Product Description
Text provides a tool set for programmers to implement, debug, and use graph algorithms across a wide range of computer applications. Covers graph properties and types; digraphs and DAGs; minimum spanning trees; shortest paths; network flows; and diagrams, sample Java code, and detailed algorithm descriptions. Softcover. ... Read more

Customer Reviews (9)

Not a gifted writer
[...]I have at least half of both volumes, and it really seems to me that there are real problems here with the exposition. Let me see if I can elaborate.

Here is an actual sentence from the book-

We construct a symbol table that is made up of an ordered array of keys, except that we keep in that array not the key, but an index into the text string that points to the first character of the key.

Consider that there are two possible conflicting meanings of the sentence fragment :

...an index into the text string that points to the first character of the key.

In the first meaning, there is an index that points to the first character of a string which string has the property that it, in its turn "points to the first character of the key". (a String is engaged in pointing and so in the index.)

In the second meaning, there is an index that points (into) a text string and in fact that index points into the FIRST CHARACTER of that text string, and that first character the index is pointing to, well, that is the also first character of the key. (only the index is pointing; the string pointeth not.)

OK so how do you describe what's missing here? At least thedisambiguating use of commas, at least. It's as though he likes to write in subordinate clauses, but thinks it's economical to leave out the punctuation (which, it is true, there are no hard and fast rules for).

So it's just sentence after sentence after sentence like that. Sometimes you can understand what he's saying. Other times, really you just can't. IF each sentence has 2 (or more!) possible interpretations, and each sentence depends on your understanding the last (as is the case- he never says the same thing in two different ways), then you get this ambiguity growing at the alarming rate of x^2, an observation the author might enjoy.

As the other reviewers said, the code is a C programmers attempt to write in Java. This never goes well.....


But the fact remains it is still the most accessible and thorough coverage of some of its subjects. So what are you going to do?

I don't get the impression he is deliberately bartering in obscuratism, it's just that this book suffers (and so will you) from a lack of editing, a lack of reviewing and feedback by genuine, unaided learners etc. etc.

You might want to check other people's lists for alternatives. Or not. Perhaps that passage was perfectly clear to you.

Short on Practical Examples?
Another reviewer gave this book a one star rating citing that the book falls short on practical examples.

In light of that, I'm concerned that other readers might overlook what, in my opinion, may be one of the most comprehensive and well written introductions to graph theory and graph algorithms that there is, and certainly one of the best that I have personally come across thus far.

Recently I took on a project wherein I needed to solve a shortest path problem for a particular kind of graph.I am not a specialist in graph theory and needed practical information that I could utilize immediately.For me, this book fit the bill and was a godsend.

It is true that I already had a practical real world application in mind before I even knew of this book but this book has exceeded both my needs and expectations.

It is easy for me to understand how you may not initially see the practical value of the information being presented, if the sole reason you're studying this book is simply because it is a part of your college curriculum.I think, however, that that does not lessen the value of the book, especially for those of us who do have practical applications for the material.

If you are looking for an informational resource for a real-world problem related to graph theory, you would do well to consider this book.

The book does actually open by citing several practical examples of areas where these algorithms can be applied, although, perhaps the reader who assigned the one star rating may have appreciated and benefited from a case study.

`Algorithms in Java' aka `How little code does it take to confuse people?'
I have the dubious distinction of having taken a class that used this book as it's central text. The illustrations are great. The explanations of algorithms and general algorithm design concepts are clear. The code, however, is neigh unreadable in a lot of places.

This was a huge problem for me, as I had a lot of difficulty seeing a clear mapping from the concepts explained to the code examples. Sedgwick's code examples often build on previous ones to the degree that they are not understandable on their own (this is especially true with the graph algorithms in part 5). If you try to use this book as a reference you will find yourself digging much harder than you would like in order to understand code samples that are actually quite simple. You could see how this might make a programming based course difficult.

Thorough, well written and illustrated, excellent
This is an excellent book. Robert does a great job leading you through the fundamentals of algorithms and algorithm analysis. The visualizations are very well done. In particular the sort algorithm coverage is very well illustrated and described.

The best parts of the book are sorting and searching. A wide variety of algorithms are explained and demonstrated in detail. The code is solid and the writing is very good.

This is the set of Java algorithms books.

Long on theory, Zero on practical examples
After reading the glowing reviews from the other folk here, I was a little excited about this book. It was the text chosen by my college for a class in Algorithm Development. My excitement quickly turned to disdain after reading a few chapters. Theory and performance data are covered very extensively, and for that, I applaud the writers. But what is missing for me is practical examples of where you would use the algorithms presented! Try as I might, I couldn't find any real-world examples for any of the algorithms. Maybe I learn differently than everybody else, but examples go a LONG way in helping me understand things. ... Read more

Product Description
A thorough overview of the primary techniques and models used in the mathematical analysis of algorithms. This book draws upon classical mathematical material from discrete mathematics, elementary real analysis, and combinations and discusses properties of discrete structures and covers the analysis of a variety of classic forting, searching, and string processing algorithms. ... Read more

Customer Reviews (5)

Not a reference guide
This book is REALLY for coursework : someone who is going to sit down and read and work thru this book sequentially, not randomly like a reference book.
Other than that caveat it does what it promises ably but be aware that it is MATHS heavy and REQUIRES the programme work.

A must have.
I read a lot of books about complexity analysis. And this book is a state of art in the field. Easy to read, and well done.It cover the necessary staff that every new commer to the field should know, can be used as a refference,and it make a good teaching material for graduate student.

Clear and concise
This is an excellent book on the analysis of algorithms.More specifically, it is a book on the mathematics needed for the analysis of algorithms.Quite a few algorithms are presented and analyzed in great detail, but the emphasis is on the analysis techniques rather than on the algorithms.

This is in contrast with Cormen,Leiserson and Rivest, or Sedgewick's own "Algorithms" series which emphasize the algorithms rather than the analysis.

If you're looking for a catalog of algorithms along with explanations, you want a different book, but if you want to know how to analyze that bizarre code (which Fred in the next cubicle wrote) and prove that it works well (or doesn't) then this is an excellent choice.

The book is aimed at advanced undergrads/graduate students and assumes a certain amount of mathematical sophistication - i.e. calculus, discrete math, probability, etc.

On the spectrum from "Mathematical Techniques" through "Analysis of Algorithms" and ending up with "Catalog of Algorithms", I would start with Graham, Knuth and Patashnik "Concrete Mathematics", travel through this book, on to Knuth "The Art of Computer Programming", then to Cormen, Leiserson and Rivest, and finally end up with either Sedgewick's "Algorithms" or Skeina's "Algorithm Design Manual".

Classic textbook in this field
For a long time analytic combinatorics lacks a good and comprehensive textbook. Almost every learner in this field learns this subject via scattered papers and chapters in different books or journels. Theapprearence of this book is so welcome by learners and researchers that itoffers a excellent introduction of this powerful and relatively new field.Flajolet and Sedgewick are the famous masters of this field, and this bookproves that again. The writing style is succinct, with instant exercise(s)after every important concept and result. The pace of this book is verynatural and self-contained. The first half of this book deals with thebasic tools used for analysis of algorithm, from the recurrence, generatingfunction, to asymptotic approx. Then it discusses 2 most crucial subjects:trees and permutations. The last 2 chapter turns to strings and words. Ifound it very readble that there is a typical and core example in everychapter. BTW, since I still haven't finished studying this book, but I mustsay that Chapter 5 (Asymptotic) is among many textbooks the bestintroduction to this hard topic so far.

A very readable chapter on generating functions
I don't know whether the style of this book is good or not but for me the chapter on generating functions was very readable. At the time of reading I already have read several books for the understanding of generating functions; including Graham, Knuth, and Patashnik's "Concrete Mathematics," which is definitely great but difficult to me. I've got a solid understanding of the subject through two books: Polya et al's "Notes on Introductory Combinatorics" and Sedgewick and Flajolet's. ... Read more

Product Description

This multivolume work on the analysis of algorithms has long been recognized as the definitive description of classical computer science. The three complete volumes published to date already comprise a unique and invaluable resource in programming theory and practice. Countless readers have spoken about the profound personal influence of Knuth's writings. Scientists have marveled at the beauty and elegance of his analysis, while practicing programmers have successfully applied his "cookbook" solutions to their day-to-day problems. All have admired Knuth for the breadth, clarity, accuracy, and good humor found in his books.

To begin the fourth and later volumes of the set, and to update parts of the existing three, Knuth has created a series of small books called fascicles, which will be published t regular intervals. Each fascicle will encompass a section or more of wholly new or evised material. Ultimately, the content of these fascicles will be rolled up into the comprehensive, final versions of each volume, and the enormous undertaking that began in 1962 will be complete.

Customer Reviews (6)

Computer Science Classic
Three classic volumes from Donald Knuth. I have the 3rd edition. Once your get pass understanding MIX ( MMIX, 4th edition), it is a great technical read. Bring so much to Computer Science. I used them in school. I use them today.

Brief but worthwhile
Combinatorial problems arise in a wide range of contexts. Among combinatorial problems, generation of all distinct sets of some size (tuples) or all rearrangements of the objects (permutations) occur commonly, often as the first step in a larger calculation. Knuth addresses some important classes of such problems in this book.

Even "all possible permutations" leaves a wide range of choices open. For example, should the list be in alphabetical order? Should it minimize the number of differences between consecutive elements? Many other constraints can be imposed as well, even esthetic ones! "Ringing the changes" on a carillon is one such combinatorial problem, with a long history and criteria for beauty all its own. However choices are made, the next step is to specify a way of creating the list. This can have constraints of its own. For example, it may be neccesary to create the next arrangement in the sequence knowing only the current element of the sequence. Knuth offers different algorithms for meeting different sets of constraints. If none of them match your needs, then the references will help you find something that does, or the discussion and exercises will help you develop one of your own.

Although useful, this book is very brief. 144 pages isn't a lot. Take away 45 pages just for solutions to exercises, then more for index and exercises, and the text is surprisingly brief. What's left carries its weight, though. It's a valuable addition to almost programmer's library.

-- wiredweird

Very nice book
Am studying Gray codes for a graduate paper.This was an excellent resource.Fun and interesting read.

Combinatorial Programming Simplified!
First, I would like to say this is the first Donald Knuth book I have read, only because every programmer respects TAOCP so much that they say it is too hard for the hobby programmer. I have a small background in Computer Science, and some mid-level Math; yet Knuth walks you through some of the most exciting Computer Science problems you could ever dream of with ease! I came to find this book perfect, mostly because my favorite Programming problem is the Traveling Salesman, this book as well as fasicles 3 and 4, are the perfect reference to find great ways to venture into the unsolved TSP Algorithm, and the feared Hamilitonian Cycle.

Reading about gray generation I immediatly found so much more value to this book than I ever expected. As well, the book then jumps into ways to use loopless generation( which blew my mind! ). Then the best part comes in the second half of the book, "Generating All Permutations" First it starts with a brute force method for achieving all permutations, then Algorithm L to G(my favorite algorithm in the book...) is the largest hurtle in the book; I actually bought the whole TAoCP volumes so I could get through this part because it goes over permutation pre-multiplication ( Knuth has a better way of defining this ), although the idea is simple, an effective way to implement and explore pre-multiplication I found to be extremely important and should not be over looked. Then after that the diffictulty goes to equal as the first half.

In summary this book is deffinitly worth the wait, and it helps a person, no matter how experienced, to explore new ways to venture out of the straight and narrow, and into an arena of problems that few dare to venture.

a solid compendium of challenging problems
This preliminary excerpt from Knuth's Volume 4 will please all the fans of his seminal first three volumes. The didactic style is the same. So too is the very distinctive Tex typeface. (You know that he invented Tex, don't you?)

Of course, there are the problem sets. This little book has two sections. In each are 112 problems. Strewth! Knuth thoughtfully gives an estimate next to each of how long it will take you to solve it. Those estimates probably refer to someone of his calibre. I've attempted most of the problems in his earlier volumes and could typically only get within a factor of two of the time estimate. And this was only when I could actually solve a problem.

The book addresses a gap in the literature of computer science. Research papers in journals or books of conference proceedings do not usually present you with problems. While introductory texts do, but those are simple. Very difficult to find a solid compendium of challenging problems.

Such is the attraction of this book to me and perhaps to you. The potential readership is exclusive and self selecting. The only drawback is the wait for the rest of Volume 4. ... Read more

Product Description

"An important topic, which is on the boundary between numerical analysis and computer science…. I found the book well written and containing much interesting material, most of the time disseminated in specialized papers published in specialized journals difficult to find. Moreover, there are very few books on these topics and they are not recent."

–Numerical Algorithms (review of the first edition)

This unique book provides concepts and background necessary to understand and build algorithms for computing the elementary functions—sine, cosine, tangent, exponentials, and logarithms. The author presents and structures the algorithms, hardware-oriented as well as software-oriented, and also discusses issues related to accurate floating-point implementation. The purpose is not to give "cookbook recipes" that allow one to implement a given function, but rather to provide the reader with tools necessary to build or adapt algorithms for their specific computing environment.

This expanded second edition contains a number of revisions and additions, which incorporate numerous new results obtained during the last few years. New algorithms invented since 1997—such as Matula’s bipartite method, another table-based method due to Ercegovac, Lang, Tisserand, and Muller—as well as new chapters on multiple-precision arithmetic and examples of implementation have been added. In addition, the section on correct rounding of elementary functions has been fully reworked, also in the context of new results. Finally, the introductory presentation of floating-point arithmetic has been expanded, with more emphasis given to the use of the fused multiply-accumulate instruction.

The book is an up-to-date presentation of information needed to understand and accurately use mathematical functions and algorithms in computational work and design. Graduate and advanced undergraduate students, professionals, and researchers in scientific computing, numerical analysis, software engineering, and computer engineering will find the book a useful reference and resource.

Customer Reviews (3)

Excelent book
For those interested in computer arithmetics this is the right book to start with...Excelent references to the state of the art and related work.

When every bit matters
Most people use floating point arithmetic in a fairly cavalier way. They treat double precision numbers as exact. And, although people use commercial libraries for transcendentals and the like, they seem unconcerned when they need to implement an offbeat function or approximation. Everyone knows the Taylor series for exp(x), for example, so how hard could it be to code that up? (Answer: easy to code, and equally easy to do very badly.)

In fact, IEEE standard arithmetic can not even represent 1/3 exactly. (If that's news to you, or if you think the difference doesn't matter, you should back off and find some introductory material before attacking this book). Also, orthogonal polynomials will give better accuracyand more controllable error than Taylor series, for polynomial approximations of given degree - over a decimal digit more accuracy, in a project I worked on recently. The first three chapters go over those basics, then get into the book's real content.

The next chapters address table-based methods - and tables appear at one point or another in many implementations.Then the author presents iterative techniques for square roots (and 1/sqrt, which is often more convenient), logs exponentials, and trig functions. Although accuracy is paramount, these algorithms also emphasize fast convergence using inexpensive operations. The next section, on shift-and-add algorithms, presents advanced, accurate, efficient algorithms including CORDIC. This section requires close attention, since this book is about principles rather than cut-and-paste coding, so people without immediate implementation needs might come back to it to give it the effort it requires. The book's last section deals with range reduction, i.e. converting the problem to a more tightly bounded one, where the algorithm's behavior can be better undestood and controlled. It also deals with rounding and other quirky cases in floating point arithmetic.

This book isn't for everyone - in fact, not many people these days need to implement "library" functions on their own. As a result, knowledge of implementing them well is increasingly scarce. If you end up in the unusual position of having to implement them yourself, possibly using an exotic computing technology, then this book will help you get the last possible bit of accuracy, and to get it as fast as possible.

-- wiredweird

Clear and complete
The book clearly explains the most important algorithms used by computers to compute many mathematical functions, with plenty of actual examples.
It is not a list of algorithms and tables, but rather a recipe book; actual computation of values and tables is left to the reader, better equipped with some numerical analysis package.
Despite the title, the methods can be applied (with some effort) to a broad set of functions (includingmany that are not usually considered "elementary", like Bessel or Gudermannian functions).
An extensive bibliography is included.
A must for those who are involved in designing and implementing such functions for a computer, but also an enjoyable reading for those who wonder how some functions can be computed. ... Read more

Product Description

Predicting the future for financial gain is a difficult, sometimes profitable activity. The focus of this book is the application of biologically inspired algorithms (BIAs) to financial modelling.

In a detailed introduction, the authors explain computer trading on financial markets and the difficulties faced in financial market modelling. Then Part I provides a thorough guide to the various bioinspired methodologies – neural networks, evolutionary computing (particularly genetic algorithms and grammatical evolution), particle swarm and ant colony optimization, and immune systems. Part II brings the reader through the development of market trading systems. Finally, Part III examines real-world case studies where BIA methodologies are employed to construct trading systems in equity and foreign exchange markets, and for the prediction of corporate bond ratings and corporate failures.

The book was written for those in the finance community who want to apply BIAs in financial modelling, and for computer scientists who want an introduction to this growing application domain.

Customer Reviews (2)

Very nice book - provides a good overview
I usually don't spend time writing reviews, but I did want to comment on the very
negative review made in Dec 2009 because I found this review misleading.

I am interested in both Biologically Inspired Algorithms (BIA) and Financial Modelling (FM).
I have done a lot of research myself using Neural Networks, and I am currently working
on a project regarding Financial Modelling.

I have read only parts of the book yet, but I already found those chapters very
helpful. The fields of BIA and FM are very broad so, of course, no text book can
exhaustively cover both fields. Nevertheless, the authors explain very nicely the fundamental
steps that one needs to consider when building a system which uses BIA for FM.
The first parts of the book introduce the fundamental aspects (BIA and FM) whereas the
third part of the book provides case studies.

I liked the book (as far as I have read it yet) very much: It is well structured and
well written and it provides a good overview. For in depth information it provides a lot
of references.

So for everyone interested in getting an overview of the topic this book is a clear
recommendation. I would have given 5 stars, but I have to admit that at some points a bit
more detail would not have gone amiss.

interesting lateral applications
In the ceaseless search for better modelling of financial instruments and economic events, one approach is to look for methods from mathematical biology as inspiration. Here, the main approaches studied include neural networks, genetic algorithms and ant colony modelling. The first two are perhaps the most widely used.

The key inspiration is to look into the future. The later sections of the book involve predicting various events, like a corporate failure. The efficacy of the biological methods for doing predictions is unclear. The book's results are intriguing, though.

There appear to be 2 audiences for the book. One is biologists or programmers already using those methods in biology, and who are looking at applying these to finance. The other audience is mathematicians in finance wanting more tools. Consequently, each audience will find different portions of the book useful. The explanation of conventional financial modelling is for the biologist, for example. ... Read more

Product Description
Introduction to Computing and Algorithms prepares students for the world of computing by giving them a solid foundation in the study of computer science--algorithms. By taking an algorithm-based approach to the subject, this new introductory text helps students grasp overall concepts, rather than getting them bogged down with specific syntax details of a programming language that can become obsolete. Students work with algorithms from the start and apply these ideas to real problems that computers can help solve. The benefit of this approach is that students will understand the power of computers as problem-solving tools, learn to think like programmers and gain an appreication of the computer science discipline.Features Introduces basic computing ideas, including essential algorithm constructs, software engineering, and certain foundational aspects of theory, tailored to students at a beginning level. Using a "Java-like" pseudo-code, this text prepares students for learning how to program with an object-oriented language. Provides a comprehensive lab manaual that introduces students to various software applications that they will use throughout their careers.Reinforces key concepts with pedagogical features like "Food for Thought" sections and boxed definitions. ... Read more

Customer Reviews (11)

The book on algorithms that I spent 30 years looking for
I started learning programming back in the day with FORTRAN IV. I hated with a passion. This idea of breaking down every task in its idiot's level drudgery so the computer would not mess up was just so tedious. And what were each and every step, anyways? I sucked at algorithms, bottom line. This book finally gives the reader a road map about how to organize and write a "recipe" so the computer will do what is supposed to do. And since it does not use any "real" computer language, these general principles can be applied to ANY language. Better still, it does not bog the student down with formatting and syntax issues (a great relief for those of us still suffering with PTSD from FORTRAN and cryptic error messages). If you think globally and autistic level detail is NOT your forte, this is the book for you.

First Chapter Only
I only read the first chapter before returning to the library, however, that was enough to know that I would purchase this book.Profound ideas were presented.

Perfect for my class!
The product was exactly what I needed for my class and at a cheaper price. Not much more could have been better.

Former Student Speaks
As a former student of Dr. Shackelford when I was an undergrad at Tech, I have first hand knowledge of trying to learn programming with psudeo code as my basis.While proponents of psuedo code claim that it allows learning the basics without getting bogged down in the mechanics of programming, there isn't a whole lot you can actually do with the knowledge gained from this book.You may understand programming better after learning this material, however you will never be able to program an actual computer to do anything.As an engineer who leans towards the hardware side but would like to have more practical programming skills, I would have appreciated learning more of the practical implementation with the material in this book.Personally the formula that has worked for me is to learn the theory, then implement that knowledge by creating something in the real world with real tools.While this book may help you with the theory, the practical implementation side must be found elsewhere.Hence two stars; this book is half the story.

If you are looking for a book that goes over the basics of programming and you don't care about any practical applications, this is the book for you.If you are looking for real world programming skills, look elsewhere.This book will not teach you how to program with real world tools.

Not a teacher, or even a college student
I've been a professional computer programmer for the last seven years, with no formal training.I bought this book to begin improving my grasp of computer theory as well as practice.I've found this book to be eminantly readable, an actual page turner.Parts of it are quite elementary, but it's very good at explaining "why" as well as "what".

I consider the pseudo-code an advantage, since it forces me to look at unfamiliar terms and structures and equate them with the equivalent items in my "real" language.It teaches *theory*, which I can apply to any language, not implementation in a single language that will be obsolete in a year or two. ... Read more

Product Description
An object-oriented learning framework for creating good software design.

Bruno Preiss presents readers with a modern, object-oriented perspective for looking at data structures and algorithms, clearly showing how to use polymorphism and inheritance, and including fragments from working and tested programs. ... Read more

Customer Reviews (6)

Got Advanced Math and Advanced C++??????
Books like this one and Weiss are crap!! PHDs write books to look good in front of their PHD peers. The book Data Structures and Algorithms in 24 hour is fantasic start to Data Structures. There is no way you can understand books like this one and Weiss unless you have this fresh under your belt and had a B grade in all these:

1. Advanced C++
2. Calculus 1,2,3
3. Finite math
4. Discrete math
5. combinatorics math
6. basic data structures class

you much have all thise to even understand the paticulars with the Djikstra Algorithm and Binary trees ect.....trust me..

I mean fresh in your mind. These guys only talk in greek and unless you speak
PHD you will be very bumbed...I have invested some good books and some great vidoes to teach me DSA with out all the PHD verbage. you learn in the busines of school
there are those who can teach the topics and those who only speak of these topics and books like this one and Wiess dont really teach they talk about it only.

Life as we know it...you learn the hard way.

And I beleve all of us are smart like these PHDs you just have to get in there and bust your but t to speak their language and their concepts. It is possible.

Thank god for amazon and their free review because that is how I buy books is by their review good and bad.Love Aamzon

fantastic!
I used the source code in this book when I implemented buddy system in my OS.
Bruno's code is very effective and the design is excellent too.
I've learned a lot of things in this book.
So, I'd like to recommend this book absolutely!

A perfect book for starters in Data Structures using C++
This is a great book for one who has had a formal study of undergraduate Calculus/Algebra and a very good understanding of the C++ language. The book starts off with explaining the fundamentals that will be applied to measure the effectiveness of a piece of code, and is very helpful for those who wants to understand the basic theory applied in the later chapters. This books treats almost all the basic data structures and have been presented in a very simple non-profounding way, like keeping the class design and hiearchy the same throughout. All the data structures have been explained using the (easy to use) arrays as well as link-lists. This makes it easier for a novice to grasp the fundamentals and go on to implement more complex and effective data structures using link lists. Overall, I found this book extremely helpful in getting a sound footing on this topic.

Data Structures and Algorithms for Math Students
Believe the summary...this book is for 2nd and 3rd year post-secondary students.I am an experienced C++ programmer, but Grade 12 math isn't enough to cut through the explanations to get to the code, which I can understand perfectly well.

Who should buy this book?Students with a good grasp of basic calculus, who want a thoroughly academic treatment of algorithms in C++ in order to pass Computer Science.

Who should not?A C++ programmer that wants clear, effectively presented information on implementing standard algorithms and data structures in order to get their project done.

I'm of the Keep It Simple school of thought, and the practical theory and implementations in this book could have been presented much more effectively without the adademic bafflegab.

I am currently working on my calculus skills in my spare time, and as my familiarity with the mathematical notation grows, I may be able to put this book to good use.Untill then I wish I'd bought something else, programming doesn't need to be as dense as this book makes it.

An excellent tutorial on Structures and Algorithims
The book has a detailed introduction and explanation to the subject and clearly explains how to analyze and implement in programming.This is done all in C++ and it is suited to students in Computer Science Courses.Theexercises at the end of the chapters are quite useful. ... Read more