Previous Section
 < Free Open Study > 
Next Section


List of Figures

Chapter 1: Software Engineering Principles

Figure 1.1: An abstraction includes the essential details relative to the perspective of the viewer.
Figure 1.2: A blank CRC card
Figure 1.3: A portion of a functional design for baking a cake
Figure 1.4: This graph demonstrates the importance of early detection of software errors.
Figure 1.5: Checklist for deskchecking a C++ program
Figure 1.6: Testing approaches
Figure 1.7a: Checking out all the branches
Figure 1.7b: Checking out all the trails
Figure 1.8: Model of test architecture
Figure 1.9: Life-cycle verification activities

Chapter 2: Data Design and Implementation

Figure 2.1: The decimal equivalents of an 8-bit binary number
Figure 2.2: A black box representing an integer
Figure 2.3: A collection of books ordered in different ways
Figure 2.4: Communication between the application level and implementation level
Figure 2.5: Record myCar
Figure 2.6: Memory configurations
Figure 2.7: Implementation-level view of CarType
Figure 2.8: Inheritance hierarchy

Chapter 3: ADTs Unsorted List and Sorted List

Figure 3.1: Data members of class UnsortedType
Figure 3.2: Retrieving an item in an unsorted list
Figure 3.3: Deleting an item in an unsorted list
Figure 3.4: Inserting into a sorted list
Figure 3.5: Retrieving in a sorted list
Figure 3.6: A binary search of the phone book
Figure 3.7: Trace of the binary search algorithm
Figure 3.8: Map to Joe's Diner
Figure 3.9: Comparison of linear and binary searches
Figure 3.10: Complexity bins
Figure 3.11: A scenario walk-through in progress
Figure 3.12: Problem statement with nouns circled and verbs underlined
Figure 3.13: The data objects in the case study
Figure 3.14: The high-level processing of the case study
Figure 3.15: Relationships among the views of data

Chapter 4: ADTs Stack and Queue

Figure 4.1: Real-life stacks
Figure 4.2: The effects of Push and Pop operations
Figure 4.3: Well-formed and ill-formed expressions
Figure 4.4: The effect of a Pop following a series of Pushes
Figure 4.5: A stack in which the array is in dynamic storage
Figure 4.6: A FIFO queue
Figure 4.7: The effects of queue operations
Figure 4.8: The effect of Enqueue and Dequeue
Figure 4.9: Wrapping the queue elements around
Figure 4.10: An empty queue
Figure 4.11: A full queue
Figure 4.12: Testing for an empty queue
Figure 4.13: Testing for a full queue
Figure 4.14: Class interface diagram for CountedQueType class
Figure 4.15: Specification for simulation program

Chapter 5: Linked Structures

Figure 5.1: Putting new element into the allocated space
Figure 5.2: After four calls to Push
Figure 5.3: One way to keep track of the pointers
Figure 5.4: Chaining the stack elements together
Figure 5.5: Pushing the first element
Figure 5.6: A single node
Figure 5.7: Node terminology
Figure 5.8: The second Push operation
Figure 5.9: Be careful when you change pointers
Figure 5.10: Pointer dereferencing and member selection
Figure 5.11: Pushing onto an empty stack
Figure 5.12: Popping the top element
Figure 5.13: Popping the stack
Figure 5.14: Popping the last element on the stack
Figure 5.15: A linked queue representation
Figure 5.16: The Enqueue operation
Figure 5.17: A bad queue design
Figure 5.18: The Dequeue operation
Figure 5.19: A circular linked queue
Figure 5.20: Comparison of storage requirements
Figure 5.21: Honor roll list with two items (ResetList has not been called)
Figure 5.22: Retrieving an item in an unsorted linked list
Figure 5.23: Deleting an interior node and deleting the first node
Figure 5.24: Retrieving an item that is not there
Figure 5.25: Inserting at the end of the list
Figure 5.26: The inchworm effect
Figure 5.27: Four insertion cases
Figure 5.28: Deleting from a linked list

Chapter 6: Lists Plus

Figure 6.1: A circular linked list
Figure 6.2: Circular linked lists with the external pointer pointing to the rear element
Figure 6.3: Initializing for FindItem
Figure 6.4: The FindItem operation for a circular list
Figure 6.5: Inserting into a circular linked list
Figure 6.6: Deleting from a circular linked list
Figure 6.7: A linear doubly linked list
Figure 6.8: Insertions into singly and doubly linked lists
Figure 6.9: Linking the new node into the list
Figure 6.10: Deleting from a doubly linked list
Figure 6.11: An "empty" list with a header and a trailer
Figure 6.12: Stack is a value parameter
Figure 6.13: Shallow copy versus deep copy of a stack
Figure 6.14: Relative position of pointers at the beginning of each iteration
Figure 6.15: Array-based lists in static and dynamic storage
Figure 6.16: Linked lists in static and dynamic storage
Figure 6.17: A sorted list stored in an array of records
Figure 6.18: An array with a linked list of values and free space
Figure 6.19: An array with three lists (including the free list)
Figure 6.20: List and linked structure are together
Figure 6.21: A circular doubly linked list
Figure 6.22: Inserting at the front and at the rear
Figure 6.23: Representing large integers with linked lists
Figure 6.24: An instance of class LargeInt

Chapter 7: Programming with Recursion

Figure 7.1: Function ValueInList in midexecution
Figure 7.2: Calculating Combinations (4. 3)
Figure 7.3: Recursive RevPrint
Figure 7.4: Static allocation of space for a program with three functions
Figure 7.5: The sample program loaded in memory
Figure 7.6: Calculating Combinations(6, 4)
Figure 7.7: Ordering a list using the quick sort algorithm
Figure 7.8: Function split

Chapter 8: Binary Search Trees

Figure 8.1: A binary tree
Figure 8.2: Binary trees with ten nodes
Figure 8.3: A binary search tree
Figure 8.4: Node terminology for a tree node
Figure 8.5: Two binary search trees
Figure 8.6: Tracing the Retrieve operation
Figure 8.7: Insertions into a binary search tree
Figure 8.8: The recursive Insert operation
Figure 8.9: The tree parameter is a pointer within the tree
Figure 8.10: The input order determines the shape of the tree
Figure 8.11: Deleting a leaf node
Figure 8.12: Deleting a node with one child
Figure 8.13: Deleting a node with two children
Figure 8.14: Deletions from a binary search tree
Figure 8.15: Printing all the nodes in order
Figure 8.16: Visualizing binary tree traversals
Figure 8.17: Three tree traversals
Figure 8.18: Using the function FindNode to find the insertion point
Figure 8.19: Pointers nodePtr and parentPtr are external to the tree
Figure 8.20: Pointer parentPtr is external to the tree, but parentPtr-> left is an actual pointer in the tree
Figure 8.21: A binary tree and its array representation
Figure 8.22: Examples of binary trees
Figure 8.23: A binary search tree stored in an array with dummy values

Chapter 9: Priority Queues, Heaps, Graphs, and Sets

Figure 9.1: Real-life priority queue
Figure 9.2: Two heaps containing the letters "A" through "J"
Figure 9.3: The ReheapDown operation
Figure 9.4: The ReheapUp operation
Figure 9.5: Heap values in an array representation
Figure 9.6: The ReheapDown operation
Figure 9.7: The ReheapUp operation
Figure 9.8: Some examples of graphs
Figure 9.9: Two complete graphs
Figure 9.10: A weighted graph
Figure 9.11: Using a stack to store the routes
Figure 9.12: The depth-first search
Figure 9.13: Using a queue to store the routes
Figure 9.14: The breadth-first search
Figure 9.15: Graph of flight connections between cities
Figure 9.16: Adjacency list representation of graphs

Chapter 10: Sorting and Searching Algorithms

Figure 10.1: Example of straight selection sort (sorted elements are shaded)
Figure 10.2: A snapshot of the selection sort algorithm
Figure 10.3: Example of bubble sort (sorted elements are shaded)
Figure 10.4: Snapshot of bubble sort
Figure 10.5: Example of the insertion sort algorithm
Figure 10.6: A snapshot of the insertion sort algorithm
Figure 10.7: Rationale for divide-and-conquer sorts
Figure 10.8: Strategy for merging two sorted arrays
Figure 10.9: Two subarrays
Figure 10.10: Merging sorted halves
Figure 10.11: Analysis of the function MergeSort with N = 16
Figure 10.12: An unsorted array and its tree
Figure 10.13: The heap-building process
Figure 10.14: Changing contents of the array
Figure 10.15: Effect of HeapSort on the array
Figure 10.16: Sorting arrays with pointers
Figure 10.17: Using a hash function to determine the location of the element in an array
Figure 10.18: Comparing hashed and sequential lists of identical elements
Figure 10.19: Handling collisions with linear probing
Figure 10.20: A hash program with linear probing
Figure 10.21: Handling collisions with rehashing
Figure 10.22: Handling collisions by hashing with buckets
Figure 10.23: Handling collisions by hashing with chaining
Figure 10.24: Comparison of linear probing and chaining schemes
Figure 10.25: Hash scheme to handle employee records
Figure 10.26: Array after each pass
Figure 10.27: Queues after each pass

Appendix E: The Standard Template Library

Figure A.1: Relationships among iterator categories
Figure A.2: vector memory allocation
Figure A.3: string memory allocation


Previous Section
 < Free Open Study > 
Next Section
Converted from CHM to HTML with chm2web Pro 2.85 (unicode)