Browse Books

Reviewer: Doris C. Appleby

This book is, according to the authors, “a new version” of their 1976 text, Fundamentals of Data Structures, with all the algorithms rewritten from the description language, SPARKS, into PASCAL. The material covered in the first book was reviewed in detail [ 19, 4 (April 1978), Rev. 32,817; and 19, 6 (June 1978), Rev. 33,083] and will not be discussed here. All topics from CS2 [1] are included, except Computer Organization and Assembly Language, Shell Sort and Decques; all from CS5; all CS7 but NP-hard problems and simple DBMS; and all from IS2 [2] but Blocking, DBMS, and Information Hiding. Readability is certainly enhanced for students familiar with PASCAL. Program development moves smoothly from English description of algorithms through pseudo-PASCAL to correct code. Exercises have been condensed by deleting those specific to SPARKS, and “PASCAL” has been substituted for “FORTRAN” or “PL/I” in problems requiring a programmed solution. The introductory chapter has been rewritten, but the other nine have few changes other than the rewritten algorithms. Although the new version is welcome, this reviewer is disappointed in three ways. First, the treatment does not capture some of the nicer features of PASCAL, other than its block structure and facility for recursion. Nowhere are set or user-defined scalar types used. Arrays are always indexed by integers, and local index variables are declared to be of type INTEGER, rather than of a type identical to that declared with the array. Although the only run-time difference would be in error reporting, procedure code is clearer when appropriate variables are of a user-defined index type, rather than having long lists of INTEGER variables. Variant records are never mentioned, although they could be put to good advantage in Section 10.2.4, on Trie Indexing. The discussion of external sorting (Chapter 8) includes PASCAL versions of merge sorts using arrays to simulate tapes and buffers. The purpose of these algorithms, to sort data too numerous to be stored on-line, is unnecessarily lost by not using PASCAL's internal file capabilities. These capabilities store (in many implementations) data off-line, and thus increase program capacity substantially, while providing realistic simulations of tape rewinding. The second disappointment is that the new version is not a genuine revision. Selected readings contain only one item (p. 26) not included in the 1976 version. The three appendices have been eliminated, but the algorithm list (the old Appendix C) has not been moved to the index. Thus, one must search through the relevant chapters to locate algorithms for such things as exchange or radix sorting, and cannot be certain that Shell Sort is omitted without a thorough search. The new index does include, however, a false reference to the deleted Appendix B. Section 10.4, on storage management, refers to algorithms in Section 4.3 which has also been deleted. The third weakness perceived is that it is doubtful that the PASCAL programs were run on any machine at all. If so, the illegal passing of an array bound as a parameter to the procedure “Verify1” (p. 333) would surely have been caught. A second error noticed (p. 347) lies in the assumption that each link in a record chain is initially NIL, when “link” has been declared as INTEGER. (NIL is reserved as a value for pointer variables in PASCAL). Even so, the text retains its effective blend of abstract data structures, proofs of correctness, algorithmic analysis, and (PASCAL) implementations. It continues to be a good choice for upper division undergraduate, or for beginning graduate students with some degree of mathematical sophistication. The first author has, however, used half the text with well-prepared sophomores. All the material cannot be covered in a single semester, but the book is a bit slim for a full year course. This reviewer hopes that these prolific authors will find time to rewrite more of the text surrounding algorithms, include more of PASCAL's high-level data types, update the references list, revise the exercises, correct errors, and test programs. The text deserves such attention.

Reviewer: Doris C. Appleby

Even the simplest program can be considered an application of data structures, but courses and texts with the words in the title have long been part of the computer science curriculum. The recommended curriculum is in the process of revision; guidelines for a new first course appeared in 1984, and those for the second course in 1985. In Curriculum '78 [1], there were three prerequisites to the data structures course, CS7. Much of the material from that syllabus is now included in the new CS2. The authors for both the new CS1 [2] and CS2 [3] curricula expect that most students “will have taken one or more programming courses in high school,” and that those who haven't will have to do extra work on their own. Existing textbooks reflect this situation, in that most were written for CS7, to be taught at the sophomore or junior level. Many texts for the new CS1 have appeared in the last few months, and publishers promise new choices for CS2 in the near future. It is also anticipated that a new syllabus for CS7 will be more advanced when it appears. Thus, we currently have data structures texts that are too hard for CS2 students, and too elementary for an upper-level data structures course. In addition to expecting very well-prepared freshmen, both the new CS1 and CS2 are organized for a four-credit format, including a two hour laboratory each week for at least CS1. However, it is quite possible that many students will have studied nothing but BASIC in high school, and that many colleges will continue to offer three-credit courses, with or without labs. Thus, data structures could continue to be taught at the same level anticipated in Curriculum '78, with two or three rather elementary prerequisite courses. The five books chosen for review are what might be considered “semi-advanced” undergraduate texts in data structures. They are advanced in that each covers considerable material past that suggested for CS2, but are accessible to students with less background than those who have completed the full CS2 syllabus. None are entirely suitable for a course based on the new syllabus, or for an advanced CS7, enrolling students who had completed the new CS2. All but one are revisions of older texts to include Pascal. Although all of these books may be superseded by others if the proposed curriculum for CS2 becomes standard, they will be good volumes by which to measure new ones. Some will continue to be available, but none may be widely used in five years. Horowitz and Sahni This text was first published in 1976 as Fundamentals of Data Structures [4]. It has served many students as a “Bible” along with the companion volume, Fundamentals of Computer Algorithms [5], which first appeared in 1978. It was, and is, an effective blend of abstract data structure, proofs of correctness, and algorithmic analysis. The original text used a descriptive language, derived from ALGOL, to present algorithms, and expected students to code them up in either PL/I or Fortran. Students were expected to know a particular language syntax, as well as any peculiarities in either the standard or the compiler available, and to be able to fill in many of the middle steps in arriving at a particular algorithm. The original edition went through many substantially unchanged printings. This 1984 text does just what the title promises; changes the pseudocode to Pascal. Unfortunately, it does nothing else. Computer science has matured in these past ten years, to include much more emphasis on both abstraction and on software engineering. The authors, who publish prolifically, have made no efforts to update the new edition, or even to correct program errors. However, many of those now teaching data structures will have studied from the earlier edition, and will feel comfortable with this text. The original is undoubtedly the benchmark from which more recent books have been written. Kruse Of all five, this book would win the “most liked by students” award. The author believes in “progressing from the concrete to the abstract,” and presents extensive examples of program development. Data structures are introduced to solve particular problems and to improve the runtime performance of earlier programs. Thus, Kruse motivates an abstract data type from a particular application, reversing the currently advocated pedagogy. Algorithmic analysis is addressed, but only in so far as it can be achieved by the techniques of high school algebra. I found myself eager to keep reading and assume students would do so also. There are many programming projects, from revising or completing procedures presented to group projects. Kruse agrees with the inclusion of software engineering techniques and practice early in one's student career. Although it includes work well beyond that proposed in the new CS2 syllabus, it is a viable candidate for use as the primary text for CS2. Then why didn't I choose it for my students__?__ It kept sitting there on my desk in the candidate pile week after week. Although it is an excellent book, per se, it will probably not become a standard for CS2. It is not mathematical enough for students who have already taken a course in discrete mathematics, and it reverses the trend in the undergraduate computer science curriculum to be more like the “real” sciences in establishing a theory first, from which applications flow. None the less, I relegated it to the supplementary shelf with regret. Reingold and Hansen Reingold and Hansen have revised their 1983 text [6] to be Pascal-based, rather than language independent. As such, it becomes much more accessible to lower division students, who are not yet programming experts; that is, if their primary programming language is Pascal. (Is the Modula-2 edition to follow__?__) This book is, to my mind, a true data structures text. It uniformly follows a technique of stating clearly and succinctly what the abstract structure in question is, and what its associated operations do. The authors then present examples and Pascal code. When the topic lends itself, excellent diagrams are included. One of the real pleasures in reading this text is its literateness. Remarks and excellently annotated references at the end of each chapter introduce the student to computer science classics and the pioneers in the field. I was particularly pleased to find one problem in the section on trees based on a little known work by Lewis Carroll. Every bit of the Pascal code has been checked for syntactic accuracy. I briefly wondered, on reading the Preface to this edition, why they had not made trial runs as well. Which brings us to the unsuitability of this excellent book for most CS2s. Most of the algorithms are for single procedures, unincorporated into larger programs. Exercises are mostly of the “draw a diagram,” “design an algorithm to do [some small task],” “modify [some small algorithm] to . . . ,” or “what is the effect of [a few lines of code]” variety. Most CS2 students need to be writing increasingly larger programs that work. However, for a two-quarter or two-semester course in data and file structures, or for students who are either competent programmers or becoming competent in another course, Reingold and Hansen is the best of the five books under consideration here. Tenenbaum and Augenstein This text is widely used in colleges and even in some high schools. It presents numerous algorithms and the data structures necessary to implement them, and is organized for a course in which weekly programming assignments are expected. It is not really a very good book, either in style or in approach (as has been noted by previous reviewers), but does lend itself to a hands-on type course. It suffers from some of the same problems of Horowitz and Sahni, in that it was “translated” from a book using PL/I, and pays little heed to superior features of Pascal. If one were choosing a text for a CS2 course, this would be one of the few now available that would do, in that it covers all the topics at the level of a second semester freshman. The original reviewer did not consider the book a worthy addition to his library, much less the primary text for a course. And yet, one still sees it sticking from the book bags of multitudes of young undergraduates. The second edition is a substantial improvement over the first. Its increased size, from 545 to 774 pages, is due in part to a larger type size, which makes for easier reading. There are also new features. A good description and notation for abstract data types is presented in the introductory chapter, but it is used only to introduce stacks and queues. Nothing has been removed from the first edition, but material has been added on priority queues, general search and B-trees, dynamic hashing, graph traversals, and spanning forests. A new, 73-page Chapter 10 discusses storage management, including garbage collection. The chapter on trees has been largely rewritten, to good advantage, and the graph material moved appropriately from Chapter 7 to Chapter 9. Those who liked the old text will welcome this second edition, but it is not different enough to convert the disaffected. Tremblay and Sorenson This book would be a valuable resource in any student's library. It is, literally, encyclopedic. It includes a great deal of advanced material, such as formal grammars, the basic features of LISP, and an introduction to database systems. An instructor could not cover it all in two semesters, and leaving out some of the early material produces a rather disjointed course. One of the real strengths of the text is the linking of specific hardware implementations to the data structure under consideration. This, of course, flies in the face of an emphasis on abstraction, but for those looking for an engineering (in contrast to the possibly misnamed software engineering) approach, Tremblay and Sorenson offer a lot. A section on algorithmic analysis has been added to the introductory chapter, and subsequent algorithms are analyzed. The authors assume the readers are familiar with combinatorial mathematics, including recurrence relations, but state that such sections can be omitted. Extreme care has been lavished on excellent diagrams throughout. The text includes a long Chapter 7, on file processing. For this, the authors switch from Pascal to PL/I, to take advantage of its superior file handling features. It would be suitable for a two-semester course in data structures and file processing, at the sophomore level, but would be problematic for a one-semester course on either topic. Tables 1 and 2 summarize numerical and qualitative information about the five texts considered.