Data Structures for Game Programmers

Rating:
Summary: Very Good
Review: ...Now for the good: The book is awesome. It is well written, packed full of information about everything relating to data structures and games; and the best part: It is written in such a way so that you can apply the structures and algorithms to non-game programs as well! They should have called this "Data Structures For Anyone". This is easily one of the greatest books I've ever bought.

Rating:
Summary: I would recommend this book to a non-beginner
Review: A pre-requisite for any book on Data Stuctures is that the person should be comfortable with the syntax and semantics of programming in a high level language such as C++ or Java. Hence this book assumes that you are comfortable with C++ and OOP. There is no such thing as Data Structures for Absolute Beginners. So discard the review with 2 stars. Overall this is an excellent and interesting book on Data Structures.

Bottom line is this, you can find the information presented in DS4GP in any other good book on data structures but what sets this book apart is the presentation, organization, practical content and the writing style of the author.

It's definetly not for beginners or for a person looking for a very detailed book on data structures that covers AVL trees and red-black trees. But for the other 99% its a must buy.

Rating:
Summary: One Of The Greatest Book Dedicated To Game Programming
Review: Data Structures... Those things of legend that, basically, totally suck. They're complicated, their use is cryptic at times, However, Ron Penton, the author of Data Structures for Game Programmers, makes these things of legend not only simple to understand, but also makes the entire learning process... *gasp... *FUN!*

The author goes through every data structure in the book with great detail. No two page explanations here, nor does he want you to just copy and paste the code into your project. No sir, Ron goes through EVERY data structure in the book with great detail, lots of figures and diagrams, and three demos. One demo showing the data structure in-action via a custom GUI, allowing you to play with and "tweak" various settings to see how the algorithm works. Then there's a console mode implementation that simply shows a basic implementation of the algorithm. And finally, there is a demo where the reader sees how the data structure can be applied to game development. It's definately obvious that the author knows his stuff inside and out.

So, if you're a game programmer, you definately owe it to yourself to pick up this book. No matter what. If you're a general programmer having a hard time with college data structure books that make no sense, you also owe it to yourself to pick this book up.

Premier Press and its fellow authors definately seems to be getting the hang of writing and publishing, as each book they put out seems to be getting better and better, let's just hope this trend continues.

Rating:
Summary: Great Book for Any Programmer
Review: Data Structures... Those things of legend that, basically, totally suck. They're complicated, their use is cryptic at times, However, Ron Penton, the author of Data Structures for Game Programmers, makes these things of legend not only simple to understand, but also makes the entire learning process... *gasp... *FUN!*

The author goes through every data structure in the book with great detail. No two page explanations here, nor does he want you to just copy and paste the code into your project. No sir, Ron goes through EVERY data structure in the book with great detail, lots of figures and diagrams, and three demos. One demo showing the data structure in-action via a custom GUI, allowing you to play with and "tweak" various settings to see how the algorithm works. Then there's a console mode implementation that simply shows a basic implementation of the algorithm. And finally, there is a demo where the reader sees how the data structure can be applied to game development. It's definately obvious that the author knows his stuff inside and out.

So, if you're a game programmer, you definately owe it to yourself to pick up this book. No matter what. If you're a general programmer having a hard time with college data structure books that make no sense, you also owe it to yourself to pick this book up.

Premier Press and its fellow authors definately seems to be getting the hang of writing and publishing, as each book they put out seems to be getting better and better, let's just hope this trend continues.

Rating:
Summary: does what it says
Review: i wanted a book to brush up on some data structures since i've been out of programming for a few months. plus, most of my learning of these has been self taught and from the internet where there is limited (good) writings on more complex subjects such as programming. so i wanted to have a fresh perspective. not only does the book contain very useful details in many areas and to the point information (gets to the first data structure by page 14!) but the author somehow makes this stuff fun to read.

the author doesn't go hugely in to depth in some areas but that's pretty much what i wanted since i am already familiar with how to use most of the stuff. very good book and i'd highly recommend it. hope this author continues with more books!

Rating:
Summary: Does what it says
Review: i wanted a book to brush up on some data structures since i've been out of programming for a few months. plus, most of my learning of these has been self taught and from the internet where there is limited (good) writings on more complex subjects such as programming. so i wanted to have a fresh perspective. not only does the book contain very useful details in many areas and to the point information (gets to the first data structure by page 14!) but the author somehow makes this stuff fun to read.
the author doesn't go hugely in to depth in some areas but that's pretty much what i wanted since i am already familiar with how to use most of the stuff. very good book and i'd highly recommend it. hope this author continues with more books!

Rating:
Summary: great book on data structurues applied to game programming
Review: I've skipped around but basically read the entire book. This book is great for learning data structures that are necessary to making a game or an engine. if you think you don't need data structures like these, you really do need to buy this book. All of the structures come with implementation as well as graphical, interactive demonstrations. Very good book overall

Rating:
Summary: Wow!
Review: Let me be frank; I HATE DATA STRUCTURES. They are BORING. I'm a sophomore in a Computer Science program, and I've just finished taking a data structures course, and I barely passed it. All college Data Structure books are written for people who like to read extremely boring mathematical proofs, and I can't read that stuff. So, a friend of mine told me to get this book, so I got it on sale, and boy, I am glad.

I've bought Prima/Premier books before, and they are usually good, but also disappointing because the first 40% of the book is always an introduction on things like "a complete tutorial on direct3d" or something. Well this book is different: it gets RIGHT TO THE POINT, IMMEDIATELY. The first two chapters are ALL of the intro material (algorithm analysis and templates), then Chapter 3 jumps right into the data structures!

Okay, so arrays may seem to be a bit simplistic, so I skipped that chapter at first. The later chapters in the book are more interesting, but then I noticed in a later chapter, a reference to a complex issue in the array chapter (processor caching). So I went back and and re-read that chapter, and WHOA! He literally shows you EVERYTHING there is to know about arrays, even complex stuff like caching that a normal data structures book would never even touch!

This book is amazing; and covers TONS of topics. There's no TOC listed at this site yet, so here's a list of what it's got: Arrays, 2D Arrays, 3D Arrays, Bitvectors, Linked Lists, Hash Tables, Stacks, Queues, Recursion, Trees, Binary Trees, Heaps, Minimax trees, Graphs, AI Machines, Data Sorts, Compression Algorithms, Pathfinding (BEST CHAPTER!), and he even goes over the creation of a simple 2D game and complete map editor for it.

Every chapter is packed full of diagrams and figures, notes, and demo's. For every major concept, there is a "Graphical Demonstration" on the CD, that shows you how it works! And, for every chapter, there's also one or more "Game Demonstration"s. These show you how to integrate the data structurs into a game! The CD is so awesome that it could practically sell on its own!

The bottom line is: this book takes the boring and difficult subject of data structures, and turns them into something anyone can understand, in a fun and exciting way. 5 stars!

Rating:
Summary: Very solid material
Review: Obviously a book on data structures isn't going to be the most mind-blowing read in the world, but this book is very solid, very practical to game programmers, and the demos and examples are interesting enough to keep your focus sharp. The sad thing is that most people aren't going to understand how much they need this book, so lemme just be blunt-- if you think you're too smart to need a book on game programming data structures, chances are you aren't. Most people are going to find plenty of "ah... I didn't know that"'s throughout this thing. Definately worth checking out.

Rating:
Summary: Tries, but doesn't quite get there
Review: Publishing a book on data structures and algorithms isn't an easy task, because there's no computer science genre that's got as much of a pedigree. With titles ranging from a dozen good college textbooks to Sedgewick's five-volume _Algorithms_ series to Knuth's dense and eternally-unfinished _Art of Computer Programming_ series, any new book on data structures and algorithms is facing some serious competition. When I learned that Ron Penton, a newcomer to the programming book scene, was entering the foray with _Data Structures for Game Programmers_, I was skeptical. Could a book explaining the deep subject of data structures and algorithms written by someone with comparatively little experience in programming hold its own against books written by lifelong academics?

Unfortunately, that answer is "not really". While _Data Structures for Game Programmers_ does a reasonable job of explaining the data structures and algorithms that are necessary for games, the book suffers from serious organization problems and a lack of depth.

The book does cover the expected basics and follows the standard format, with a chapter on arrays, a chapter on linked lists, a chapter on binary trees, a chapter on stacks & queues, etc. These are covered reasonably well, showing how the structures are represented, the advantages and disadvantages of each, and how to code them. The book does try to distinguish itself from a standard college data structures textbook in two ways. First, each data structure and algorithm includes an interactive example program on the included CD. These examples are very well done and are an excellent way to see constructs "in action". Second, the example programs are all game-oriented, mostly involving a Zelda/Ultima style adventure game.

Around page 600, the book takes a turn into algorithm territory, and it does take a more game-oriented focus following the obligatory chapter on sorting. Chapters on data compression, random numbers, and path-finding are natural fits for all kinds of games.

Following the algorithms are a few short appendices covering the basics of C++ (or as much as can be covered in 30 pages, which isn't much), a few pages on how PC memory is organized, a quick overview of SDL (the graphics library used to make the example programs), and twenty pages on STL.

Unfortunately, the short shrift given to STL is one of the problems with the book. While the value of STL was once debated, it is now blessed by ISO as the C++ standard library and is now as much a part of C++ as the if( ) statement. About half of the data structures covered in the book are already implemented in STL, and the rest can be made out of combinations of STL containers and algorithms. The book, however, ignores STL in favor of building all data structures from the ground up. While I understand the need to show how data structures look and work internally, the chapters should at least mention that the structures are already part of C++ and don't need to be implemented directly.

Early on I mentioned the organizational problems with the book, and a couple of them are significant. The first is how, despite the fact that the book is aimed at C++ beginners, the book opens with a fairly advanced chapter on templates. The templates chapter is followed by a far-simpler chapter on arrays. Despite having not covered arrays yet, the chapter on templates implements an array container assuming that arrays are already understood. Even worse, chapter 9 is a tutorial on how to write classes in C++, even though C++ classes have been in heavy use since chapter two! I honestly don't know if this is a case of chicken-egg syndrome run amok or if it's a case of an author and editor not spending enough time organizing the layout of the book, but it does make for a confusing read.

My final complaint about the book is about the relative lack of depth given to the subjects. While simple structures like arrays are covered comprehensively, there is too much "this is too advanced a topic for this book" later on. For example, the chapter on binary trees shows how to build and climb a binary tree. The chapter does correctly state that binary trees suffer from a significant flaw, which is that the search efficiency is very dependent on the order of the data inserted. The chapter also states that there are ways around this flaw, namely AVL and red-black trees which re-balance themselves. That's where the book stops, though. Even though the book could cover balanced trees with a few more pages, the book just recommends you look elsewhere and leaves (no pun intended) binary trees with their flaws. This is later repeated in the chapter on minimax trees, mentioning that tree-searches can have their performance improved significantly, but not detailing those ways because, according to the author, the chapter was getting too big and most folks aren't interested in minimax trees anyway.

In conclusion, _Data Structures for Game Programmers_ tries to achieve a lofty goal, staking a space among books written by the top people in the field. Unfortunately, though, it only partially reached that goal, covering some topics well and gaining big points for the quality of the programs on the included CD, but falling well short of the mark in organization and depth of advanced coverage.