Lecture 1 (43:03)

About the Introduction to Computer Science Series at Stanford

About the Introduction to Computer Science Series at Stanford, The Philosophy, Why take CS106B?, Logistics of the Course, Introducing C++

Step 10%
Lecture 2 (43:48)

Similarity between C++ & Java: - syntax - variable types - operators - control structures

Similarity between C++ & Java: - syntax - variable types - operators - control structures, Looking at an Example C++ code: - comment, #include Statements, Global Declarations (constant), Declaring a Function Prototype, The main() Function, Decomposed Function Definition, Example Live Coding: To Calculate the Average, for loop -> a while : Another Purpose of the Same Code, C++ User Defined Data Types: -enums -records, C++ Parameters Passing: -pass by value - pass by reference

Step 20%
Lecture 3 (44:40)

C++ Libraries - Standard Libraries

C++ Libraries - Standard Libraries, CS106 Libraries, CS106 random.h Library, C++ String Type, Operations on String Type, String Class' Member Functions, C++ string vs Java String, Live Example Code : Working on Strings, CS106 strutils.h Library, C++ String vs C String, Concatenation Pitfall (C++ vs C string cont.), C++ Console I/O

Step 30%
Lecture 4 (50:27)

C++ Console I/O

C++ Console I/O, C++ File I/O, Stream Operations, Live Example Coding : Working with Files, Live Coding Continuation: Function to Operate on the Opened File Stream, Passing the File Stream by Reference, Error Function, Class Libraries OO Features, Why OO is So Successful, CS106 Class Library, CS106: Scanner Library, Scanner Client Interface, Client Use of Scanner, Container Classes, Template Containers, Vector Interface

Step 40%
Lecture 5 (45:30)

Client Use of Templates

Client Use of Templates, Vector Class, Vector Client Interface, Client Use of Vector, Type-safety in Templates, Grid Class, Grid Client Interface, Client Use of Grid, Stack Class, Stack Client Interface, Queue Class, Queue Client Interface, Client Use of Queue, Nested Templates, Learning a New API, CS106B Library Documentation

Step 50%
Lecture 6 (43:01)

More Containers

More Containers, Map Class, Uses of Map, Map Client Interface, Live Coding Example: Use of Map, More information on Maps, What s Missing? Iterator Operation Through the Map, Iterating Over the Map, Set Class, Set Client Interface, Live Coding Example : Use of Set, Set Higher-level Operations, Why Set is Different

Step 60%
Lecture 7 (47:32)

Seeing Functions as Data: Specific Plot Functions

Seeing Functions as Data: Specific Plot Functions, Generic Plot Function, Back to the Set, Live Coding Example: Use of Set with User Defined Data Types, Client Callback Function, Review of the Classes Seen,5 Using Nested ADTs (Abstract Data Types), Live Coding Example, Recursion, Recursive Decomposition

Step 70%
Lecture 8 (42:37)

Common Mistakes Stumbled Upon: 'I'terator

Stumbled Upon: 'I'terator, Common Mistakes Stumbled Upon: Concatenating Strings, Solving Problems Recursively, Functional Recursion, Example of Recursion: Calculating Raise to Power, Demo of "Raise to the Power Example" Through Live Coding, Mechanics of What s Going to Happen in Recursion, More Efficient Recursion, Being Wary of Too Many Base Cases, Recursion & Efficiency, Example: Palindromes, Example: Binary Search, Binary Search Code Walk Through, Choosing a Subset; Choose Code

Step 80%
Lecture 9 (48:04)

Thinking Recursively

Thinking Recursively, Procedural vs Functional Recursion, Fractal Code, Live Demo: Fractal Example, Another Recursive Graphic: Mondrian Art, Random Pseudo-Mondrian and the Code, Hanois Towers : Classic Recursion Example, Tower Code, Live Demo, Permutations, Permute Code, Tree of Recursive Calls

Step 90%
Lecture 10 (47:02)

Refresh: Permute Code

Refresh: Permute Code, Tree of Recursive Calls, Live Demo: Testing with Different Cases, Eliminating Duplicates, Subsets, Subset Strategy, Subset Code, Tree of RecursiveCalls: Subset, Exhaustive Recursion, Recursive Backtracking, Turning Recursive Permute to Backtracking, Permute -> Anagram Finder Code, Decision Problems: 8 Queens, Extension to N Queens

Step 100%
Lecture 11 (47:48)

Backtracking Pseudocode

Backtracking Pseudocode, Sudoku Solver, Sudoku Code, Cryptarithmetic, Dumb Solver, Smarter Solver, Looking for Patterns, Introduction to Pointers, Single Pointer Operations

Step 110%
Lecture 12 (41:45)

Pointer Movie

Pointer Movie, Pointer Operations: Code & Pointer Memory Diagrams, Pointer Basics, Pointer and Dynamic Arrays, Use of Pointers, Recursive Data, A Recursive Structure, Live Demo: Working with Linked List, Building the List

Step 120%
Lecture 13 (51:35)

Coding with Linked List

Coding with Linked List, Printing the List, Using Recursion to Print List, De-allocating the Memory Used for the Linked List, Watch the Pointers: Prepend Function, Passing Pointers by Reference, Array vs Linked List, Insert in Sorted (order) Linked List, Insert in Sorted Order: Code, Recursive Insert

Step 130%
Lecture 14 (49:33)

Algorithm Analysis

Algorithm Analysis, Evaluating the Performance, Analysis of Codes: Statement Counts, Another Example (Statement Count Contd.), Comparing Algorithm, Big-O Notation, Big-O to Predict the Time of Execution, Best/Worst/Average Case, Analysis of Recursive Algorithms, Another Example : Towers of Hanoi, A Tabulation for Different Algorithms, Growth Patterns, Application of Algorithm Analysis to Sorting, Selection Sort, Selection Sort Code

Step 140%
Lecture 15 (47:20)

Selection Sort

Selection Sort, Live Demo: Working/execution of the Code, Selection Sort Analysis, Insertion Sort Algorithm, Live Demo: Working/execution of Insertion Sort, Insertion Sort Analysis, Insertion vs Selection, Quadratic Growth of the Algorithm, Merge Sort, Merge Sort: Working/execution Demo, Merge Sort Code Explanation, Merge Sort Analysis, Quadratic vs Linear Arithmetic, Sort 'Race', Quick Sort Idea

Step 150%
Lecture 16 (47:35)

Partitioning for Quicksort

Partitioning for Quicksort, Quicksort Code Working/execution, Quicksort Code, Live Demo: Running Quicksort vs Merge Sort, Bad Split Example, Worst Case Split, What Input has Worst Case for Quick Sort, Live Demo: Running Quicksort vs Merge Sort, Different Input Scenarios, Strategy to Avoid Worst Case Split, Execution Time Tabulation, Towards Generic Functions: Swap, Function Template, Example Live Code, Template Instantiation and its Errors, Sort Template, Client Use of Sort Template

Step 160%
Lecture 17 (44:31)

Sort Template with Callback

Sort Template with Callback, Supplying the Callback Function, One Last Convenience: Default Callback Function, Why Object Oriented Programming, Class Division, Class Interface in ".h" File, Storage for Objects, Accessing Members of a Class, Class Implementation, Implementing Member Functions, Maintaining Object Consistency, Constructors of a Class, Destructors of a Class, Basic Thoughts on Object Design, Internal vs External Representation: Idea of Encapsulation, Better Representation, ADTs (Abstract Data Types)

Step 170%
Lecture 18 (50:54)

Abstract Data Types

Abstract Data Types, Wall of Abstraction, Why ADTs?, Live Coding Example: Creating the Vector Class, Private Data Members, Growing Dynamically: Making Space at Runtime, Insert and Remove Functions, Templatizing the Class Created, Including the "template.cpp" - Why?

Step 180%
Lecture 19 (41:27)

Rules of Template Implementation

Rules of Template Implementation, Explanation of the Working, Not Allow Member Wise Copy, InsertAt Function, Consequences of Contiguous Memory Being a Disadvantage, Stack Class, The Member Function Definitions, Midterm Post Mortem

Step 190%
Lecture 20 (51:00)

Live Coding: Recap of the Vector-based Implementation for Stack

Live Coding: Recap of the Vector-based Implementation for Stack, Linked List Implementation for Stack, Live Coding: Linked List Implementation for Stack, Analyzing Push/pop Functions, Queue Implementation, Live Coding: Queue Implementation, Alternative Implementation, Text Editor Case Study, Buffered Class Interface and Buffer Layered on Vector, Live Coding: Text Editor, Evaluate Vector Buffer, Buffer Layered on Stack, Live Demo, Compare Implementations, Buffer as Linked List

Step 200%
Lecture 21 (46:02)

Buffer: Vector vs Stack

Buffer: Vector vs Stack, Buffer as Linked List, Cursor Design, Use of Dummy Cell, Linked List Insert/delete, Linked List Cursor Movement, Compare Implementation, Doubly Linked List, Compare Implementation, Space Time Trade Off, Implementing Map, Simple Map Implementation: Vector, Map as Vector : Performance Implication, A Different Strategy

Step 210%
Lecture 22 (49:45)

Map as Vector

Map as Vector, A different Strategy: Binary Search Tree, Trees in General, Binary Search Tree for Numbers, Operating on Trees, Tree Traversals at Work, Implementing Map as Tree, Map - getValue(), Important Syntactical Advice, Adding to a BST, Trace treeEnter(), Passing Nodes by Reference, Evaluate Map as a Tree, Impact of the Height of the Tree, Degenerate Trees, What to do About Unbalanced Trees?

Step 220%
Lecture 23 (45:51)

Pathfinder Demo

Pathfinder Demo, Graphs: Examples, Graphs: Explanation, Implementation Strategies, Graph Representation in C++, Nodes and Arcs in C++, Graph Traversals, DFS - (Depth First Search), Trace DfS, BFS - (Breadth First Search), Trace BFS, Graph Search Algorithms, Weighted arcs

Step 230%
Lecture 24 (50:19)

Compare Map Implementations

Compare Map Implementations, Hashtable Idea, Hash Functions, Hash Collisions, Live Demo: Hashing, Live Coding: Hashing, Hashing Idea : Example in Real World, Hash Table Performance, Compare Map Implementations, Hashing Generic Types, Implementing Set

Step 240%
Lecture 25 (50:36)

Lexicon Case Study

Lexicon Case Study, Lexicon as Sorted Vector, Lexicon as BST, Lexicon as Hash Table, Summary so Far, Noticing Patterns/repetitions in the Words, Letter Trie, Lexicon as Trie, Dynamic Array of Children, Flatten Tree into Array, Exploiting Prefixes and Suffixes, DAWG: Directed Acyclic Word Graph, Lexicon as DAWG, The Final Result, Cool Facts about the DAWG

Step 250%
Lecture 26 (49:05)

Final Showdown

Final Showdown, Thinking About Design, Runtime Performance, Memory Used, Code Complexity, Making Tradeoffs, Array vs Vector, Stack/Queue vs Vector, Set vs Sorted Vector, Pointer-based vs. Contiguous Memory, CS106B MVPs, Pointers, To Remember Years from Now, After CS106B, considering.cs

Step 260%
Lecture 27 (41:34)

About the C++ Language, Quick History of C++, C++ Philosophy

Guest Lecturer: Keith Schwarz, About the C++ Language, Quick History of C++, C++ Philosophy, C++ Without genlib.h, A Working genlib.h Replacement, Other CS106 Headers, strutils.h, simpio.h, random.h, graphics.h/extrgraph.h, What about ADTs?, Standard Template Library, STL Algorithms, Language Features, Operator Overloading, What Next?

Step 270%


Julie Zelenski, Computer Science II: Programming Abstractions (Stanford University: Stanford Engineering Everywhere), http://see.stanford.edu. License: Creative Commons Attribution-NonCommercial-ShareAlike 3.0


Julie Zelenski

Additional Notes

schooX is not affiliated or endorsed by Stanford University. Please consider donating to Stanford University by clicking on the donation button below.