Username
Password
Forgot your password?
Username:
Password
Confirm Password
Email:
MHC F25 COMSC 205: Data Structures
Table Of Contents
Contents
::
0.
1.
Course Resources
»
Lecture 0
Welcome!
¶
0.1. Course Resources
Lecture 1
Intro to Java I: Data Types and Hello World!
¶
1.1. Introduction
1.2. Why Learn another programming Language?
1.2.1. Why Learn Java? Why not C or C++?
1.3. Let’s look at a Java Program
1.3.1. Compiling and Running
1.3.2. Java Keywords
1.4. Java Data Types
1.4.1. Primitives
1.4.2. Declaring Variables
1.4.3. String
Lecture 2
Intro to Java II: File I/O, Loops, and Conditionals
¶
2.1. Java Data Structures and File I/O
2.1.1. Imports
2.1.2. Input / Output / Scanner
2.1.3. List
2.1.4. Exception Handling with try/catch
2.1.5. Arrays
2.1.6. Dictionary
2.2. Conditionals
2.2.1. Simple if
2.2.2. if else
2.2.3. elif
2.2.4. switch
2.2.5. Boolean Operators
2.3. Loops and Iteration
2.3.1. Definite Loop
2.3.2. Indefinite Loops
Lecture 3
Intro to Java III: Classes
¶
3.1. Defining Classes in Java
3.1.1. Writing a constructor
3.1.2. Methods
3.1.3. Inheritance
3.1.4. Interfaces
3.1.5. Static member variables
3.1.6. Static Methods
3.1.7. Full Implementation of the Fraction Class
3.2. Additional Java Information
3.2.1. Naming Conventions
3.2.2. Common Mistakes
3.2.3. Java Documentation
3.3. Variable Scoping
3.3.1. Variable Scoping
3.3.2. Summarizing Scope Concepts
3.3.3. Check Your Understanding: Scope
3.3.4. Syntax Practice: Scoping
Lecture 4
Object Oriented Programming I: Inheritance
¶
4.1. Introduction to Inheritance
4.1.1. Class Hierarchy and Inheritance
4.1.2. java.lang.Object toString()
4.1.3. Motivating Inheritance and Polymorphism
4.2. Java’s Inheritance Mechanism
4.2.1. Using an Inherited Method
4.2.2. Overriding an Inherited Method
4.2.3. Static Binding, Dynamic Binding and Polymorphism
4.2.4. Using the super Keyword to Refer to the Superclass
4.2.5. Inheritance and Constructors
Lecture 5
Object Oriented Programming II: Abstract Classes
¶
5.1. Abstract Classes, Interfaces, and Polymorphism
5.1.1. Implementing an Abstract Method
5.1.2. Implementing a Java Interface
5.1.3. Interfaces or Abstract Classes
Lecture 6
Algorithm Analysis
¶
6.1. Motivating Studying Data Structures
6.1.1. Introduction
6.1.2. A Philosophy of Data Structures
6.1.3. Selecting a Data Structure
6.1.4. Real-World Example
6.2. Problems, Algorithms, and Programs
6.2.1. Introduction
6.2.2. Algorithms
6.2.3. Programs
6.2.4. Summary
6.3. Comparing Algorithms
6.3.1. Introduction
6.3.2. Basic Operations and Input Size
6.3.3. Growth Rates
6.4. Asymptotic Analysis and Upper Bounds
6.4.1. Introduction
6.4.2. Upper Bounds
6.4.3. Simplifying Rules
6.4.4. Check Your Understanding: Asymptotic Analysis
Lecture 7
The List Interface and Generics
¶
7.1. Java Generics
7.1.1. Primitives vs Object Wrappers
7.1.2. Java Generics
7.2. The List Interface
7.2.1. Introduction
7.2.2. Defining the Interface
7.2.3. Using a List
Lecture 8
ArrayLists
¶
8.1. ArrayList Implementation
8.1.1. Full Implementation
8.1.2. How ArrayLists internally represent data
8.1.3. Instance variables and constructors
8.1.4. Adding elements to a given position: add(int index, E o)
8.1.5. Adding elements to end of list: add(E o)
8.1.6. Removing elements at a given position: remove(int position)
Lecture 9
Singly Linked Lists
¶
9.1. References in Java
9.1.1. Pointers and References
9.1.2. Data Types in Java
9.1.3. Referencing and Dereferencing
9.1.4. The Employee Class
9.1.5. Reference Assignments
9.1.6. Sharing
9.1.7. Shallow and Deep Comparing: .equals() vs ==
9.1.8. Bad References
9.2. Linked Lists
9.2.1. Nodes
9.2.2. Linked List Partial Implementation
9.2.3. Linked List Instance Variables
9.2.4. addFirst() and addAfter()
9.2.5. Linked List Traversal and getNode()
9.2.6. Linked List add(int position, E element)
Lecture 10
Doubly Linked Lists
¶
10.1. Doubly Linked Lists
10.1.1. Motivating Doubly Linked Lists
10.1.2. Node class implementation
10.1.3. addLast() implementation
10.1.4. addAfter() implementation
10.1.5. remove() a given node
10.1.6. Summarizing list operation efficiency
Lecture 11
Exceptions
¶
11.1. Exceptions
11.1.1. Introduction
11.1.2. Handling Exceptional Conditions
11.1.3. Java’s Exception Hierarchy
11.1.4. Trying, Throwing, and Catching an Exception
11.1.5. Syntax and Semantics of Try/Throw/Catch
11.1.6. Exception Propagation: Searching for a Catch Block
Lecture 12
Testing
¶
12.1. Software Testing
12.1.1. What Is Software Testing?
12.1.2. Example: testing remove(int position) for Linked List
Lecture 13
Midterm Review
¶
Lecture 14
Stacks
¶
14.1. Stacks
14.1.1. Stack Terminology and Interface
14.1.2. ArrayList-Based Stack
14.1.3. LinkedList-Based Stack
14.1.4. Comparison of ArrayList-Based and LinkedList-Based Stacks
Lecture 15
Queues
¶
15.1. Queues
15.1.1. Queue Terminology and Interface
15.1.2. LinkedList Queue
15.1.3. Attempting an ArrayList Queue
15.1.4. Circular Array-Based Queue
15.1.5. Comparison of Circular Array and LinkedList Queue Implementations
Lecture 16
Recursion and Search
¶
16.1. Recursion
16.1.1. Introduction
16.1.2. Writing Recursive Methods
16.1.3. Tracing Recursive Code
Lecture 17
Binary Search and Recursive Structures
¶
17.1. Searching in an Array
17.1.1. Linear Search
17.1.2. Binary Search
Lecture 18
Binary Trees
¶
18.1. Binary Trees
18.1.1. Introduction
18.1.2. Binary Tree Terminology
18.1.3. Binary Tree as a Recursive Data Structure
18.2. Binary Tree Implementation
18.2.1. Nodes in a Binary Tree
18.2.2. BinaryTree class
18.2.3. Recursively implementing height()
Lecture 19
Binary Search Trees I
¶
19.1. Binary Tree Traversals
19.1.1. Preorder Traversal
19.1.2. Postorder Traversal
19.1.3. Inorder Traversal
19.2. Binary Search Trees
19.2.1. Binary Search Tree Definition
19.2.2. BST insert()
Lecture 20
Binary Search Trees II and Heaps
¶
20.1. Binary Search Trees Continued
20.1.1. BST contains()
20.1.2. BST remove()
20.1.3. BST operation costs
20.2. Heaps and Priority Queues
20.2.1. Priority Queues
20.2.2. Heap Properties
20.2.3. Heap insert()
20.2.4. Heap remove()
20.2.5. Heap priority queue operation costs
Lecture 21
Maps and Hash Tables
¶
21.1. Maps
21.1.1. The Map Interface
21.1.2. Classes that Implement Map
21.1.3. Using a Map
21.2. Hash Tables
21.2.1. Hashing Introduction
21.2.2. Hash Table Implementation
21.2.3. MHCHashMap get()
21.2.4. MHCHashMap put()
21.2.5. MHCHashMap Complete Reference
21.3. Handling Collisions
21.3.1. Chaining
21.3.2. MHCHashMap, with chaining
21.3.3. MHCHashMapChaining get()
21.3.4. Hash Table Operation Analysis
21.3.5. MHCHashMapChaining Complete Reference
Lecture 22
Sorting I
¶
22.1. Sorting I
22.1.1. Insertion Sort
22.1.2. Selection Sort
Lecture 23
Sorting II
¶
23.1. Sorting II
23.1.1. Merge Sort
23.1.2. Runtime comparisons between sorting algorithms
License
Contents
::
0.
1.
Course Resources
»
Summary*:
Operating system*:
Windows
Mac OS
Linux
iOS
Android
Other
Browser*:
Chrome
Safari
Internet Explorer
Opera
Other
Description*:
Attach a screenshot (optional):
