choice of good solutions for a given problem. The partitioning into methods for sorting arrays and
methods for sorting files (often called internal and external sorting) exhibits the crucial influence of data
representation on the choice of applicable algorithms and on their complexity. The space allocated to
sorting would not be so large were it not for the fact that sorting constitutes an ideal vehicle for
illustrating so many principles of programming and situations occurring in most other applications. It
often seems that one could compose an entire programming course by deleting examples from sorting
only.
Another topic that is usually omitted in introductory programming courses but one that plays an
important role in the conception of many algorithmic solutions is recursion. Therefore, the third chapter
is devoted to recursive algorithms. Recursion is shown to be a generalization of repetition (iteration), and
as such it is an important and powerful concept in programming. In many programming tutorials, it is
unfortunately exemplified by cases in which simple iteration would suffice. Instead, Chap. 3 concentrates
on several examples of problems in which recursion allows for a most natural formulation of a solution,
whereas use of iteration would lead to obscure and cumbersome programs. The class of backtracking
algorithms emerges as an ideal application of recursion, but the most obvious candidates for the use of
recursion are algorithms operating on data whose structure is defined recursively. These cases are treated
in the last two chapters, for which the third chapter provides a welcome background.
Chapter 4 deals with dynamic data structures, i.e., with data that change their structure during the
execution of the program. It is shown that the recursive data structures are an important subclass of the
dynamic structures commonly used. Although a recursive definition is both natural and possible in these
cases, it is usually not used in practice. Instead, the mechanism used in its implementation is made
evident to the programmer by forcing him to use explicit reference or pointer variables. This book
follows this technique and reflects the present state of the art: Chapter 4 is devoted to programming with
pointers, to lists, trees and to examples involving even more complicated meshes of data. It presents what
is often (and somewhat inappropriately) called list processing. A fair amount of space is devoted to tree
organizations, and in particular to search trees. The chapter ends with a presentation of scatter tables, also
called "hash" codes, which are oftern preferred to search trees. This provides the possibility of comparing
two fundamentally different techniques for a frequently encountered application.
Programming is a constructive activity. How can a constructive, inventive activity be taught? One
method is to crystallize elementary composition priciples out many cases and exhibit them in a
systematic manner. But programming is a field of vast variety often involving complex intellectual
activities. The belief that it could ever be condensed into a sort of pure recipe teaching is mistaken. What
remains in our arsenal of teaching methods is the careful selection and presentation of master examples.
Naturally, we should not believe that every person is capable of gaining equally much from the study of
examples. It is the characteristic of this approach that much is left to the student, to his diligence and
intuition. This is particularly true of the relatively involved and long example programs. Their inclusion
in this book is not accidental. Longer programs are the prevalent case in practice, and they are much
more suitable for exhibiting that elusive but essential ingredient called style and orderly structure. They
are also meant to serve as exercises in the art of program reading, which too often is neglected in favor of
program writing. This is a primary motivation behind the inclusion of larger programs as examples in
their entirety. The reader is led through a gradual development of the program; he is given various
snapshots in the evolution of a program, whereby this development becomes manifest as a stepwise
refinement of the details. I consider it essential that programs are shown in final form with sufficient
attention to details, for in programming, the devil hides in the details. Although the mere presentation of
an algorithm's principle and its mathematical analysis may be stimulating and challenging to the
academic mind, it seems dishonest to the engineering practitioner. I have therefore strictly adhered to the
rule of presenting the final programs in a language in which they can actually be run on a computer.
Of course, this raises the problem of finding a form which at the same time is both machine executable
and sufficiently machine independent to be included in such a text. In this respect, neither widely used
languages nor abstract notations proved to be adequate. The language Pascal provides an appropriate
compromise; it had been developed with exactly this aim in mind, and it is therefore used throughout this
book. The programs can easily be understood by programmers who are familiar with some other high-
level language, such as ALGOL 60 or PL/1, because it is easy to understand the Pascal notation while
proceeding through the text. However, this not to say that some proparation would not be beneficial. The
5星 · 超过95%的资源 需积分: 32 169 浏览量
2009-08-10
00:51:24
上传
评论
收藏 1.23MB PDF 举报 
wqq7569086482013-03-09书很好，需要一定的英文基础，先收藏了
