Instant download Data Abstraction & Problem Solving with C Walls and Mirrors pdf, docx, kindle format all chapters after payment. 0134463978, 9780134463971
Product details:
ISBN 10: 0134463978
ISBN 13: 9780134463971
Author: Frank; Timothy
This is the eBook of the printed book and may not include any media, website access codes, or print supplements that may come packaged with the bound book. For courses in C++ Data Structures Concepts of Data Abstraction and Manipulation for C++ Programmers The Seventh Edition of Data Abstraction & Problem Solving with C++: Walls and Mirrors introduces fundamental computer science concepts related to the study of data structures. The text Explores problem solving and the efficient access and manipulation of data and is intended for readers who already have a basic understanding of C++. The “walls and mirrors” mentioned in the title represent problem-solving techniques that appear throughout the text. Data abstraction hides the details of a module from the rest of the program, whereas recursion is a repetitive technique that solves a problem by solving smaller versions of the same problems, much as images in facing mirrors grow smaller with each reflection. Along with general changes to improve clarity and correctness, this Seventh Edition includes new notes, programming tips, and sample problems.
Table of contents:
Chapter 1 Data Abstraction: The Walls
Contents
Prerequisites
1.1 Object-Oriented Concepts
1.1.1 Object-Oriented Analysis and Design
1.1.2 Aspects of an Object-Oriented Solution
1.2 Achieving a Better Solution
1.2.1 Cohesion
1.2.2 Coupling
1.3 Specifications
1.3.1 Operation Contracts
1.3.2 Unusual Conditions
1.3.3 Abstraction
1.3.4 Information Hiding
1.3.5 Minimal and Complete Interfaces
1.4 Abstract Data Types
1.4.1 Designing an ADT
An appointment book.
1.4.2 ADTs That Suggest Other ADTs
1.5 The ADT Bag
1.5.1 Identifying Behaviors
1.5.2 Specifying Data and Operations
1.5.3 An Interface Template for the ADT
1.5.4 Using the ADT Bag
Example.
Summary
Exercises
Programming Problems
C++ Interlude 1 C++ Classes
Contents
Prerequisites
C1.1 A Problem to Solve
C1.1.1 Private Data Fields
C1.1.2 Constructors and Destructors
C1.1.3 Methods
Passing parameters by constant reference.
C1.1.4 Preventing Compiler Errors
C1.2 Implementing a Solution
C1.2.1 Initializers
C1.3 Templates
C1.4 Inheritance
C1.4.1 Base Classes and Derived Classes
C1.4.2 Overriding Base-Class Methods
C1.5 Virtual Methods and Abstract Classes
C1.5.1 Virtual Methods
C1.5.2 Abstract Classes
Programming Problems
Chapter 2 Recursion: The Mirrors
Contents
Prerequisites
2.1 Recursive Solutions
2.2 Recursion That Returns a Value
2.2.1 A Recursive Valued Function: The Factorial of n
2.2.2 The Box Trace
2.3 Recursion That Performs an Action
2.3.1 A Recursive Void Function: Writing a String Backward
Another solution.
2.4 Recursion with Arrays
2.4.1 Writing an Array’s Entries in Backward Order
2.4.2 Searching a Sorted Array: The Binary Search
2.4.3 Finding the Largest Value in a Sorted or Unsorted Array
2.4.4 Finding the kth Smallest Value of an Unsorted Array
2.5 Organizing Data
2.5.1 The Towers of Hanoi
2.6 More Examples
2.6.1 The Fibonacci Sequence (Multiplying Rabbits)
2.6.2 Organizing a Parade
2.6.3 Choosing k Out of n Things
2.7 Recursion and Efficiency
Summary
Exercises
Programming Problems
Chapter 3 Array-Based Implementations
Contents
Prerequisites
3.1 The Approach
3.1.1 Core Methods
3.1.2 Using Fixed-Size Arrays
3.2 An Array-Based Implementation of the ADT Bag
3.2.1 The Header File
3.2.2 Defining the Core Methods
The constructor.
The method add.
The method toVector.
The methods getCurrentSize and isEmpty.
3.2.3 Testing the Core Methods
Getting ready.
A test program.
3.2.4 Implementing More Methods
The method getFrequencyOf.
The method contains.
3.2.5 Methods That Remove Entries
The method remove.
The method clear.
3.2.6 Testing
3.3 Using Recursion in the Implementation
3.3.1 The Method getIndexOf
3.3.2 The Method getFrequencyOf
Summary
Exercises
Programming Problems
C++ Interlude 2 Pointers, Polymorphism, and Memory Allocation
Contents
Prerequisites
C2.1 Memory Allocation for Variables and Early Binding of Methods
C2.2 A Problem to Solve
C2.3 Pointers and the Program’s Free Store
C2.3.1 Deallocating Memory
C2.3.2 Avoiding Memory Leaks
C2.3.3 Avoiding Dangling Pointers
C2.4 Virtual Methods and Polymorphism
C2.5 Dynamic Allocation of Arrays
C2.5.1 A Resizable Array-Based Bag
Chapter 4 Link-Based Implementations
Contents
Prerequisites
4.1 Preliminaries
4.1.1 The Class Node
4.2 A Link-Based Implementation of the ADT Bag
4.2.1 The Header File
4.2.2 Defining the Core Methods
The default constructor.
The method add.
The method toVector.
The methods isEmpty and getCurrentSize.
4.2.3 Implementing More Methods
The method getFrequencyOf.
The method contains.
The method remove.
The method clear.
The destructor.
The copy constructor.
4.3 Using Recursion in Link-Based Implementations
4.3.1 Recursive Definitions of Methods in LinkedBag
The method toVector.
The private method getPointerTo.
4.4 Testing Multiple ADT Implementations
4.5 Comparing Array-Based and Link-Based Implementations
Summary
Exercises
Programming Problems
Chapter 5 Recursion as a Problem-Solving Technique
Contents
Prerequisites
5.1 Defining Languages
5.1.1 The Basics of Grammars
5.1.2 Two Simple Languages
Palindromes.
Strings of the form AnBn .
5.2 Algebraic Expressions
5.2.1 Kinds of Algebraic Expressions
5.2.2 Prefix Expressions
5.2.3 Postfix Expressions
5.2.4 Fully Parenthesized Expressions
5.3 Backtracking
5.3.1 Searching for an Airline Route
Representing the flight data.
The nature of the search.
A recursive strategy.
Operations on the flight map.
5.3.2 The Eight Queens Problem
Implementing a solution to the Eight Queens problem.
5.4 The Relationship Between Recursion and Mathematical Induction
5.4.1 The Correctness of the Recursive Factorial Function
Basis.
Inductive hypothesis.
Inductive conclusion.
5.4.2 The Cost of Towers of Hanoi
Basis.
Inductive hypothesis.
Inductive conclusion.
Summary
Exercises
Programming Problems
Chapter 6 Stacks
Contents
Prerequisites
6.1 The Abstract Data Type Stack
6.1.1 Developing an ADT During the Design of a Solution
6.1.2 Specifications for the ADT Stack
Refining the specification of the ADT stack.
Using the ADT stack in a solution.
An interface.
Axioms (optional).
6.2 Simple Uses of a Stack
6.2.1 Checking for Balanced Braces
6.2.2 Recognizing Strings in a Language
6.3 Using Stacks with Algebraic Expressions
6.3.1 Evaluating Postfix Expressions
6.3.2 Converting Infix Expressions to Equivalent Postfix Expressions
6.4 Using a Stack to Search a Flight Map
6.5 The Relationship Between Stacks and Recursion
Summary
Exercises
Programming Problems
C++ Interlude 3 Exceptions
Contents
Prerequisites
C3.1 Background
C3.1.1 A Problem to Solve
C3.2 Assertions
C3.3 Throwing Exceptions
C3.4 Handling Exceptions
C3.4.1 Multiple catch Blocks
C3.4.2 Uncaught Exceptions
C3.4.3 Where to Handle Exceptions
C3.5 Programmer-Defined Exception Classes
Chapter 7 Implementations of the ADT Stack
Contents
Prerequisites
7.1 An Array-Based Implementation
7.2 A Link-Based Implementation
7.3 Implementations That Use Exceptions
Summary
Exercises
Programming Problems
Chapter 8 Lists
Contents
Prerequisites
8.1 Specifying the ADT List
8.2 Using the List Operations
8.3 An Interface Template for the ADT List
Summary
Exercises
Programming Problems
Chapter 9 List Implementations
Contents
Prerequisites
9.1 An Array-Based Implementation of the ADT List
9.1.1 The Header File
9.1.2 The Implementation File
The constructor and the methods isEmpty and getLength.
The method insert.
The method getEntry.
A client.
The method replace.
The method remove.
The method clear.
9.2 A Link-Based Implementation of the ADT List
9.2.1 The Header File
9.2.2 The Implementation File
The constructor.
The method getEntry.
The method getNodeAt.
The method insert.
The method remove.
The method clear.
The destructor.
The remaining methods.
9.2.3 Using Recursion in LinkedList Methods
The method insert.
Tracing an addition to the list’s beginning.
Tracing an addition to the list’s interior.
9.3 Comparing Implementations
Summary
Exercises
Programming Problems
C++ Interlude 4 Safe Memory Management Using Smart Pointers
Contents
Prerequisites
C4.1 Raw Pointers
C4.2 Smart Pointers
C4.2.1 Using Shared Pointers
C4.2.2 Revised Node and LinkedList Classes
C4.2.3 Using Unique Pointers
C4.2.4 Using Weak Pointers
C4.3 Other Smart Pointer Features
C4.3.1 A Method Common to All Smart Pointers
C4.3.2 A Method Common to All Shared and Unique Pointers
C4.3.3 Methods Exclusive to Shared Pointers
C4.3.4 A Method Exclusive to Unique Pointers
C4.3.5 Unique Pointers with Arrays
Chapter 10 Algorithm Efficiency
Contents
Prerequisites
10.1 What Is a Good Solution?
10.2 Measuring the Efficiency of Algorithms
10.2.1 The Execution Time of Algorithms
Traversal of linked nodes.
The Towers of Hanoi.
Nested loops.
10.2.2 Algorithm Growth Rates
10.2.3 Analysis and Big O Notation
Properties of growth-rate functions.
Worst-case and average-case analyses.
10.2.4 Keeping Your Perspective
10.2.5 The Efficiency of Searching Algorithms
Sequential search.
Binary search.
Summary
Exercises
Programming Problems
Chapter 11 Sorting Algorithms and Their Efficiency
Contents
Prerequisites
11.1 Basic Sorting Algorithms
11.1.1 The Selection Sort
Analysis.
11.1.2 The Bubble Sort
Analysis.
11.1.3 The Insertion Sort
Analysis.
11.2 Faster Sorting Algorithms
11.2.1 The Merge Sort
Analysis.
11.2.2 The Quick Sort
Partitioning the array.
Entries equal to the pivot.
Selecting a pivot.
Adjusting the partition algorithm.
A function for the quick sort.
Analysis.
11.2.3 The Radix Sort
Analysis.
11.3 A Comparison of Sorting Algorithms
Summary
Exercises
Programming Problems
C++ Interlude 5 Class Relationships and Reuse
Contents
Prerequisites
C5.1 Inheritance Revisited
C5.1.1 Public, Private, and Protected Sections of a Class
C5.1.2 Public, Private, and Protected Inheritance
C5.1.3 Is-a and As-a Relationships
Is-a relationships.
As-a relationships.
C5.2 Containment: Has-a Relationships
C5.3 Abstract Base Classes Revisited
Chapter 12 Sorted Lists and Their Implementations
Contents
Prerequisites
12.1 Specifying the ADT Sorted List
12.1.1 An Interface Template for the ADT Sorted List
12.1.2 Using the Sorted List Operations
12.2 A Link-Based Implementation
12.2.1 The Header File
12.2.2 The Implementation File
The method insertSorted.
The private method getNodeBefore.
12.2.3 The Efficiency of the Link-Based Implementation
12.3 Implementations That Use the ADT List
12.3.1 Containment
The header file.
The constructors and destructor.
The method insertSorted.
The method removeSorted.
The method getPosition.
The remaining methods.
Efficiency issues.
12.3.2 Public Inheritance
The header file.
Method definitions.
Overridden methods.
Efficiency issues.
12.3.3 Private Inheritance
Summary
Exercises
Programming Problems
Chapter 13 Queues and Priority Queues
Contents
Prerequisites
13.1 The ADT Queue
13.2 Simple Applications of the ADT Queue
13.2.1 Reading a String of Characters
13.2.2 Recognizing Palindromes
13.3 The ADT Priority Queue
13.3.1 Tracking Your Assignments
13.4 Application: Simulation
13.5 Position-Oriented and Value-Oriented ADTs
Summary
Exercises
Programming Problems
Chapter 14 Queue and Priority Queue Implementations
Contents
Prerequisites
14.1 Implementations of the ADT Queue
14.1.1 An Implementation That Uses the ADT List
14.1.2 A Link-Based Implementation
The method enqueue.
The method dequeue.
Retrieval.
14.1.3 An Array-Based Implementation
The header file.
The implementation file.
Variations.
14.1.4 Comparing Implementations
14.2 An Implementation of the ADT Priority Queue
Summary
Exercises
Programming Problems
C++ Interlude 6 Overloaded Operators and Friend Access
Contents
Prerequisites
C6.1 Overloaded Operators
C6.1.1 Overloading = for Assignment
C6.1.2 Overloading + for Concatenation
Link-based lists.
Array-based lists.
C6.2 Friend Access and Overloading <<
Chapter 15 Trees
Contents
Prerequisites
15.1 Terminology
15.1.1 Kinds of Trees
Example: Algebraic expressions.
15.1.2 The Height of Trees
15.1.3 Full, Complete, and Balanced Binary Trees
15.1.4 The Maximum and Minimum Heights of a Binary Tree
15.2 The ADT Binary Tree
15.2.1 Traversals of a Binary Tree
Preorder traversal.
Inorder traversal.
Postorder traversal.
Visiting a node.
15.2.2 Binary Tree Operations
Example.
15.2.3 An Interface Template for the ADT Binary Tree
15.3 The ADT Binary Search Tree
15.3.1 Binary Search Tree Operations
Example.
15.3.2 Searching a Binary Search Tree
15.3.3 Creating a Binary Search Tree
Example.
15.3.4 Traversals of a Binary Search Tree
15.3.5 The Efficiency of Binary Search Tree Operations
Summary
Exercises
Programming Problems
Chapter 16 Tree Implementations
Contents
Prerequisites
16.1 The Nodes in a Binary Tree
16.1.1 An Array-Based Representation
The free list.
16.1.2 A Link-Based Representation
16.2 A Link-Based Implementation of the ADT Binary Tree
16.2.1 The Header File
16.2.2 The Implementation
The constructors.
The copy constructor and destructor.
The method getHeight.
The method add.
The traversals.
Nonrecursive traversal (optional).
16.3 A Link-Based Implementation of the ADT Binary Search Tree
16.3.1 Algorithms for the ADT Binary Search Tree Operations
Adding a new entry.
Removing an entry.
Retrieving an entry.
16.3.2 The Class BinarySearchTree
16.4 Saving a Binary Search Tree in a File
16.5 Tree Sort
16.6 General Trees
Summary
Exercises
Programming Problems
Chapter 17 Heaps
Contents
Prerequisites
17.1 The ADT Heap
17.2 An Array-Based Implementation of a Heap
17.2.1 Algorithms for the Array-Based Heap Operations
Retrieving an item from a heap.
Removing an item from a heap.
Adding a data item to a heap.
17.2.2 The Implementation
Some method definitions.
17.3 A Heap Implementation of the ADT Priority Queue
17.4 Heap Sort
Summary
Exercises
Programming Problems
C++ Interlude 7 Iterators
Contents
Prerequisites
C7.1 Iterators
C7.1.1 Common Iterator Operations
C7.1.2 Using Iterator Operations
C7.1.3 Implementing an Iterator
C7.2 Advanced Iterator Functionality
Chapter 18 Dictionaries and Their Implementations
Contents
Prerequisites
18.1 The ADT Dictionary
18.1.1 An Interface for the ADT Dictionary
18.2 Possible Implementations
18.2.1 A Sorted Array-Based Implementation of the ADT Dictionary
18.2.2 A Binary Search Tree Implementation of the ADT Dictionary
The header file.
The method implementations.
18.3 Selecting an Implementation
18.3.1 Three Scenarios
Scenario A: Addition and traversal in no particular order.
Scenario B: Retrieval.
Scenario C: Addition removal, retrieval, and traversal in sorted order.
Summary.
18.4 Hashing as a Dictionary Implementation
18.4.1 Hash Functions
Selecting digits.
Folding.
Modulo arithmetic.
Converting a character string to an integer.
18.4.2 Resolving Collisions Using Open Addressing
18.4.3 Resolving Collisions By Restructuring the Hash Table
18.4.4 The Efficiency of Hashing
Linear probing.
Quadratic probing and double hashing.
Separate chaining.
Comparing techniques.
18.4.5 What Constitutes a Good Hash Function?
18.4.6 Dictionary Traversal: An Inefficient Operation Under Hashing
18.4.7 Using Hashing and Separate Chaining to Implement the ADT Dictionary
The hash table.
The method add.
The method remove.
Summary
Exercises
Programming Problems
Chapter 19 Balanced Search Trees
Contents
Prerequisites
19.1 Balanced Search Trees
19.2 AVL Trees
19.3 2-3 Trees
19.3.1 Traversing a 2-3 Tree
19.3.2 Searching a 2-3 Tree
19.3.3 Adding Data to a 2-3 Tree
Add 39.
Add 38.
Add 37.
Add 36.
Add 35, 34, and 33.
The addition algorithm.
19.3.4 Removing Data from a 2-3 Tree
Remove 70.
Remove 100.
Remove 80.
The removal algorithm.
19.4 2-3-4 Trees
19.4.1 Searching and Traversing a 2-3-4 Tree
19.4.2 Adding Data to a 2-3-4 Tree
Add 20.
Add 50 and 40.
Add 70.
Add 80 and 15.
Add 90.
Add 100.
Splitting 4-nodes during additions.
19.4.3 Removing Data from a 2-3-4 Tree
19.5 Red-Black Trees
19.5.1 Searching and Traversing a Red-Black Tree
19.5.2 Adding to and Removing from a Red-Black Tree
Summary
Exercises
Programming Problems
Chapter 20 Graphs
Contents
Prerequisites
20.1 Terminology
20.2 Graphs as ADTs
20.2.1 Implementing Graphs
20.3 Graph Traversals
20.3.1 Depth-First Search
20.3.2 Breadth-First Search
20.4 Applications of Graphs
20.4.1 Topological Sorting
20.4.2 Spanning Trees
The DFS spanning tree.
The BFS spanning tree.
20.4.3 Minimum Spanning Trees
20.4.4 Shortest Paths
20.4.5 Circuits
20.4.6 Some Difficult Problems
The traveling salesperson problem.
The three utilities problem.
The four-color problem.
Summary
Exercises
Programming Problems
Chapter 21 Processing Data in External Storage
Contents
Prerequisites
21.1 A Look at External Storage
21.2 Working with External Data
21.2.1 Sorting Data in an External File
21.2.2 Basic Data Management Operations
21.2.3 Indexing an External File
21.2.4 External Hashing
Retrieval when an index file uses external hashing.
Addition when an index file uses external hashing.
Removal when an index file uses external hashing.
21.2.5 B-Trees
Adding a record to a B-tree.
Removing a record from a B-tree.
21.2.6 Traversals
21.2.7 Multiple Indexing
Summary
Exercises
Programming Problems
C++ Interlude 8 The Standard Template Library
Contents
C8.1 STL Containers
C8.1.1 STL Container Adapters
C8.1.2 Sequence Containers
The sequence container array.
The STL class vector.
The STL container deque.
The STL class list.
The STL container forward_list.
C8.1.3 Associative Containers
C8.2 STL Algorithms
Appendix A Review of C++ Fundamentals
Contents
Prerequisite
A.1 Language Basics
A.1.1 Comments
A.1.2 Identifiers and Keywords
A.1.3 Primitive Data Types
A.1.4 Variables
A.1.5 Literal Constants
A.1.6 Named Constants
A.1.7 Enumerations
A.1.8 The typedef Statement
A.1.9 Assignments and Expressions
Arithmetic expressions.
Relational and logical expressions.
Conditional expressions.
Implicit type conversions.
Explicit type conversions.
Other assignment operators.
A.2 Input and Output Using iostream
A.2.1 Input
A.2.2 Output
A.2.3 Manipulators
A.3 Functions
A.3.1 Standard Functions
A.4 Selection Statements
A.4.1 The if Statement
A.4.2 The switch Statement
A.5 Iteration Statements
A.5.1 The while Statement
A.5.2 The for Statement
A.5.3 The do Statement
A.6 Arrays
A.6.1 One-Dimensional Arrays
Initialization.
Passing an array to a function.
A.6.2 Multidimensional Arrays
Initialization.
A.7 Strings
A.8 Vectors
A.9 Classes
A.9.1 The Header File
A.9.2 The Implementation File
Constructors.
A.9.3 Using the Class Sphere
A.9.4 Inheritance
A.10 Libraries
A.11 Namespaces
Summary
Appendix B Important Themes in Programming
Contents
Prerequisites
B.1 Modularity
B.2 Style
B.2.1 Use of Private Data Members
B.2.2 Proper Use of Reference Arguments
B.2.3 Proper Use of Methods
B.2.4 Avoidance of Global Variables in Modules
B.2.5 Error Handling
B.2.6 Readability
B.2.7 Documentation
B.3 Modifiability
B.3.1 Named Constants
B.3.2 The typedef Statement
B.4 Ease of Use
B.5 Fail-Safe Programming
B.5.1 Guarding Against Errors in Input Data
B.5.2 Guarding Against Errors in Program Logic
B.6 Debugging
B.6.1 Debugging Functions and Methods
B.6.2 Debugging Loops
B.6.3 Debugging if Statements
B.6.4 Using cout Statements
B.6.5 Using Special Dump Functions
B.7 Testing
B.7.1 Levels of Testing
B.7.2 Kinds of Testing
B.7.3 Developing Test Data
B.7.4 Testing Techniques
B.7.5 Use of Stubs
Appendix C The Unified Modeling Language
Contents
Prerequisites
C.1 The Use Case
C.2 UML Sequence Diagrams
C.3 UML Class Diagrams
C.4 Keeping the UML in Perspective
Appendix D The Software Life Cycle
Contents
Prerequisites
D.1 Iterative and Evolutionary Development
D.2 Rational Unified Process Development
D.2.1 Inception Phase
D.2.2 Elaboration Phase
D.2.3 Construction Phase
D.2.4 Transition Phase
D.3 What About the Waterfall Method of Development?
Appendix E Mathematical Induction
Appendix F Algorithm Verification
Prerequisite
Appendix G C++ File Fundamentals
Contents
Prerequisite
G.1 File Input and Output
G.2 Text Files
G.2.1 Opening and Closing Text Files
G.2.2 Reading and Writing Text Files
G.2.3 Manipulating Text Files
G.3 Binary Files
Appendix H C++ Header Files and Standard Functions
cassert
cctype
cmath
cstdlib
cstring
fstream
iomanip
iostream
stdexcept
string
Appendix I C++ Documentation Systems
Appendix J ASCII Character Codes
Appendix K C++ for Java Programmers
Contents
K.1 General Concepts
K.2 Data Types, Variables, Constants, and Arrays
K.3 Flow Control and Functions
K.4 Classes
K.5 Basic Input and Output
Appendix L C++ for Python Programmers
Contents
L.1 General Concepts
L.2 Comparison of Language Elements
L.3 Functions
L.4 Classes
Index
People also search:
data abstraction and problem solving with java
data abstraction and problem solving with c++
abstraction problem solving
problem solving abstraction
Reviews
There are no reviews yet.