Chapter 1: Introduction
1.1 Testing our algorithm
1.2 Devising the algorithm for the pattern on the grids
1.3 Devising the algorithm for filling in a rectangle
1.4 Devising an algorithm to find the closest point in a set S to another point P
Chapter 2: Reading Code
2.1 Variable declarations
2.2 Declarations and Assignments
2.3 Assignment statements with more complex right-hand sides
2.4 Execution of function calls
2.5 An example with printed output
2.6 Execution of if/else
2.7 Execution of switch/case
2.8 Execution of a while loop
2.9 Execution of a nested loops and ifs
2.10 Execution of continue in a for loop
Chapter 3: Types
3.1 Execution of our naive code for computing the hours in a 7 day work week
3.2 Execution of our fixed code for computing the hours in a 7 day work week
3.3 Declaration and use of a struct for a rectangle
3.4 Executing code which uses an enumerated type
Chapter 4: Writing Code
4.1 Writing the isPrime function
Chapter 5: Compiling and Running
5.1 Writing, compiling, and running the “Hello World” program
Chapter 7: Recursion
7.1 Executing the recursive factorial function by hand
7.2 Writing factorial recursively
7.3 Writing Fibonacci recursively
7.4 Duplication of computation in Fibonacci
7.5 Execution of the tail recursive implementation of factorial
7.6 Execution of the mutually recursive isOdd and isEven functions
Chapter 8: Pointers
8.1 Stepping through a naive (pointer-less) implementation of swap
8.2 Stepping through a simple series of pointer manipulations
8.3 Stepping through a correct implementation of swap with pointers
8.4 Stepping through our swap function with attention to what happens in hardware
Chapter 9: Arrays
9.1 Array access with pointer arithmetic
9.2 Array access with indexing
9.3 Devising the code to find the index of the largest element of an array
9.4 Translating our closest point algorithm to code
9.5 Illustration of a dangling pointer caused by attempting to return an array
Chapter 10: Uses of Pointers
10.1 Writing a function to compare two strings
10.2 Writing a function to deep copy a string.
10.3 An illustration of why casting between incompatible representations can cause your program to crash
10.4 An example of how a buffer overflow exploit works
Chapter 11: Interacting With the User and System
11.1 Reading a file with fgetc
11.2 Reading from a file with fgets
11.3 Writing to a file
11.4 Closing a file, and writing buffered data down to the OS and disk
Chapter 12: Dynamic Allocation
12.1Stepping through a simple call to malloc
12.2 Mechanics of free(p)
12.3 Code that leaks memory,and how to fix it with free
12.43 Common problems when using free
12.5 Stepping through a simple call to realloc
12.6 Using getline to read lines from a file and print them out
12.7 An example that combines getline, realloc
Chapter 13: Programming in the Large
13.1 Initial steps for this example
Chapter 14: Transition to C++
14.1 Executing code with methods
14.2 Executing code with references
14.3 Executing swap, written with reference
14.4 Executing code with an overloaded operator
Chapter 15: Object Creation and Destruction
15.1 Executing code that creates an object with a constructor
15.2 Execution of code with new and new[]
15.3 Creating objects whose constructors use initalizer lists
15.4 Initialization list ordering, and implicit initialization of non-POD fields
15.5 Execution ofcodewithobjectdestruction
15.6 Execution of more complex code with destructors
15.7 Naively copying an object via parameter passing.
15.8 Naively copying an object via assignment
15.9 Executing code with a copy constructor: parameter passing example revisited.
15.10 Executing Code with an overloaded copying assignment operator
Chapter 18: Inheritance
18.1 Constructing and destroying objects that use inheritance.
18.2 Method dispatch in C++.
18.3 Dynamically dispatching methods during object construction and destruction
18.4 The pitfalls of non-virtual destructors when objects are used polymorphically
18.5 Executing code with abstract classes
Chapter 19: Error Handling and Exceptions
19.1 Executing code exceptions
Chapter 20: Introduction To Algorithms and Data Structures
20.1 The operation of an array/vector-based queue, including resizing to add more elements
20.2 Using a stack to keep track of which HTML tags are open
Chapter 21: Linked Lists
21.1 Adding to the front of a linked list
21.2 Adding to the back of a doubly linked list
21.3 Destroying a linked list
21.4 Adding in sorted order with a pointer to a pointer
21.5 Executing the recursive code to add in sorted order
21.6 Devising the code to add in sorted order with a pointer to a pointer to a node
Chapter 22: Binary Search Trees
22.1 Devising a recursive algorithm to add to a binary search tree
22.2 Devising an algorithm to add to a binary search tree by keeping a pointer to the box that we might want to change
22.3 Devising an algorithm to search a binary search tree using iteration
Chapter 23: Hash Tables
23.1A hash table with external chaining
23.2 Rehashing a hash table with external chaining
Chapter 24: Heaps and Priority Queues
24.1 Adding items to a max-heap
24.2 Removing the largest item from a max-heap
24.3 An example of Huffman Coding with 5 symbols
Chapter 25: Graphs
25.1 DFS that recurses infinitely
25.2 Execution of the DFS algorithm
25.3 Prim’s algorithm to find a minimum spanning tree
25.4 Kruskal’s algorithm to find a minimum spanning tree

Chapter 26: Sorting
26.1 Execution of bubble sort
26.2 FastExecution of a larger bubble sort
26.3 Illustration of the execution of shaker sort
26.4 Execution of insertion sort
26.5 FastExecution of a larger insertion sort
26.6 Execution of selection sort
26.7 Execution of a larger selection sort
26.8 Execution of heap sort
26.9 Execution of merge sort
26.10 Execution of quick sort
Chapter 27: Balanced BSTs
27.1 Adding 3 creates imbalance. Left rotation re-balances the tree
27.2 Generalized single rotations for an AVL tree
27.3 Generalized double rotations for an AVL tree
27.4 Example of adding to an AVL tree and applying rotations to correct imbalances
27.5 Deletion from an AVL tree
27.6 Insertion into a red/black tree
Chapter 28: Concurrency
28.1 Basics of multi-threaded execution
28.2 Illustration of data races in multi-threaded code
28.3 Illustration of mutexes in multi-threaded code
Appendix C: Other Important Tools
C.1 Example of basic gdb comments
C.2 Example of some more gdb commands