Binary Search Tree (BST)

Abstract Data Type (ADT)

Stack (abstract data type)

Queue (abstract data type)

Map (higher-order function)

Algorithmic Analysis

Case Analysis

Algorithm Analysis

Asymptotic Analysis

Recursive Algorithm Analysis

Hashing

AVL Trees

Tree (data structure)

Graphs

Breadth-first search (BFS)

Depth-first search (DFS)

Topological sorting

Graph traversal

Minimum Spanning Tree (MST)

Disjoint Sets

Dynamic programming

Graph Modelling

Sorting algorithm

P/NP

Computer memory

Shortest paths

Heap (data structure)

CSE 373 Data Structures and Algorithms University of Washington Summer 2022 This course focuses on common data structures and algorithms. It integrates theoretical understanding with practical exercises, preparing students for software-related roles and industry technical interviews. Programming projects, unit testing, and source control techniques are emphasized.  In this course, you will gain a strong theoretical and conceptual understanding of common data structures and algorithms, as well as how to apply them within larger programming projects.

Specific topics we will cover include:

- **Data structures and ADTs**: lists, stacks, queues, sets, dictionaries, linked lists, arrays, trees, balanced trees, AVL trees, hash tables, priority queues, binary heaps, and disjoint sets.
- **Graphs and graph algorithms**: graph search, shortest path, and minimum spanning trees.
- **Algorithm analysis**: asymptotic analysis, and P and NP complexity classes.
- **Sorting** and divide-and-conquer.

This course is designed to have a practical component to help you gain basic familiarity with techniques used within industry. In particular, you’ll be asked to:

- Work on **programming projects** and integrate your work in an existing codebase.
- Learn how to use an **industrial-strength IDE**.
- Learn techniques for **checking correctness**: writing unit tests with JUnit, designing and checking invariants, etc.
- Learn how to collaborate on a single code base using **source control** repositories.

Finally, this course emphasizes the importance of making and justifying design decisions. Taken together, all of the above skills are chosen to set you up for success in a software-related role. In fact, this course is typically regarded as useful preparation for industry and technical interviews. [CSE 143](https://courses.cs.washington.edu/courses/cse143/), or similar Java programming experience. 

CSE 373 Data Structures and Algorithms

Data Structures and Algorithms

Worst-Case Analysis

Solving Recurrences

Median and Selection

Quick Sort

Lower Bounds for Sorting

Red-Black Trees

Dijkstra's algorithm

Longest Common Subsequence (LCS)

Independent Set

Ford–Fulkerson algorithm

Gale–Shapley algorithm

Asymptotics

Merge sort

Randomized Algorithms

Bucket Sort

Strongly connected components

Bellman–Ford algorithm

Floyd–Warshall algorithm

Knapsack problem

Greedy Algorithm

Max-Flow

Stable Matching

Master theorem

CS 161 Design and Analysis of Algorithms Stanford University Winter 2023 This course provides an in-depth exploration of algorithm analysis and design. It covers various sorting, searching, and selection algorithms, data structures, and fundamental graph algorithms. It emphasizes the understanding of worst and average case analysis, recurrences, and asymptotics.  This course will cover the basic approaches and mindsets for analyzing and designing algorithms and data structures. Topics include the following: Worst and average case analysis. Recurrences and asymptotics. Efficient algorithms for sorting, searching, and selection. Data structures: binary search trees, heaps, hash tables. Algorithm design techniques: divide-and-conquer, dynamic programming, greedy algorithms, amortized analysis, and randomization. Algorithms for fundamental graph problems: minimum-cost spanning tree, connected components, topological sort, and shortest paths. Possible additional topics: network flow and string searching. Additional Calculus for Engineers (ACE) is one of the School of Engineering’s Equity and Inclusion Initiatives, designed to provide the skills and solid foundation in mathematics, computational math in engineering, and computer science to undergraduate students interested in pursuing an engineering degree. The goal of ACE is to increase confidence and content knowledge through small group interactive sessions and additional academic resources provided to students enrolled in the program. We especially want to provide an opportunity for students who come from educationally disadvantaged backgrounds or for anyone who feels they might need additional support in order to succeed. We limit enrollment to enable small classes that allow students to have one-on-one interactions with the CA. CS 106B or CS 106X; CS 103 or CS 103B; CS 109 or STATS 116. ### Textbook Information

All the following textbooks are optional. They are all excellent for supplementing lectures with details.

- *Introduction to Algorithms (3rd Ed)*, Cormen, Leiserson, Rivest, &amp; Stein ([available online!](https://searchworks.stanford.edu/view/12846639))
- *Algorithms*, Dasgupta, Papadimitriou, &amp; Vazirani
- *Algorithm Design*, Kleinberg &amp; Tardos
- *Algorithms Illuminated*, Roughgarden ([with great videos!](https://www.youtube.com/channel/UCcH4Ga14Y4ELFKrEYM1vXCg/playlists))

All students should retain receipts for books and other course-related expenses, as these may be qualified educational expenses for tax purposes. If you are an undergraduate receiving financial aid, you may be eligible for additional financial aid for required books and course materials if these expenses exceed the aid amount in your award letter. For more information, review your award letter or visit the [Student Budget website](https://financialaid.stanford.edu/undergrad/budget/index.html).

CS 161 Design and Analysis of Algorithms

Java (programming language)

Class (computer programming)

Software testing

References

Recursion (computer science)

List (abstract data type)

SLLists

Nested Classes

Debugging

Array (data structure)

Array Resizing

Inheritance (object-oriented programming)

Extends

Higher-order function (HOF)

Exception handling

Object Methods

Set (abstract data type)

Red Black Trees

Tree traversal

Multi-Dimensional Data

Prefix Operations and Tries

Reductions and Decomposition

Algorithmic Bounds

Data structure

Scope

Linked list

Kolmogorov complexity

Sentinel Nodes

DLLists

ALists

SLists

Implements

Casting

Subtype Polymorphism

Iterators

B-tree

Priority queue (PQ)

Range Searching

Software Engineering

Radix Sorts

Compression

P=NP

Static

CS 61B: Data Structures UC Berkeley Fall 2022 CS 61B focuses on software efficiency from design and runtime perspectives. It covers object-oriented programming with Java, teaching data structures and various programming concepts. The course promotes hands-on learning with optional assignments. The CS 61 series is an introduction to Computer Science, with particular emphasis on software and machines from a programmer’s point of view. CS 61A covered high-level approaches to problem-solving, providing you with a variety of ways to organize solutions to programming problems as compositions of functions, collections of objects, or sets of rules. In CS 61B, we move to a somewhat more detailed (and to some extent, more basic) level of programming by focusing particularly on the efficiency of writing programs (design) and running programs (runtime).  This class assumes you have taken CS 61A, CS 88, or E 7, or have equivalent background to a student who has taken one of these courses. The course is largely built upon the assumption that you have taken CS 61A. CS 88 and E7 students may find the beginning of the course to be a bit scarier, particularly when it comes to object oriented programming. We assume you are coming in with zero Java experience, but we will move through basic Java syntax very quickly.

We recommend all students to complete the [optional introductory assignment](https://fa22.datastructur.es/materials/hw/hw0/) by the beginning of the semester to get comfortable with Java and practice some of the programming skills expected by this class.

If you already have Java experience, great! We hope that you’ll help out your fellow students in discussion, lab, and on our class forum, particularly in the opening weeks when everyone is catching up on Java. **There is no required textbook for the class.**

There is an online textbook written by myself and a large team of former TAs. It can be found at https://joshhug.gitbooks.io/hug61b. If you find these notes insufficient, you might consider consulting [Paul Hilfinger’s (free) Java Reference](http://www-inst.eecs.berkeley.edu/~cs61b/fa14/book1/java.pdf) or [Head First Java, 2nd Edition by Sierra and Bates (O’Reilly, 2005)](https://www.google.com/search?q=head+first+java). These are not required for the course. The **optional** textbook for the weeks 5-14 of the course is Algorithms, 4th Edition by Wayne and Sedgewick.

The official description of the Java core language is available online in [The Java Language Specification](https://docs.oracle.com/javase/specs/jls/se17/html/index.html) (Java SE 17 Edition) by James Gosling, Bill Joy, Guy Steele, Gilad Bracha, Alex Buckley, Daniel Smith, and Gavin Bierman. It’s extremely thorough and precise, at the expense of being quite dense and technical. You will find the official [Java 17 documentation](ttps://docs.oracle.com/en/java/javase/17/docs/api/index.html) to be useful as well

CS 61B: Data Structures

Interface

Encapsulation

`ArrayIntList`

pre/post conditions

Reference Semantics

List Nodes

`LinkedIntList`

Recursive Tracing

Grammars

Binary Search

Recursive Backtracking

Binary tree

Comparable

Generics

Priority Queues

Huffman

Resizing

Abstract Classes

Computational complexity

CSE 143 Computer Programming II University of Washington Summer 2022 This course is a continuation of CSE 142, focusing on manipulating data, implementing data structures, and learning about algorithms in Java. It delves into abstract data types, recursion, inheritance, and more.  This course is a continuation of CSE 142. While CSE 142 focused on topics of program control (loops, conditionals, methods, parameter passing, etc.), CSE 143 focuses on topics ofb manipulating data. Topics include: abstract data types (ADTs), lists, stacks, queues, linked lists, binary trees, recursion, interfaces, inheritance, and encapsulation. Students will also learn about the notion of complexity and how to evaluate performance trade-offs of classic algorithms (such as sorting and searching) and classic data structures (such as lists, sets, and maps). The course will include a mixture of implementing data structures and using components from the Java Collections Framework.  ## Textbook

Our optional textbook for CSE 143 this quarter will be the following:

Reges/Stepp. Building Java Programs: A Back to Basics Approach, 5th edition. ISBN 978-0135471944

- [Building Java Programs: A Back to Basics Approach (authors' web site)](http://www.buildingjavaprograms.com/)

This book was written specifically for this course and makes a valuable supplement to the lecture presentations.

## Code Files

The textbook includes many sample programs. You can access a full set of [code files](http://www.buildingjavaprograms.com/code_files/) that is organized chapter by chapter. This will allow you to download any of the programs and run them on your own computer.

## Video Notes

New copies of the textbook come with an access code to watch "Video Notes." These videos supplement the lecture and book material by walking through more examples in detail. You can access the video notes at the Pearson [VideoNotes](http://www.pearsonhighered.com/regesstepp/) web site.

CSE 143 Computer Programming II

Computer Programming

Union-Find

Java

Geometric Applications of BSTs

Mincuts

Trie

Algorithm Design

Analysis of Algorithms

Elementary Sorts

Elementary Symbol Tables

Balanced Search Trees

Hash table

Digraphs

Maxflows

String Sorts

Data Compression

COS 226 Algorithms and Data Structures Princeton University Spring 2023 This course surveys crucial algorithms and data structures used in modern computing, with emphasis on sorting, searching, graphs, and strings. It aims to develop implementations, understand their performance, and evaluate their effectiveness. This course surveys the most important algorithms and data structures in use on computers today. Particular emphasis is given to algorithms for sorting, searching, graphs, and strings. The course concentrates on developing implementations, understanding their performance characteristics, and estimating their potential effectiveness in applications.  COS 126 or approval by the COS placement officer. **Textbook**. *Algorithms, 4th edition* by Robert Sedgewick and Kevin Wayne. Addison-Wesley Professional, 2011, ISBN 0-321-57351-X. The assigned readings are required.

COS 226 Algorithms and Data Structures