Preface¶
Introduction¶
Programming Tutorials¶
- 2.1. Command Line Basics
- 2.2. Parsing Command Line Parameters In Your Progam
- 2.3. Using Parameters in Eclipse
- 2.4. Installing the Web-CAT Submission Plug-in for Eclipse
- 2.5. Common Debugging Methods
- 2.6. Debugging In Eclipse
- 2.7. Reading Input (from Files or Otherwise)
- 2.8. Random Access Files In Java
- 2.9. JUnit Testing And You
- 2.10. Writing JUnit Tests
- 2.11. Code Coverage In JUnit
- 2.12. Mutation Coverage In JUnit
- 2.13. Testing
- 2.14. Testing for Code Coverage
- 2.15. Another Example
- 2.16. Bowling Example
Mathematical Background¶
Algorithm Analysis¶
- 4.1. Chapter Introduction
- 4.2. Problems, Algorithms, and Programs
- 4.3. Comparing Algorithms
- 4.4. Best, Worst, and Average Cases
- 4.5. Faster Computer, or Faster Algorithm?
- 4.6. Asymptotic Analysis and Upper Bounds
- 4.7. Lower Bounds and \(\Theta\) Notation
- 4.8. Calculating Program Running Time
- 4.9. Analyzing Problems
- 4.10. Common Misunderstandings
- 4.11. Multiple Parameters
- 4.12. Space Bounds
- 4.13. Code Tuning and Empirical Analysis
- 4.14. Algorithm Analysis Summary Exercises
Linear Structures¶
- 5.1. Chapter Introduction: Lists
- 5.2. The List ADT
- 5.3. Array-Based List Implementation
- 5.4. Linked Lists
- 5.5. Comparison of List Implementations
- 5.6. Doubly Linked Lists
- 5.7. List Element Implementations
- 5.8. Stacks
- 5.9. Linked Stacks
- 5.10. Freelists
- 5.11. Implementing Recursion
- 5.12. Queues
- 5.13. Linked Queues
- 5.14. Linear Structure Summary Exercises
Design¶
Binary Trees¶
- 7.1. Binary Trees Chapter Introduction
- 7.2. Binary Trees
- 7.3. Binary Tree as a Recursive Data Structure
- 7.4. The Full Binary Tree Theorem
- 7.5. Binary Tree Traversals
- 7.6. Implementing Tree Traversals
- 7.7. Information Flow in Recursive Functions
- 7.7.1. Information Flow in Recursive Functions
- 7.7.2. Binary Tree Set Depth Exercise
- 7.7.3. Collect-and-return
- 7.7.4. Binary Tree Check Sum Exercise
- 7.7.5. Binary Tree Leaf Nodes Count Exercise
- 7.7.6. Binary Tree Sum Nodes Exercise
- 7.7.7. Combining Information Flows
- 7.7.8. Binary Tree Check Value Exercise
- 7.7.9. Combination Problems
- 7.7.10. Binary Tree Height Exercise
- 7.7.11. Binary Tree Get Difference Exercise
- 7.7.12. Binary Tree Has Path Sum Exercise
- 7.8. Binary Tree Node Implementations
- 7.9. Composite-based Expression Tree
- 7.10. Binary Tree Space Requirements
- 7.11. Binary Search Trees
- 7.12. Dictionary Implementation Using a BST
- 7.13. Binary Tree Guided Information Flow
- 7.14. Multiple Binary Trees
- 7.15. A Hard Information Flow Problem
- 7.16. Array Implementation for Complete Binary Trees
- 7.17. Heaps
- 7.18. Huffman Coding
- 7.19. Trees versus Tries
- 7.20. Proof of Optimality for Huffman Coding
- 7.21. Binary Tree Chapter Summary
Sorting¶
- 8.1. Chapter Introduction: Sorting
- 8.2. Sorting Terminology and Notation
- 8.3. Insertion Sort
- 8.4. Bubble Sort
- 8.5. Selection Sort
- 8.6. The Cost of Exchange Sorting
- 8.7. Optimizing Sort Algorithms with Code Tuning
- 8.8. Shellsort
- 8.9. Mergesort Concepts
- 8.10. Implementing Mergesort
- 8.11. Quicksort
- 8.12. Heapsort
- 8.13. Binsort
- 8.14. Radix Sort
- 8.15. An Empirical Comparison of Sorting Algorithms
- 8.16. Lower Bounds for Sorting
- 8.17. Sorting Summary Exercises
File Processing¶
- 9.1. File Processing and Buffer Pools
- 9.1.1. File Processing and Buffer Pools
- 9.1.1.1. Programmer’s View of Files
- 9.1.1.2. Java File Functions
- 9.1.1.3. Primary vs. Secondary Storage
- 9.1.1.4. Comparisons
- 9.1.1.5. Golden Rule of File Processing
- 9.1.1.6. Disk Drives
- 9.1.1.7. Sectors
- 9.1.1.8. Terms
- 9.1.1.9. Seek Time
- 9.1.1.10. Other Factors
- 9.1.1.11. (Old) Disk Spec Example
- 9.1.1.12. Disk Access Cost Example (1)
- 9.1.1.13. Disk Access Cost Example (2)
- 9.1.1.14. How Much to Read?
- 9.1.1.15. Newer Disk Spec Example
- 9.1.1.16. Buffers
- 9.1.1.17. Buffer Pools
- 9.1.1.18. Buffer Pools
- 9.1.1.19. Organizing Buffer Pools
- 9.1.1.20. LRU
- 9.1.1.21. Dirty Bit
- 9.1.1.22. Bufferpool ADT: Message Passing
- 9.1.1.23. Bufferpool ADT: Buffer Passing
- 9.1.1.24. Design Issues
- 9.1.1.25. Some Goals
- 9.1.1.26. Improved Interface
- 9.1.1.27. Improved Interface (2)
- 9.1.1.28. External Sorting
- 9.1.1.29. Model of External Computation
- 9.1.1.30. Key Sorting
- 9.1.1.31. Simple External Mergesort (1)
- 9.1.1.32. Simple External Mergesort (2)
- 9.1.1.33. Simple External Mergesort (3)
- 9.1.1.34. Problems with Simple Mergesort
- 9.1.1.35. A Better Process
- 9.1.1.36. Breaking a File into Runs
- 9.1.1.37. Replacement Selection (1)
- 9.1.1.38. Replacement Selection (2)
- 9.1.1.39. RS Example
- 9.1.1.40. Snowplow Analogy (1)
- 9.1.1.41. Snowplow Analogy (2)
- 9.1.1.42. Problems with Simple Merge
- 9.1.1.43. Multiway Merge (1)
- 9.1.1.44. Multiway Merge (2)
- 9.1.1.45. Limits to Multiway Merge (1)
- 9.1.1.46. Limits to Multiway Merge (2)
- 9.1.1.47. General Principles
- 9.1.1. File Processing and Buffer Pools
- 9.2. Primary versus Secondary Storage
- 9.3. Disk Drives
- 9.4. Buffer Pools
- 9.5. The Programmer’s View of Files
- 9.6. External Sorting
Hashing¶
Memory Management¶
Indexing¶
General Trees¶
Graphs¶
Advanced Data Structures¶
Blockchain¶
- 16.1. Bitcoin
- 16.2. Blockchain Tutorial Glossary
- 16.3. Blocks & Nodes
- 16.4. Consensus Algorithms Introduction
- 16.5. Crypto Hacking
- 16.6. Cryptography and Blockchain
- 16.7. Ethereum
- 16.8. Hard Forks
- 16.9. Merkle Trees
- 16.10. Other Applications
- 16.11. Other Cryptocurrencies
- 16.12. Permissioned Consensus Algorithms
- 16.13. Permissionless Consensus Algorithms
- 16.14. Proof of Stake
- 16.15. Public Ledgers
- 16.16. Smart Contracts
- 16.17. The Ethereum Virtual Machine and Gas
- 16.18. Understanding Blockchain
CS3Slides¶
- 17.1. 2-3+ Trees
- 17.2. Algorithm Analysis
- 17.2.1. Algorithm Analysis
- 17.2.1.1. Algorithm Efficiency
- 17.2.1.2. How to Measure Efficiency?
- 17.2.1.3. Problems, Algorithms, Programs
- 17.2.1.4. Growth Rate Example (1)
- 17.2.1.5. Growth Rate Example (2)
- 17.2.1.6. Growth Rate Graph
- 17.2.1.7. Best, Worst, Average Cases
- 17.2.1.8. Which Analysis to Use?
- 17.2.1.9. Faster Computer or Algorithm?
- 17.2.1.10. Faster Computer or Algorithm? 2
- 17.2.1.11. Asymptotic Analysis: Big-oh
- 17.2.1.12. Big-oh Notation (cont)
- 17.2.1.13. Big-Oh Examples
- 17.2.1.14. Big-Oh Examples (2)
- 17.2.1.15. A Common Misunderstanding
- 17.2.1.16. Big-Omega \(\Omega\)
- 17.2.1.17. Big-Omega Example
- 17.2.1.18. Theta Notation \(\Theta\)
- 17.2.1.19. A Common Misunderstanding
- 17.2.1.20. Simplifying Rules
- 17.2.1.21. Summary
- 17.2.1.22. .
- 17.2.1.23. Time Complexity Examples (1)
- 17.2.1.24. Time Complexity Examples (2)
- 17.2.1.25. Time Complexity Examples (3)
- 17.2.1.26. Time Complexity Examples (4)
- 17.2.1.27. Binary Search
- 17.2.1.28. Other Control Statements
- 17.2.1.29. Analyzing Problems
- 17.2.1.30. Analyzing Problems: Example
- 17.2.1.31. Space/Time Tradeoff Principle
- 17.2.1.32. Multiple Parameters
- 17.2.1.33. Space Complexity
- 17.2.1. Algorithm Analysis
- 17.3. Binary Trees Part 1
- 17.4. Binary Trees Part 2
- 17.4.1. Binary Trees Part 2
- 17.4.1.1. Full and Complete Binary Trees
- 17.4.1.2. Full Binary Tree Theorem (1)
- 17.4.1.3. Full Binary Tree Theorem (2)
- 17.4.1.4. Full Binary Tree Corollary
- 17.4.1.5. Dictionary
- 17.4.1.6. .
- 17.4.1.7. Dictionary (2)
- 17.4.1.8. Binary Search Trees
- 17.4.1.9. BST as a Dictionary (1)
- 17.4.1.10. BST as a Dictionary (2)
- 17.4.1.11. BST
findhelp - 17.4.1.12. BST
inserthelp - 17.4.1.13. BST
deletemax - 17.4.1.14. BST
removehelp - 17.4.1.15. .
- 17.4.1.16. BST Analysis
- 17.4.1. Binary Trees Part 2
- 17.5. Binary Trees Part 3
- 17.5.1. Binary Trees Part 3
- 17.5.1.1. Comparison (1)
- 17.5.1.2. Comparison (2)
- 17.5.1.3. KVpair
- 17.5.1.4. .
- 17.5.1.5. KVpair: Generics
- 17.5.1.6. .
- 17.5.1.7. Using the KVpair (1)
- 17.5.1.8. Binary Tree Implementation (1)
- 17.5.1.9. Binary Tree Implementation (2)
- 17.5.1.10. Inheritance (1)
- 17.5.1.11. Inheritance (2)
- 17.5.1.12. Inheritance (3)
- 17.5.1.13. Design Patterns
- 17.5.1.14. Composite (1)
- 17.5.1.15. Composite (2)
- 17.5.1.16. Composite (3)
- 17.5.1.17. Space Overhead (1)
- 17.5.1.18. Space Overhead (2)
- 17.5.1. Binary Trees Part 3
- 17.6. CS3114 Introduction
- 17.7. Clean Code
- 17.1. Data Structures and Algorithm Analysis Introduction
- 17.1. File Processing and Buffer Pools
- 17.1.1. File Processing and Buffer Pools
- 17.1.1.1. Programmer’s View of Files
- 17.1.1.2. Java File Functions
- 17.1.1.3. Primary vs. Secondary Storage
- 17.1.1.4. Comparisons
- 17.1.1.5. Golden Rule of File Processing
- 17.1.1.6. Disk Drives
- 17.1.1.7. Sectors
- 17.1.1.8. Terms
- 17.1.1.9. Seek Time
- 17.1.1.10. Other Factors
- 17.1.1.11. (Old) Disk Spec Example
- 17.1.1.12. Disk Access Cost Example (1)
- 17.1.1.13. Disk Access Cost Example (2)
- 17.1.1.14. How Much to Read?
- 17.1.1.15. Newer Disk Spec Example
- 17.1.1.16. Buffers
- 17.1.1.17. Buffer Pools
- 17.1.1.18. Buffer Pools
- 17.1.1.19. Organizing Buffer Pools
- 17.1.1.20. LRU
- 17.1.1.21. Dirty Bit
- 17.1.1.22. Bufferpool ADT: Message Passing
- 17.1.1.23. Bufferpool ADT: Buffer Passing
- 17.1.1.24. Design Issues
- 17.1.1.25. Some Goals
- 17.1.1.26. Improved Interface
- 17.1.1.27. Improved Interface (2)
- 17.1.1.28. External Sorting
- 17.1.1.29. Model of External Computation
- 17.1.1.30. Key Sorting
- 17.1.1.31. Simple External Mergesort (1)
- 17.1.1.32. Simple External Mergesort (2)
- 17.1.1.33. Simple External Mergesort (3)
- 17.1.1.34. Problems with Simple Mergesort
- 17.1.1.35. A Better Process
- 17.1.1.36. Breaking a File into Runs
- 17.1.1.37. Replacement Selection (1)
- 17.1.1.38. Replacement Selection (2)
- 17.1.1.39. RS Example
- 17.1.1.40. Snowplow Analogy (1)
- 17.1.1.41. Snowplow Analogy (2)
- 17.1.1.42. Problems with Simple Merge
- 17.1.1.43. Multiway Merge (1)
- 17.1.1.44. Multiway Merge (2)
- 17.1.1.45. Limits to Multiway Merge (1)
- 17.1.1.46. Limits to Multiway Merge (2)
- 17.1.1.47. General Principles
- 17.1.1. File Processing and Buffer Pools
- 17.8. General Trees
- 17.8.1. General Trees
- 17.8.1.1. General Trees
- 17.8.1.2. General Tree ADT
- 17.8.1.3. General Tree Traversal
- 17.8.1.4. Rep: Lists of Children
- 17.8.1.5. Rep: Dynamic Node (Array)
- 17.8.1.6. Rep: Dynamic Node (linked list)
- 17.8.1.7. Rep: Left-Child/Right-Sibling
- 17.8.1.8. Serialization
- 17.8.1.9. Binary tree serialization
- 17.8.1.10. Alternate serialization
- 17.8.1.11. Bit Vector Serialization
- 17.8.1.12. General Tree Serialization
- 17.8.1. General Trees
- 17.9. Graphs
- 17.9.1. Graphs
- 17.9.1.1. Graphs
- 17.9.1.2. Paths, Cycles
- 17.9.1.3. Connected Components
- 17.9.1.4. Directed Graph Representation
- 17.9.1.5. Undirected Graph Representation
- 17.9.1.6. Representation Space Costs
- 17.9.1.7. Graph ADT
- 17.9.1.8. .
- 17.9.1.9. Visiting Neighbors
- 17.9.1.10. Graph Traversals
- 17.9.1.11. Graph Traversals (2)
- 17.9.1.12. Depth First Search (1)
- 17.9.1.13. Depth First Search (2)
- 17.9.1.14. Depth First Search (3)
- 17.9.1.15. Breadth First Search (1)
- 17.9.1.16. Breadth First Search (3)
- 17.9.1.17. Topological Sort
- 17.9.1.18. Depth-First Topological Sort (1)
- 17.9.1.19. Depth-First Topological Sort (1)
- 17.9.1.20. .
- 17.9.1.21. Queue-Based Topsort (1)
- 17.9.1.22. .
- 17.9.1.23. Queue-Based Topsort (2)
- 17.9.1.24. .
- 17.9.1.25. Shortest Paths Problems
- 17.9.1.26. Shortest Paths Definitions
- 17.9.1.27. Single-Source Shortest Paths
- 17.9.1.28. Dijkstra’s Algorithm Example
- 17.9.1.29. .
- 17.9.1.30. Dijkstra’s Implementation
- 17.9.1.31. Implementing minVertex
- 17.9.1.32. Approach 1
- 17.9.1.33. Approach 2
- 17.9.1.34. .
- 17.9.1.35. All-pairs Shortest Paths (1)
- 17.9.1.36. All-pairs Shortest Paths (2)
- 17.9.1.37. Floyd’s Algorithm
- 17.9.1.38. Minimal Cost Spanning Trees
- 17.9.1.39. MST Example
- 17.9.1.40. Prim’s MST Algorithm
- 17.9.1.41. .
- 17.9.1.42. Implementation 1
- 17.9.1.43. Alternate Implementation
- 17.9.1.44. Kruskal’s MST Algorithm (1)
- 17.9.1.45. Kruskal’s MST Algorithm (2)
- 17.9.1.46. .
- 17.9.1.47. Kruskal’s MST Algorithm (3)
- 17.9.1. Graphs
- 17.10. Hashing
- 17.10.1. Hashing
- 17.10.1.1. Hashing (1)
- 17.10.1.2. Hashing (2)
- 17.10.1.3. Simple Examples
- 17.10.1.4. Collisions (1)
- 17.10.1.5. Collisions (2)
- 17.10.1.6. Hash Functions (1)
- 17.10.1.7. Hash Functions (2)
- 17.10.1.8. Simple Mod Function
- 17.10.1.9. Binning
- 17.10.1.10. Mod vs. Binning
- 17.10.1.11. Mid-Square Method
- 17.10.1.12. Strings Function: Character Adding
- 17.10.1.13. String Folding
- 17.10.1.14. Open Hashing
- 17.10.1.15. Bucket Hashing (1)
- 17.10.1.16. Bucket Hashing (2)
- 17.10.1.17. Closed Hashing
- 17.10.1.18. Collision Resolution
- 17.10.1.19. Insertion
- 17.10.1.20. Search
- 17.10.1.21. Probe Function
- 17.10.1.22. Linear Probing (1)
- 17.10.1.23. Linear Probing (2)
- 17.10.1.24. Problem with Linear Probing
- 17.10.1.25. Linear Probing by Steps (1)
- 17.10.1.26. Linear Probing by Steps (2)
- 17.10.1.27. Pseudo-Random Probing (1)
- 17.10.1.28. Pseudo-Random Probing (2)
- 17.10.1.29. Quadratic Probing
- 17.10.1.30. Double Hashing (1)
- 17.10.1.31. Double Hashing (2)
- 17.10.1.32. Analysis of Closed Hashing
- 17.10.1.33. Deletion
- 17.10.1.34. Tombstones (1)
- 17.10.1.35. Tombstones (2)
- 17.10.1. Hashing
- 17.17. Heaps
- 17.18. Huffman Coding
- 17.11. Indexing
- 17.11.1. Indexing
- 17.11.1.1. Indexing
- 17.11.1.2. Files and Indexing
- 17.11.1.3. Keys and Indexing
- 17.11.1.4. Linear Indexing (1)
- 17.11.1.5. Linear Indexing (2)
- 17.11.1.6. Tree Indexing (1)
- 17.11.1.7. Tree Indexing (2)
- 17.11.1.8. Tree Indexing (3)
- 17.11.1.9. Tree Indexing (4)
- 17.11.1.10. 2-3 Tree
- 17.11.1.11. 2-3 Tree Example
- 17.11.1.12. 2-3 Tree Insertion (1)
- 17.11.1.13. 2-3 Tree Insertion (2)
- 17.11.1.14. 2-3 Tree Insertion (3)
- 17.11.1.15. B-Trees (1)
- 17.11.1.16. B-Trees (2)
- 17.11.1.17. B-Tree Search
- 17.11.1.18. B+-Trees
- 17.11.1.19. 23+-Tree Build Example
- 17.11.1.20. 23+-Tree Search Example
- 17.11.1.21. 23+-Tree Delete Example
- 17.11.1.22. B+-Tree Find
- 17.11.1.23. B+-Tree Insert
- 17.11.1.24. B+-Tree Deletion
- 17.11.1.25. B+-Tree Insert (Degree 5)
- 17.11.1.26. B-Tree Space Analysis (1)
- 17.11.1.27. B-Tree Space Analysis (2)
- 17.11.1.28. B-Trees: The Big Idea
- 17.11.1. Indexing
- 17.12. JUnit Testing
- 17.12.1. Testing
- 17.12.2. JUnit testing and code coverage
- 17.12.3. Philosophy
- 17.12.4. A Bad test (1)
- 17.12.5. A Bad test (2)
- 17.12.6. Full test of output
- 17.12.7. Selective Testing of Output
- 17.12.8. What would be good testing for Project 1?
- 17.12.9. Models
- 17.12.10. What if your model is wrong?
- 17.12.11. Regression testing
- 17.13. Lists
- 17.13.1. Lists
- 17.13.1.1. Lists
- 17.13.1.2. List Implementation Concepts
- 17.13.1.3. List ADT (1)
- 17.13.1.4. List ADT (2)
- 17.13.1.5. List ADT (3)
- 17.13.1.6. List ADT Examples
- 17.13.1.7. List Find Function
- 17.13.1.8. Array-Based List Class (1)
- 17.13.1.9. Array-Based List Insert
- 17.13.1.10. Link Class
- 17.13.1.11. Linked List Position (1)
- 17.13.1.12. Linked List Position (2)
- 17.13.1.13. Linked List Position (3)
- 17.13.1.14. Linked List Class (1)
- 17.13.1.15. Linked List Class (2)
- 17.13.1.16. Insertion
- 17.13.1.17. Removal
- 17.13.1.18. Prev
- 17.13.1.19. Overhead
- 17.13.1.20. Comparison of Implementations
- 17.13.1.21. Space Comparison
- 17.13.1.22. Space Example
- 17.13.1.23. Freelist
- 17.13.1.24. Doubly Linked Lists
- 17.13.1.25. Doubly Linked Node (1)
- 17.13.1.26. Doubly Linked Insert
- 17.13.1.27. Doubly Linked Remove
- 17.13.1. Lists
- 17.14. Math Background
- 17.15. Memory Cues and Resumption Strategies
- 17.16. Memory Management
- 17.16.1. Memory Management
- 17.16.1.1. Memory Management
- 17.16.1.2. Memory Manager ADT
- 17.16.1.3. Implementation Issues
- 17.16.1.4. Dynamic Storage Allocation
- 17.16.1.5. Fragmentation
- 17.16.1.6. Managing the Free Blocks
- 17.16.1.7. Selecting a Free Block
- 17.16.1.8. Sequential Fit Methods
- 17.16.1.9. Example
- 17.16.1.10. .
- 17.16.1.11. Buddy Method
- 17.16.1.12. Buddy Method Example
- 17.16.1.13. .
- 17.16.1.14. Failure Policies
- 17.16.1. Memory Management
- 17.17. Over-Constrained Code
- 17.18. Program Management
- 17.18.1. Program Management
- 17.18.1.1. Project Management
- 17.18.1.2. Scheduling
- 17.18.1.3. Historical Data
- 17.18.1.4. Historical Data 2
- 17.18.1.5. Historical Data 3
- 17.18.1.6. What is the Mechanism?
- 17.18.1.7. How to fail at implementing your project:
- 17.18.1.8. How to succeed at implementing
- 17.18.1.9. How to Survive
- 17.18.1.10. Being Organized 1
- 17.18.1.11. Being Organized 2
- 17.18.1.12. Memory Can’t Handle It
- 17.18.1.13. Spread Work Over Time
- 17.18.1.14. Incremental Development
- 17.18.1.15. Milestones
- 17.18.1.16. Working with a Partner (1)
- 17.18.1.17. Working with a Partner (2)
- 17.18.1. Program Management
- 17.19. Project 1 Design
- 17.20. Quick Hashing
- 17.1. SkipLists
- 17.21. Sorting Part 1
- 17.21.1. Sorting Part 1
- 17.21.1.1. Sorting
- 17.21.1.2. Insertion Sort
- 17.21.1.3. Initial Step
- 17.21.1.4. Analysis: Worst Case
- 17.21.1.5. Analysis: Best Case
- 17.21.1.6. Analysis: Average Case
- 17.21.1.7. Bubble Sort
- 17.21.1.8. Analysis
- 17.21.1.9. Selection Sort
- 17.21.1.10. Analysis
- 17.21.1.11. Summary
- 17.21.1.12. Code Tuning (1)
- 17.21.1.13. Exchange Sorting
- 17.21.1. Sorting Part 1
- 17.22. Sorting Part 2
- 17.22.1. Sorting Part 2
- 17.22.1.1. Shellsort
- 17.22.1.2. Shellsort (2)
- 17.22.1.3. Mergesort
- 17.22.1.4. .
- 17.22.1.5. Mergesort cost
- 17.22.1.6. Quicksort
- 17.22.1.7. Quicksort Partition
- 17.22.1.8. Quicksort Partition Cost
- 17.22.1.9. Quicksort Summary
- 17.22.1.10. Quicksort Worst Case
- 17.22.1.11. .
- 17.22.1.12. Quicksort Best Case
- 17.22.1.13. .
- 17.22.1.14. Quicksort Average Case
- 17.22.1.15. Optimizations for Quicksort
- 17.22.1.16. Heapsort
- 17.22.1.17. Heapsort Analysis
- 17.22.1.18. Binsort
- 17.22.1.19. Radix Sort: Linked List
- 17.22.1.20. .
- 17.22.1.21. Radix Sort: Array
- 17.22.1.22. Radix Sort Implementation
- 17.22.1.23. .
- 17.22.1.24. Radix Sort Analysis
- 17.22.1.25. Empirical Analysis
- 17.22.1.26. Sorting Lower Bound (1)
- 17.22.1.27. Sorting Lower Bound (2)
- 17.22.1. Sorting Part 2
- 17.23. Stacks and Queues
- 17.23.1. Container Class Design Issues
- 17.23.2. Stacks
- 17.23.3. Stack ADT
- 17.23.4. Array-Based Stack (1)
- 17.23.5. Array-Based Stack (2)
- 17.23.6. Linked Stack
- 17.23.7. Queues
- 17.23.8. Queue Implementation (1)
- 17.23.9. Queue Implementation (2)
- 17.23.10. Queue Implementation (3)
- 17.23.11. Circular Queue (1)
- 17.23.12. Circular Queue (2)
- 17.24. Tries
- 17.25. Union/FIND
- 17.26. Week 5
