DAY 1
The JavaScript Programming Environment and Model
- The JavaScript Environment
- JavaScript Programming Practices
- Declaring and Intializing Variables
- Arithmetic and Math Library Functions in JavaScript
- Decision Constructs
- Repetition Constructs
- Functions
- Variable Scope
- Recursion
- Objects and Object-Oriented Programming
- JavaScript Arrays Defined
- Using Arrays
- Creating Arrays
- Accessing and Writing Array Elements
- Creating Arrays from Strings
- Aggregate Array Operations
- Accessor Functions
- Searching for a Value
- String Representations of Arrays
- Creating New Arrays from Existing Arrays
- Mutator Functions
- Adding Elements to an Array
- Removing Elements from an Array
- Adding and Removing Elements from the Middle of an Array
- Putting Array Elements in Order
- Iterator Functions
- Non–Array-Generating Iterator Functions
- Iterator Functions That Return a New Array
- Two-Dimensional and Multidimensional Arrays
- Creating Two-Dimensional Arrays
- Processing Two-Dimensional Array Elements
- Jagged Arrays
- Arrays of Object
- Arrays in Objects
- A List ADT
- A List Class Implementation
- Append: Adding an Element to a List
- Remove: Removing an Element from a List
- Find: Finding an Element in a List
- Length: Determining the Number of Elements in a List
- toString: Retrieving a List’s Elements
- Insert: Inserting an Element into a List
- Clear: Removing All Elements from a List
- Contains: Determining if a Given Value Is in a List
- Traversing a List
- Iterating Through a List
- A List-Based Application
- Reading Text Files
- Using Lists to Manage a Kiosk
- Stack Operations
- A Stack Implementation
- Using the Stack Class
- Multiple Base Conversions
- Palindromes
- Demonstrating Recursion
- Queue Operations
- An Array-Based Queue Class Implementation
- Using the Queue Class: Assigning Partners at a Square Dance
- Sorting Data with Queues
- Priority Queues
- Shortcoming of Arrays
- Linked Lists Defined
- An Object-Based Linked List Design
- The Node Class
- The Linked List Class
- Inserting new Nodes
- Removing Nodes from a Linked List
- Doubly Linked Lists
- Circularly Linked Lists
- Other linked list functions
- The Dictionary Class
- Auxilliary Functions for the Dictionary Class
- Adding sorting to the Dictionary Class
- An Overview of Hashing
- A Hash Table Class
- Choosing a Hash Function
- A Better Hash Function
- Hashing Integer Keys
- Storing and Retrieving Data in a Hash Table
- Handling Collisions
- Separate Chaining
- Linear Probing
- Fundamental Set Definitions, Operations, and Properties
- Set Definitions
- Set Operations
- The Set Class Implementation
- Trees Defined
- Binary Trees and Binary Search Trees
- Building a Binary Search Tree Implementation
- Traversing a Binary Search Tree
- BST Searches
- Searching for the Minimum and Maximum Value
- Searching for a Specific Value
- Removing Nodes from a BST
- Counting Occurences
- Graph Definitions
- Real-World Systems Modeled by Graphs
- The Graph Class
- Representing Vertices
- Representing Edges
- Building a Graph
- Searching a Graph
- Depth-First Search
- Breadth-First Search
- Finding the Shortest Path
- Breadth-First Search Leads to Shortest paths
- Determining Paths
- Topological Sorting
- An Algorithm for topological Sorting
- Implementing the Topological Sorting Algorithm
- An Array Test Bed
- Generating Random Data
- Basic Sorting Algorithms
- Bubble Sort
- Selection Sort
- Insertion Sort
- Timing Comparisons of the Basic Sorting Algorithms
- Advanced Sorting Algorithms
- The Shellsort Algorithm
- The Mergesort Algorithm
- The Quicksort Algorithm
- Sequential Search
- Searching for Minimum and Maximum Values
- Using Self-Organizing Data
- Binary Search
- Counting Occurences
- Searching Textual Data
- Dynamic Programming
- A Dynamic Programming Example: Computing Fibonacci Numbers
- Finding the Longest Common Substring
- The Knapsack Problem: A Recursive Solution
- The Knapsack Problem: A Dynamic Programming Solution
- Greedy Algorithms
- A First Greedy Algorithm Example: The Coin-Changing Problem
- A Greedy Algorithm Solution to the Knapsack Problem
Arrays
Lists
Day Two
Stacks
Queues
Linked Lists
Day Three
Dictionaries
Hashing
Sets
Day Four
Binary Trees and Binary Search Trees
Graphs and Graph Algorithms
Sorting Algorithms
Day Five
Searching Algorithms
Advanced Algorithms
Subscribe to our Newsletter for latest news.
If the pdf download does not work, try a different browser
© 2004+
Back to top