Algorithms and data structures: Computing Science Excerpt from: algorithms and data structures: the Science of Computing
By Douglas Baldwin and Greg W. scragg
Translated by Liu Jianwen (http://blog.csdn.net/keminlau
Charles River media 2004 (640 pages)
While computing science textbooks are confined to teaching programming code and languages ages, algorithms and
Data structures: the science of computing takes a step back to introduce and Alibaba e algorithms -- the content of the Code. focusing on three core topics: Design (the architecture of algorithms), theory (mathematical modeling and analysis), and the scientific method (Experimental confirmation of theoretical results ), the book helps students see that computer science is about problem solving, not simply the memorization and recitation of ages. unlike extends other texts, the methods of inquiry are explained in an integrated manner so students can see explicitly how they interact. recursion and object oriented programming are emphasized as the main control structure and adjust action mechanisms, respectively, in algorithm design.
Many computer science textbooks teach (and are limited to) how to write code in programming languages at the beginning, which is not enough. This book serves as a supplement to knowledge. Let's take a step back and talk about the essence of Code-algorithms.
This book focuses on three topics: Design (algorithm architecture), theory (mathematical models and analysis), and scientific methods (empirical evidence of theoretical results ). This book reminds students that computer science is about problem solving, rather
It is a simple rote memorization of a programming language.
In addition, this book also provides a systematic and comprehensive explanation of the question method (methods of inquiry), so that students can pay attention to the difference between the question method and the working principle. Recursive and object-oriented programming are the key points in algorithm design [Control Structure
] And [Abstraction Mechanism
Algorithms and data structures: the Science of computing (which we usually refer to simply as the science of computing) is about understanding computation. we see it as a distinct departure from previous second-Course Computer Science texts, which emphasize building computations. the science of computing develops understanding by coupling algorithm design to mathematical and experimental techniques for modeling and observing algorithms 'behavior. its attention to rigorous scientific experimentation maid it from other computing texts. the science of computing introduces students to computer science's three core methods of inquiry: design, mathematical theory, and the scientific method. it introduces these methods early in the curriculum, so that students can use them throughout their studies. the book uses a stronugly hands-on approach to demonstrate the importance of, and interactions between, all three methods.
The main goal of this book is to understand what computing is, rather than focusing on how to build computing in other books. In order to understand the nature of computing, this book coupled algorithm design and mathematical methods and Experiments
Technology to capture and model algorithm behavior. Unlike general teaching materials, this book pays special attention to academic rigor. This book introduces three core research methods in Computer Science: design, mathematical theory, and science.
Method. These three research methods will be used for the entire study of the students, so the sooner you get familiar with them, the more beneficial.
Organization of this book
The science of computing has four parts. the titles of those parts, while descriptive, can be misleading if considered out of context. all three methods of inquiry are addressed in every part, but the emphasis shifts as students mature.
This book is divided into four parts. without considering the context, the title of each part may be misleading. The three research methods will appear in each part, but will become more and more in-depth.
For example, Part I: The Science of computing's three methods of inquiry has four chapters, the first of which is an introduction to the text in the usual form. it is in that chapter that we introduce the first surprise of the Course: that the obvious algorithm may not be the best. the other three chapters serve to highlight the three methods of inquiry used throughout this text. these chapters are the only place where the topics are segregated-all subsequent chapters integrate topics from each of the methods of inquiry.
For example, the first part is the three research methods of computer science. There are four chapters. The first chapter is a general introduction. In this chapter, we introduce the first shocking fact, that is, the highly-respected algorithms are often not the best. The remaining three chapters describe the three research methods respectively. These three chapters are the only three independent research methods in this book. The following sections will be based on these three research methods.
The central theme of Part II: program design is indeed the design of programs. it reviews standard control structures, but treats each as a design tool for solving certain kinds of problems, with mathematical limitations for handling about its correctness and performance, and experimental techniques for confirming the mathematical results. recursion and related Mathematics (induction and Recurrence Relations) are the heart of this part of the book.
The second part of the spindle program design. This section repeat some common control structures. However, we regard these control structures as tools to deal with specific types of problems and use mathematical knowledge to reason their correctness and efficiency, use practical techniques to verify these mathematical conclusions. Recursion and related mathematical knowledge (inductive and recursive relationships) are the core content of this part.
Armed with these tools, students are ready for Part III: data structures (the central topic of your CS 2 texts ). the tools related to algorithm analysis and to recursion, specifically, can be applied directly to the development of recursively defined data structures, including trees, lists, stacks, queues, hash tables, and priority queues. we present these structures in a manner that continues the themes of Parts I and II: lists as an example of how ideas of repetition and Recursion (and related analytic techniques) can be applied to structuring data just as they structured control; stacks and queues as adaptations of the list structure to special applications; trees as structures that improve theoretical and empirical performance; and hash tables and priority queues as case studies in generalizing the previous ideas and applying them to new problems.
With the above tools armed, students can start the next part-the third part: data structure. Tools (knowledge) related to algorithm analysis, especially recursion, can be used directly to create a recursive data structure, including tree, list, stack, queue, hash, and priority queue. We continue to describe these data structures in the way of undertaking the theme of Part 1: Just as process control can be structured, data can also be structured; A list is an example of how to use repetitive and recursive ideas (and related analysis techniques) to structure data. Stacks and queues are a list structure adjusted for special applications; the (hierarchical structure) tree can improve the (algorithm) Performance theoretically and practically, while the hash and priority queue are the previous ideas (Kemin: is a good case where data can be structured and adjusted based on specific problems) and applied to new problems.
Finally, Part IV: the limits of computer science takes students through material that might normally be reserved for later theory courses, using the insights that students have developed for both algorithms and data structures to understand just how big some problems are and the recognition that faster computers will not solve all problems.
Finally, Part 4-The limits of computer science-will bring some materials that are generally retained for subsequent theoretical courses to the students, objective To understand how difficult the data structures and algorithms are, and realize that even high-performance computers cannot solve all the problems.
Part I: The Science of computing's three methods of inquiry
Chapter 1: What is the science of computing? What is computing science?
Chapter 2: Role Action: An Introduction to design
Chapter 3: Proof: An Introduction to Theory
Chapter 4: experimentation: An Introduction to the scientific method
Does it strike you that there's a certain self-contradiction in the term "computer science "? "Computer" refers to a kind of man-made machine; "science" suggests discovering rules that describe how some part of the universe works. "Computer Science" shocould therefore be the discovery of rules that describe how computers work. but if computers are machines, surely the rules that determine how they work are already understood by the people who make them. what's left for computer science to Di Scover?
Do you think the word "Computer Science" is a bit self-contradictory? "Computer" refers to an artificial machine, while "science" refers to discovering the laws of motion of things in the universe. Thus, "Computer Science" is to explore computing
The machine's motion pattern. But if a computer is a runable machine, aren't people having mastered its motion pattern when creating it? Is there anything left for computer science?
The problem with the phrase "Computer Science" is its use of the word "computer. "" computer "Science isn' t the study of computers; it's the study of computing, in other words, the study of processes for mechanic ally solving problems. the phrase "science of computing" emphasizes this concern with general computing processes instead of with machines.   In fact, partition parts of the world outside the United States call the field "informatics," because it is more concerned with information and information processing than with machines.
The problem of "Computer Science" lies in "computer. Computer science is not about computers, but about computing. In other words, it is about solving problems mechanically (automatically. Therefore, "Computing Science" is more pertinent than machine science. Many countries simply call this field information science, and it is more pertinent to use information science or information processing than machines.
The first four chapters of this book explain the idea of "processes" that solve problems and introduce the methods of inquiry with which computer scientists study those processes. these methods of inquiry include designing the processes, mathematically modeling how the processes shold behave, and experimentally verifying that the processes behave in practice as they shold in theory.
Part III: Introduction to Data Structures
Chapter 11: Lists
Chapter 12: queues and stacks
Chapter 13: Binary Trees
Chapter 14: Case Studies in design: inserting acting indirection
The emphasis of the first half of this text has been on actions (methods or algorithms): types of actions, defining new actions, predicting results, and evaluating actions. but the objects manipulated by algorithms can be quite interesting in their own right. in fact some algorithms all but require new perspectives on the nature of objects. this section expands the concept of object and investigates the implications of that expansion on the algorithms that manipulate them.
The first half of this book focuses on "actions" (actions methods or algorithms): Action types, defining new actions, predicting results, and evaluating actions. However, the data objects operated by algorithms also have interesting properties or rules ............ This section describes the concept of a Data Object (operated by an algorithm, however, when the reader still does not understand the indirect concept, he must further interpret the indirect concept. The meaning of the expanded concepts in the algorithm.
Thus far, objects have been viewed as fixed entities, fully specified by their class. the internal structure of an object does not change over time. A robot can't grow a new wheel, develop a new color palette, or rearrange its internal components. but some problems do require such references to or manipulation of the relationship of an object's subparts to each other or to the object as a whole. part III describes techniques that enable an object to change in important ways. the resulting object classes with internally addressable structures are called data structures: subparts can be added, removed, reordered, or queried. the three methods of inquiry developed in parts I and II continue to provide the cornerstone of the investigation, but the four chapters of Part III also add to that collection of tools to describe four classes of data structures and conclude by using those tools in new situations, developing new problem solutions.
So far, data objects have been regarded as a fixed whole, all of which are specified by their types. The internal structure of the data object will not change. However, there are some problems that we do need to access and manipulate the sub-objects inside the Data Object ............ This section describes how to manipulate sub-objects inside a data object. The new data objects that can be accessed in this way are called data structures: internal objects can be added, deleted, reorganized, and queried.