Map (higher-order function)

Abstract Data Type (ADT)

Stack (abstract data type)

Queue (abstract data type)

Algorithmic Analysis

Case Analysis

Algorithm Analysis

Asymptotic Analysis

Recursive Algorithm Analysis

Binary Search Tree (BST)

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

Abstract Data Structures

Recursion (computer science)

C++ Classes

Memory management

Implementation-level abstractions

Linked data structures

Python

Grids

Set (abstract data type)

Backtracking

Pointer (computer programming)

Binary Search Trees

String (computer science)

Fractals

Dynamic Memory

Implementing `StackInt`

Linked list

Huffman Coding

Graph Shortest Path Algorithms

Big-O notation

Procedural Recursion

Vector (C++)

CS 106B Programming Abstractions Stanford University Winter 2023 This course helps transition from coding to problem-solving using computers. The course explores techniques, tools, and models for problem-solving across disciplines using C++. Prior programming experience is assumed. A nonprofit needs to assign tasks to its volunteers so they get completed as fast as possible. A political scientist wants to determine how to allocate city council seats based on a popular vote. A climatologist wants to estimate how many trees are in a forest. A city planner wants to see whether a proposed development will be underwater as sea levels rise. A physicist wants to know why perturbations to a system cause cascading effects.

How can we use computing power to answer these questions?

This course is about transitioning from “I know how to write programs” to “I know how to solve problems with computers.” Over the course of ten weeks, we’ll explore an array of techniques, tools, and perspectives useful for modeling and solving problems. We’ll explore recursion and see how it can be used both to model the intricacies of nature and to optimally allocate resources. We’ll develop a rich vocabulary of structures that can both capture the position of a dancer in space and compress a data file. And we’ll see how to put these techniques to use in problems drawn from a range of disciplines. By the time you’ve completed this course, you’ll learn how to look at problems in fundamentally different ways and how to use those perspectives to create clean and elegant computational solutions.  CS106B assumes that you have a familiarity with programming at the level of CS106A or the AP Computer Science exam. Check out [our course placement page](https://web.stanford.edu/class/archive/cs/cs106b/cs106b.1234/course_placement) for more information about deciding whether CS106B is right for you. As always, feel free to get in touch with us if you have any questions.

A note: although this class uses C++, this class is primarily designed to teach abstraction, recursion, and algorithmic analysis. If you already know those topics and just want to learn C++, you may want to opt to take CS106L instead of CS106B. The required reading for this course is Eric Roberts' *Programming Abstractions in C++*. You can purchase a copy at the bookstore using this link:

> https://www.bkstr.com/stanfordstore/search/keyword/programming%2520abstractions

You can also use this online version, which is a 2012 draft version of the book.

> https://web.stanford.edu/dept/cs_edu/resources/textbook/

We assume that the majority of you have no prior programming experience in C++, and this textbook is a great resource to use at the start of the quarter as you’re transitioning into the language.

A helpful note from the School of Engineering:

> *“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 106B Programming Abstractions

Computer Programming

Java (programming language)

Class (computer programming)

Software testing

References

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

Red Black Trees

Tree traversal

Multi-Dimensional Data

Prefix Operations and Tries

Reductions and Decomposition

Quick Sort

Algorithmic Bounds

Data structure

Scope

Kolmogorov complexity

Sentinel Nodes

DLLists

ALists

SLists

Implements

Casting

Subtype Polymorphism

Iterators

Asymptotics

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

Visual Encoding

Animation

Uncertainty

Data & Image Models

Tableau

Scalable Visualization

Color

Networks

Exploratory Data Analysis

Deceptive Visualization

D3.js

Graphical Perception

Narrative Visualization

CSE 512 Data Visualization University of Washington Spring 2022 This course from the University of Washington dives deep into the principles of data visualization, exploring techniques derived from graphic design, perceptual psychology, and cognitive science. The course enhances understanding of visualization techniques, exposure to common data domains, and offers practical experience in building and evaluating visualization systems.  The world is awash with increasing amounts of data, and we must keep afloat with our relatively constant perceptual and cognitive abilities. Visualization provides one means of combating information overload, as a well-designed visual encoding can supplant cognitive calculations with simpler perceptual inferences and improve comprehension, memory, and decision making. Furthermore, visual representations may help engage more diverse audiences in the process of analytic thinking.

In this course we will study techniques for creating effective visualizations based on principles from graphic design, perceptual psychology, and cognitive science. The course is targeted both towards students interested in using visualization in their own work, as well as students interested in building better visualization tools and systems.

In addition to class discussions, students will complete visualization design and data analysis assignments, as well as a final project. Students will share the results of their final project as both an interactive website and a video presentation. This course is designed to provide students with the foundations necessary for understanding and extending the current state of the art in data visualization. By the end of the course, students will have gained:
- An understanding of key visualization techniques and theory, including data models, graphical perception and methods for visual encoding and interaction.
- Exposure to a number of common data domains and corresponding analysis tasks, including multivariate data, geo-spatial data, and networks.
- Practical experience building and evaluating visualization systems.
- The ability to read and discuss research papers from the visualization literature.  - [The Visual Display of Quantitative Information](http://www.amazon.com/gp/product/0961392142), E. Tufte. Graphics Press, 2001.
- [Envisioning Information](http://www.amazon.com/Envisioning-Information-Edward-R-Tufte/dp/0961392118), E. Tufte. Graphics Press, 1990.
- [Vega-Lite Visualization Notebook Curriculum](https://observablehq.com/@uwdata/data-visualization-curriculum). Jeffrey Heer, Dominik Moritz, Jake VanderPlas, and Brock Craft.
- *Optional*: [Interactive Data Visualization for the Web](http://alignedleft.com/work/d3-book-2e), 2nd Edition. Scott Murray, O'Reilly Press.
    - To read online, use the "O'Reilly (Formerly Safari)" link on the [UW library page](https://guides.lib.uw.edu/c.php?g=341544&p=2299182).
    - Code examples available on [GitHub](https://github.com/alignedleft/d3-book/).

CSE 512 Data Visualization

Data Science

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.