Browse Books

Reviewer: Paul Krzyzanowski

The examples in this introductory textbook on data structures are given in C. The book begins with an abstract discussion of data structures and then briefly discusses C's support for structures and arrays. The stack is then covered, with exercises in dealing with infix, postfix, and prefix notation. Recursion, queues, lists, and trees are then examined. The remaining chapters cover sorting, searching, graphs, and storage management. The chapter on trees includes a discussion of expression trees and game trees. The discussion of searching includes a fairly complete coverage of binary trees, optimum search trees, balanced trees, multiway trees, and B-trees. The coverage of hashing and hash functions is extensive. The chapter on storage management generalizes lists and covers techniques for list management and algorithms for garbage collection and compaction. It then describes various algorithms for dynamic storage management, concluding with the Buddy system and its derivatives. Most of this text is adapted from an earlier book by Tenenbaum and Augenstein, <__?__Pub Fmt italic>Data structures using Pascal<__?__Pub Fmt /italic> [1]. Some material has been reorganized; for example, sorting and searching are presented before graphs. Other material has been updated, and considerable new material has been added, particularly on hashing, graphs, and storage management. Most of the material is virtually identical to that in the Pascal version of the book. Large sections of the text read the same, and many examples have simply been translated to C. Consequently, some of the C examples do not reflect typical C usage, but rather reflect Pascal constructs. For example, one fragment of code tests an expression and returns an undefined symbol of TRUE if the expression is true and FALSE if the expression is false. Conventional C programming style is to simply return the expression. In addition, some algorithms are presented in C, while many others are presented in a metalanguage that is essentially C with undefined variables, definitions, or functions. The typographical differences between C and the C-like metalanguage are not easily detectable. Furthermore, the metacode contains syntax errors (such as sometimes using a single equals sign to test for equality; C syntax requires a double equals sign) as seen in the following fragment (p. 376): /* Transpose node (q) and node (p). */ next(q) = next(p); next(p) = q; (s = null) __?__ table = p : next(s) = p; return (p); <__?__Pub Lcl pindent="0pt">Code in the book frequently cannot be readily compiled since the necessary symbols and structures are not always defined. Moreover, some of the code is not properly indented, making examples difficult to follow. It would have been desirable for the code to be presented in a form that allowed readers to simply copy the code and execute it without having to modify it. For example, C type definitions and symbols are often included using header files. Almost all of the code presented lacks include statements, something virtually all C programs use. The introductory section describing data abstraction may be somewhat confusing to new students in computer science because the definitions are perhaps overly formal. Its discussion of a possible implementation of character strings as a structure containing a count followed by the string may also confuse the C novice since the C language does not implement strings that way (as the authors point out later in the section). Nevertheless, the text is well structured and well written. Terms are always defined, and procedural descriptions of algorithms are presented along with examples. I found the father/son notation in describing trees to be less conventional than the more customary parent/child description. While the costs of algorithms are discussed, the emphasis is clearly not on presenting a rigorous treatment of algorithm complexity, but rather on the mechanics of the algorithms and the structures they use. The bibliography is comprehensive and the entire text is well indexed, so it serves well as a reference. This book was written for use in a two-semester course in data structures and programming. With its thorough treatment of the field, plentiful examples, and good exercises, it fulfills its objective well, provided that it is not used as a reference for C programming style. Good, consistent C programming style and executable programs are lacking. The book <__?__Pub Caret>is probably too long to be used in its entirety in a one-semester data structures course, but a bit of pruning could adapt it for that purpose.