Udemy - Master the Coding Interview; Data Structures Algorithms #Last updated 12-2019

Category: Technical


Posted on 2019-12-17, by phaelx.

Description



Date: 12/2019
Author: Andrei Neagoie

Size: 12 GB
Format: MP4
Download     >>    https://usersdrive.com/oqz1pvy52bu9.html
What you'll learn
   *Ace coding interviews given by some of the top tech companies
   *Become more confident and prepared for your next coding interview
   *Learn, implement, and use different Data Structures
   *Learn, implement and use different Algorithms
   *Get more interviews
   *Professionally handle offers and negotiate raises
   *Become a better developer by mastering computer science fundamentals


Course content

Introduction
   How To Succeed In This Course
   Join Our Online Classroom!
   Exercise: Meet The Community!

Getting More Interviews
   How To Succeed In This Course
   Join Our Online Classroom!
   Exercise: Meet The Community!
   Section Overview
   Resume
   Exercise: Resume Walkthrough
   Resume Review
   Resources: Resume Templates
   What If I Don't Have Enough Experience?
   Optional Exercise: Github Master
   LinkedIn
   Optional Exercise: LinkedIn Endorsements
   Portfolio
   Resources: Free Portfolio Templates
   Email
   Resources: Email
   Where To Find Jobs?
   Resources: Where To Find Jobs?
   When Should You Start Applying?
   Section Summary

Big O
   How To Succeed In This Course
   Join Our Online Classroom!
   Exercise: Meet The Community!
   Section Overview
   Resume
   Exercise: Resume Walkthrough
   Resume Review
   Resources: Resume Templates
   What If I Don't Have Enough Experience?
   Optional Exercise: Github Master
   LinkedIn
   Optional Exercise: LinkedIn Endorsements
   Portfolio
   Resources: Free Portfolio Templates
   Email
   Resources: Email
   Where To Find Jobs?
   Resources: Where To Find Jobs?
   When Should You Start Applying?
   Section Summary
   Setting Up Your Environment
   Section Overview
   What Is Good Code?
   Big O and Scalability
   O(n)
   O(1)
   Exercise: Big O Calculation
   Solution: Big O Calculation
   Exercise: Big O Calculation 2
   Solution: Big O Calculation 2
   Simplifying Big O
   Big O Rule 1
   Big O Rule 2
   Big O Rule 3
   O(n^2)
   Big O Rule 4
   Big O Cheat Sheet
   What Does This All Mean?
   O(n!)
   3 Pillars Of Programming
   Space Complexity
   Exercise: Space Complexity
   Exercise: Twitter
   Optional: Javascript Loops
   Section Summary

How To Solve Coding Problems
   How To Succeed In This Course
   Join Our Online Classroom!
   Exercise: Meet The Community!
   Section Overview
   Resume
   Exercise: Resume Walkthrough
   Resume Review
   Resources: Resume Templates
   What If I Don't Have Enough Experience?
   Optional Exercise: Github Master
   LinkedIn
   Optional Exercise: LinkedIn Endorsements
   Portfolio
   Resources: Free Portfolio Templates
   Email
   Resources: Email
   Where To Find Jobs?
   Resources: Where To Find Jobs?
   When Should You Start Applying?
   Section Summary
   Setting Up Your Environment
   Section Overview
   What Is Good Code?
   Big O and Scalability
   O(n)
   O(1)
   Exercise: Big O Calculation
   Solution: Big O Calculation
   Exercise: Big O Calculation 2
   Solution: Big O Calculation 2
   Simplifying Big O
   Big O Rule 1
   Big O Rule 2
   Big O Rule 3
   O(n^2)
   Big O Rule 4
   Big O Cheat Sheet
   What Does This All Mean?
   O(n!)
   3 Pillars Of Programming
   Space Complexity
   Exercise: Space Complexity
   Exercise: Twitter
   Optional: Javascript Loops
   Section Summary
   Section Overview
   What Are Companies Looking For?
   What We Need For Coding Interviews
   Exercise: Google Interview
   Exercise: Interview Question
   Exercise: Interview Question 2
   Review Google Interview
   Optional Exercise: Google Interview On Your Own
   Section Summary

Data Structures: Introduction
   How To Succeed In This Course
   Join Our Online Classroom!
   Exercise: Meet The Community!
   Section Overview
   Resume
   Exercise: Resume Walkthrough
   Resume Review
   Resources: Resume Templates
   What If I Don't Have Enough Experience?
   Optional Exercise: Github Master
   LinkedIn
   Optional Exercise: LinkedIn Endorsements
   Portfolio
   Resources: Free Portfolio Templates
   Email
   Resources: Email
   Where To Find Jobs?
   Resources: Where To Find Jobs?
   When Should You Start Applying?
   Section Summary
   Setting Up Your Environment
   Section Overview
   What Is Good Code?
   Big O and Scalability
   O(n)
   O(1)
   Exercise: Big O Calculation
   Solution: Big O Calculation
   Exercise: Big O Calculation 2
   Solution: Big O Calculation 2
   Simplifying Big O
   Big O Rule 1
   Big O Rule 2
   Big O Rule 3
   O(n^2)
   Big O Rule 4
   Big O Cheat Sheet
   What Does This All Mean?
   O(n!)
   3 Pillars Of Programming
   Space Complexity
   Exercise: Space Complexity
   Exercise: Twitter
   Optional: Javascript Loops
   Section Summary
   Section Overview
   What Are Companies Looking For?
   What We Need For Coding Interviews
   Exercise: Google Interview
   Exercise: Interview Question
   Exercise: Interview Question 2
   Review Google Interview
   Optional Exercise: Google Interview On Your Own
   Section Summary
   Section Overview
   What Is A Data Structure?
   How Computers Store Data
   Data Structures In Different Languages
   Operations On Data Structures

Data Structures: Arrays
   How To Succeed In This Course
   Join Our Online Classroom!
   Exercise: Meet The Community!
   Section Overview
   Resume
   Exercise: Resume Walkthrough
   Resume Review
   Resources: Resume Templates
   What If I Don't Have Enough Experience?
   Optional Exercise: Github Master
   LinkedIn
   Optional Exercise: LinkedIn Endorsements
   Portfolio
   Resources: Free Portfolio Templates
   Email
   Resources: Email
   Where To Find Jobs?
   Resources: Where To Find Jobs?
   When Should You Start Applying?
   Section Summary
   Setting Up Your Environment
   Section Overview
   What Is Good Code?
   Big O and Scalability
   O(n)
   O(1)
   Exercise: Big O Calculation
   Solution: Big O Calculation
   Exercise: Big O Calculation 2
   Solution: Big O Calculation 2
   Simplifying Big O
   Big O Rule 1
   Big O Rule 2
   Big O Rule 3
   O(n^2)
   Big O Rule 4
   Big O Cheat Sheet
   What Does This All Mean?
   O(n!)
   3 Pillars Of Programming
   Space Complexity
   Exercise: Space Complexity
   Exercise: Twitter
   Optional: Javascript Loops
   Section Summary
   Section Overview
   What Are Companies Looking For?
   What We Need For Coding Interviews
   Exercise: Google Interview
   Exercise: Interview Question
   Exercise: Interview Question 2
   Review Google Interview
   Optional Exercise: Google Interview On Your Own
   Section Summary
   Section Overview
   What Is A Data Structure?
   How Computers Store Data
   Data Structures In Different Languages
   Operations On Data Structures
   Arrays Introduction
   Static vs Dynamic Arrays
   Quick Note: Upcoming Video
   Optional: Classes In Javascript
   Implementing An Array
   Strings and Arrays
   Exercise: Reverse A String
   Solution: Reverse A String
   Exercise: Merge Sorted Arrays
   Solution: Merge Sorted Arrays
   Interview Questions: Arrays
   Arrays Review

Data Structures: Hash Tables
   How To Succeed In This Course
   Join Our Online Classroom!
   Exercise: Meet The Community!
   Section Overview
   Resume
   Exercise: Resume Walkthrough
   Resume Review
   Resources: Resume Templates
   What If I Don't Have Enough Experience?
   Optional Exercise: Github Master
   LinkedIn
   Optional Exercise: LinkedIn Endorsements
   Portfolio
   Resources: Free Portfolio Templates
   Email
   Resources: Email
   Where To Find Jobs?
   Resources: Where To Find Jobs?
   When Should You Start Applying?
   Section Summary
   Setting Up Your Environment
   Section Overview
   What Is Good Code?
   Big O and Scalability
   O(n)
   O(1)
   Exercise: Big O Calculation
   Solution: Big O Calculation
   Exercise: Big O Calculation 2
   Solution: Big O Calculation 2
   Simplifying Big O
   Big O Rule 1
   Big O Rule 2
   Big O Rule 3
   O(n^2)
   Big O Rule 4
   Big O Cheat Sheet
   What Does This All Mean?
   O(n!)
   3 Pillars Of Programming
   Space Complexity
   Exercise: Space Complexity
   Exercise: Twitter
   Optional: Javascript Loops
   Section Summary
   Section Overview
   What Are Companies Looking For?
   What We Need For Coding Interviews
   Exercise: Google Interview
   Exercise: Interview Question
   Exercise: Interview Question 2
   Review Google Interview
   Optional Exercise: Google Interview On Your Own
   Section Summary
   Section Overview
   What Is A Data Structure?
   How Computers Store Data
   Data Structures In Different Languages
   Operations On Data Structures
   Arrays Introduction
   Static vs Dynamic Arrays
   Quick Note: Upcoming Video
   Optional: Classes In Javascript
   Implementing An Array
   Strings and Arrays
   Exercise: Reverse A String
   Solution: Reverse A String
   Exercise: Merge Sorted Arrays
   Solution: Merge Sorted Arrays
   Interview Questions: Arrays
   Arrays Review
   Hash Tables Introduction
   Hash Function
   Hash Collisions
   Hash Tables In Different Languages
   Exercise: Implement A Hash Table
   Solution: Implement A Hash Table
   keys()
   Hash Tables VS Arrays
   Exercise: First Recurring Character
   Solution: First Recurring Character
   Hash Tables Review

Data Structures: Linked Lists
   How To Succeed In This Course
   Join Our Online Classroom!
   Exercise: Meet The Community!
   Section Overview
   Resume
   Exercise: Resume Walkthrough
   Resume Review
   Resources: Resume Templates
   What If I Don't Have Enough Experience?
   Optional Exercise: Github Master
   LinkedIn
   Optional Exercise: LinkedIn Endorsements
   Portfolio
   Resources: Free Portfolio Templates
   Email
   Resources: Email
   Where To Find Jobs?
   Resources: Where To Find Jobs?
   When Should You Start Applying?
   Section Summary
   Setting Up Your Environment
   Section Overview
   What Is Good Code?
   Big O and Scalability
   O(n)
   O(1)
   Exercise: Big O Calculation
   Solution: Big O Calculation
   Exercise: Big O Calculation 2
   Solution: Big O Calculation 2
   Simplifying Big O
   Big O Rule 1
   Big O Rule 2
   Big O Rule 3
   O(n^2)
   Big O Rule 4
   Big O Cheat Sheet
   What Does This All Mean?
   O(n!)
   3 Pillars Of Programming
   Space Complexity
   Exercise: Space Complexity
   Exercise: Twitter
   Optional: Javascript Loops
   Section Summary
   Section Overview
   What Are Companies Looking For?
   What We Need For Coding Interviews
   Exercise: Google Interview
   Exercise: Interview Question
   Exercise: Interview Question 2
   Review Google Interview
   Optional Exercise: Google Interview On Your Own
   Section Summary
   Section Overview
   What Is A Data Structure?
   How Computers Store Data
   Data Structures In Different Languages
   Operations On Data Structures
   Arrays Introduction
   Static vs Dynamic Arrays
   Quick Note: Upcoming Video
   Optional: Classes In Javascript
   Implementing An Array
   Strings and Arrays
   Exercise: Reverse A String
   Solution: Reverse A String
   Exercise: Merge Sorted Arrays
   Solution: Merge Sorted Arrays
   Interview Questions: Arrays
   Arrays Review
   Hash Tables Introduction
   Hash Function
   Hash Collisions
   Hash Tables In Different Languages
   Exercise: Implement A Hash Table
   Solution: Implement A Hash Table
   keys()
   Hash Tables VS Arrays
   Exercise: First Recurring Character
   Solution: First Recurring Character
   Hash Tables Review
   Linked Lists Introduction
   What Is A Linked List?
   Exercise: Why Linked Lists?
   Solution: Why Linked Lists?
   What Is A Pointer?
   Our First Linked List
   Solution: append()
   Solution: prepend()
   Node Class
   insert()
   Solution: insert()
   Solution: remove()
   Doubly Linked Lists
   Exercise: Doubly Linked Lists
   Solution: Doubly Linked Lists
   Singly VS Doubly Linked Lists
   Exercise: reverse()
   Solution: reverse()
   Linked Lists Review

Data Structures: Stacks + Queues
   How To Succeed In This Course
   Join Our Online Classroom!
   Exercise: Meet The Community!
   Section Overview
   Resume
   Exercise: Resume Walkthrough
   Resume Review
   Resources: Resume Templates
   What If I Don't Have Enough Experience?
   Optional Exercise: Github Master
   LinkedIn
   Optional Exercise: LinkedIn Endorsements
   Portfolio
   Resources: Free Portfolio Templates
   Email
   Resources: Email
   Where To Find Jobs?
   Resources: Where To Find Jobs?
   When Should You Start Applying?
   Section Summary
   Setting Up Your Environment
   Section Overview
   What Is Good Code?
   Big O and Scalability
   O(n)
   O(1)
   Exercise: Big O Calculation
   Solution: Big O Calculation
   Exercise: Big O Calculation 2
   Solution: Big O Calculation 2
   Simplifying Big O
   Big O Rule 1
   Big O Rule 2
   Big O Rule 3
   O(n^2)
   Big O Rule 4
   Big O Cheat Sheet
   What Does This All Mean?
   O(n!)
   3 Pillars Of Programming
   Space Complexity
   Exercise: Space Complexity
   Exercise: Twitter
   Optional: Javascript Loops
   Section Summary
   Section Overview
   What Are Companies Looking For?
   What We Need For Coding Interviews
   Exercise: Google Interview
   Exercise: Interview Question
   Exercise: Interview Question 2
   Review Google Interview
   Optional Exercise: Google Interview On Your Own
   Section Summary
   Section Overview
   What Is A Data Structure?
   How Computers Store Data
   Data Structures In Different Languages
   Operations On Data Structures
   Arrays Introduction
   Static vs Dynamic Arrays
   Quick Note: Upcoming Video
   Optional: Classes In Javascript
   Implementing An Array
   Strings and Arrays
   Exercise: Reverse A String
   Solution: Reverse A String
   Exercise: Merge Sorted Arrays
   Solution: Merge Sorted Arrays
   Interview Questions: Arrays
   Arrays Review
   Hash Tables Introduction
   Hash Function
   Hash Collisions
   Hash Tables In Different Languages
   Exercise: Implement A Hash Table
   Solution: Implement A Hash Table
   keys()
   Hash Tables VS Arrays
   Exercise: First Recurring Character
   Solution: First Recurring Character
   Hash Tables Review
   Linked Lists Introduction
   What Is A Linked List?
   Exercise: Why Linked Lists?
   Solution: Why Linked Lists?
   What Is A Pointer?
   Our First Linked List
   Solution: append()
   Solution: prepend()
   Node Class
   insert()
   Solution: insert()
   Solution: remove()
   Doubly Linked Lists
   Exercise: Doubly Linked Lists
   Solution: Doubly Linked Lists
   Singly VS Doubly Linked Lists
   Exercise: reverse()
   Solution: reverse()
   Linked Lists Review
   Stacks + Queues Introduction
   Stacks
   Queues
   Exercise: Stacks VS Queues
   Solution: Stacks VS Queues
   Quick Note: Upcoming Video
   Optional: How Javascript Works
   Exercise: Stack Implementation (Linked Lists)
   Solution: Stack Implementation (Linked Lists)
   Exercise: Stack Implementation (Array)
   Solution: Stack Implementation (Array)
   Exercise: Queue Implementation
   Solution: Queue Implementation
   Queues Using Stacks
   Stacks + Queues Review

Data Structures: Trees
   How To Succeed In This Course
   Join Our Online Classroom!
   Exercise: Meet The Community!
   Section Overview
   Resume
   Exercise: Resume Walkthrough
   Resume Review
   Resources: Resume Templates
   What If I Don't Have Enough Experience?
   Optional Exercise: Github Master
   LinkedIn
   Optional Exercise: LinkedIn Endorsements
   Portfolio
   Resources: Free Portfolio Templates
   Email
   Resources: Email
   Where To Find Jobs?
   Resources: Where To Find Jobs?
   When Should You Start Applying?
   Section Summary
   Setting Up Your Environment
   Section Overview
   What Is Good Code?
   Big O and Scalability
   O(n)
   O(1)
   Exercise: Big O Calculation
   Solution: Big O Calculation
   Exercise: Big O Calculation 2
   Solution: Big O Calculation 2
   Simplifying Big O
   Big O Rule 1
   Big O Rule 2
   Big O Rule 3
   O(n^2)
   Big O Rule 4
   Big O Cheat Sheet
   What Does This All Mean?
   O(n!)
   3 Pillars Of Programming
   Space Complexity
   Exercise: Space Complexity
   Exercise: Twitter
   Optional: Javascript Loops
   Section Summary
   Section Overview
   What Are Companies Looking For?
   What We Need For Coding Interviews
   Exercise: Google Interview
   Exercise: Interview Question
   Exercise: Interview Question 2
   Review Google Interview
   Optional Exercise: Google Interview On Your Own
   Section Summary
   Section Overview
   What Is A Data Structure?
   How Computers Store Data
   Data Structures In Different Languages
   Operations On Data Structures
   Arrays Introduction
   Static vs Dynamic Arrays
   Quick Note: Upcoming Video
   Optional: Classes In Javascript
   Implementing An Array
   Strings and Arrays
   Exercise: Reverse A String
   Solution: Reverse A String
   Exercise: Merge Sorted Arrays
   Solution: Merge Sorted Arrays
   Interview Questions: Arrays
   Arrays Review
   Hash Tables Introduction
   Hash Function
   Hash Collisions
   Hash Tables In Different Languages
   Exercise: Implement A Hash Table
   Solution: Implement A Hash Table
   keys()
   Hash Tables VS Arrays
   Exercise: First Recurring Character
   Solution: First Recurring Character
   Hash Tables Review
   Linked Lists Introduction
   What Is A Linked List?
   Exercise: Why Linked Lists?
   Solution: Why Linked Lists?
   What Is A Pointer?
   Our First Linked List
   Solution: append()
   Solution: prepend()
   Node Class
   insert()
   Solution: insert()
   Solution: remove()
   Doubly Linked Lists
   Exercise: Doubly Linked Lists
   Solution: Doubly Linked Lists
   Singly VS Doubly Linked Lists
   Exercise: reverse()
   Solution: reverse()
   Linked Lists Review
   Stacks + Queues Introduction
   Stacks
   Queues
   Exercise: Stacks VS Queues
   Solution: Stacks VS Queues
   Quick Note: Upcoming Video
   Optional: How Javascript Works
   Exercise: Stack Implementation (Linked Lists)
   Solution: Stack Implementation (Linked Lists)
   Exercise: Stack Implementation (Array)
   Solution: Stack Implementation (Array)
   Exercise: Queue Implementation
   Solution: Queue Implementation
   Queues Using Stacks
   Stacks + Queues Review
   Trees Introduction
   Binary Trees
   O(log n)
   Correction: Binary Search Trees
   Binary Search Trees
   Balanced VS Unbalanced BST
   BST Pros and Cons
   Exercise: Binary Search Tree
   Solution: insert()
   Solution: lookup()
   Bonus Exercise: remove()
   Solution: remove()
   AVL Trees + Red Black Trees
   Resources: AVL Trees + Red Black Trees
   Binary Heaps
   Quick Note on Heaps
   Priority Queue
   Trie
   Tree Review

Data Structures: Graphs
   How To Succeed In This Course
   Join Our Online Classroom!
   Exercise: Meet The Community!
   Section Overview
   Resume
   Exercise: Resume Walkthrough
   Resume Review
   Resources: Resume Templates
   What If I Don't Have Enough Experience?
   Optional Exercise: Github Master
   LinkedIn
   Optional Exercise: LinkedIn Endorsements
   Portfolio
   Resources: Free Portfolio Templates
   Email
   Resources: Email
   Where To Find Jobs?
   Resources: Where To Find Jobs?
   When Should You Start Applying?
   Section Summary
   Setting Up Your Environment
   Section Overview
   What Is Good Code?
   Big O and Scalability
   O(n)
   O(1)
   Exercise: Big O Calculation
   Solution: Big O Calculation
   Exercise: Big O Calculation 2
   Solution: Big O Calculation 2
   Simplifying Big O
   Big O Rule 1
   Big O Rule 2
   Big O Rule 3
   O(n^2)
   Big O Rule 4
   Big O Cheat Sheet
   What Does This All Mean?
   O(n!)
   3 Pillars Of Programming
   Space Complexity
   Exercise: Space Complexity
   Exercise: Twitter
   Optional: Javascript Loops
   Section Summary
   Section Overview
   What Are Companies Looking For?
   What We Need For Coding Interviews
   Exercise: Google Interview
   Exercise: Interview Question
   Exercise: Interview Question 2
   Review Google Interview
   Optional Exercise: Google Interview On Your Own
   Section Summary
   Section Overview
   What Is A Data Structure?
   How Computers Store Data
   Data Structures In Different Languages
   Operations On Data Structures
   Arrays Introduction
   Static vs Dynamic Arrays
   Quick Note: Upcoming Video
   Optional: Classes In Javascript
   Implementing An Array
   Strings and Arrays
   Exercise: Reverse A String
   Solution: Reverse A String
   Exercise: Merge Sorted Arrays
   Solution: Merge Sorted Arrays
   Interview Questions: Arrays
   Arrays Review
   Hash Tables Introduction
   Hash Function
   Hash Collisions
   Hash Tables In Different Languages
   Exercise: Implement A Hash Table
   Solution: Implement A Hash Table
   keys()
   Hash Tables VS Arrays
   Exercise: First Recurring Character
   Solution: First Recurring Character
   Hash Tables Review
   Linked Lists Introduction
   What Is A Linked List?
   Exercise: Why Linked Lists?
   Solution: Why Linked Lists?
   What Is A Pointer?
   Our First Linked List
   Solution: append()
   Solution: prepend()
   Node Class
   insert()
   Solution: insert()
   Solution: remove()
   Doubly Linked Lists
   Exercise: Doubly Linked Lists
   Solution: Doubly Linked Lists
   Singly VS Doubly Linked Lists
   Exercise: reverse()
   Solution: reverse()
   Linked Lists Review
   Stacks + Queues Introduction
   Stacks
   Queues
   Exercise: Stacks VS Queues
   Solution: Stacks VS Queues
   Quick Note: Upcoming Video
   Optional: How Javascript Works
   Exercise: Stack Implementation (Linked Lists)
   Solution: Stack Implementation (Linked Lists)
   Exercise: Stack Implementation (Array)
   Solution: Stack Implementation (Array)
   Exercise: Queue Implementation
   Solution: Queue Implementation
   Queues Using Stacks
   Stacks + Queues Review
   Trees Introduction
   Binary Trees
   O(log n)
   Correction: Binary Search Trees
   Binary Search Trees
   Balanced VS Unbalanced BST
   BST Pros and Cons
   Exercise: Binary Search Tree
   Solution: insert()
   Solution: lookup()
   Bonus Exercise: remove()
   Solution: remove()
   AVL Trees + Red Black Trees
   Resources: AVL Trees + Red Black Trees
   Binary Heaps
   Quick Note on Heaps
   Priority Queue
   Trie
   Tree Review
   Graphs Introduction
   Types Of Graphs
   Exercise: Guess The Graph
   Graph Data
   Exercise: Graph Implementation
   Solution: Graph Implementation
   Graphs Review
   Data Structures Review
   What Else Is Coming Up?

Algorithms: Recursion
   How To Succeed In This Course
   Join Our Online Classroom!
   Exercise: Meet The Community!
   Section Overview
   Resume
   Exercise: Resume Walkthrough
   Resume Review
   Resources: Resume Templates
   What If I Don't Have Enough Experience?
   Optional Exercise: Github Master
   LinkedIn
   Optional Exercise: LinkedIn Endorsements
   Portfolio
   Resources: Free Portfolio Templates
   Email
   Resources: Email
   Where To Find Jobs?
   Resources: Where To Find Jobs?
   When Should You Start Applying?
   Section Summary
   Setting Up Your Environment
   Section Overview
   What Is Good Code?
   Big O and Scalability
   O(n)
   O(1)
   Exercise: Big O Calculation
   Solution: Big O Calculation
   Exercise: Big O Calculation 2
   Solution: Big O Calculation 2
   Simplifying Big O
   Big O Rule 1
   Big O Rule 2
   Big O Rule 3
   O(n^2)
   Big O Rule 4
   Big O Cheat Sheet
   What Does This All Mean?
   O(n!)
   3 Pillars Of Programming
   Space Complexity
   Exercise: Space Complexity
   Exercise: Twitter
   Optional: Javascript Loops
   Section Summary
   Section Overview
   What Are Companies Looking For?
   What We Need For Coding Interviews
   Exercise: Google Interview
   Exercise: Interview Question
   Exercise: Interview Question 2
   Review Google Interview
   Optional Exercise: Google Interview On Your Own
   Section Summary
   Section Overview
   What Is A Data Structure?
   How Computers Store Data
   Data Structures In Different Languages
   Operations On Data Structures
   Arrays Introduction
   Static vs Dynamic Arrays
   Quick Note: Upcoming Video
   Optional: Classes In Javascript
   Implementing An Array
   Strings and Arrays
   Exercise: Reverse A String
   Solution: Reverse A String
   Exercise: Merge Sorted Arrays
   Solution: Merge Sorted Arrays
   Interview Questions: Arrays
   Arrays Review
   Hash Tables Introduction
   Hash Function
   Hash Collisions
   Hash Tables In Different Languages
   Exercise: Implement A Hash Table
   Solution: Implement A Hash Table
   keys()
   Hash Tables VS Arrays
   Exercise: First Recurring Character
   Solution: First Recurring Character
   Hash Tables Review
   Linked Lists Introduction
   What Is A Linked List?
   Exercise: Why Linked Lists?
   Solution: Why Linked Lists?
   What Is A Pointer?
   Our First Linked List
   Solution: append()
   Solution: prepend()
   Node Class
   insert()
   Solution: insert()
   Solution: remove()
   Doubly Linked Lists
   Exercise: Doubly Linked Lists
   Solution: Doubly Linked Lists
   Singly VS Doubly Linked Lists
   Exercise: reverse()
   Solution: reverse()
   Linked Lists Review
   Stacks + Queues Introduction
   Stacks
   Queues
   Exercise: Stacks VS Queues
   Solution: Stacks VS Queues
   Quick Note: Upcoming Video
   Optional: How Javascript Works
   Exercise: Stack Implementation (Linked Lists)
   Solution: Stack Implementation (Linked Lists)
   Exercise: Stack Implementation (Array)
   Solution: Stack Implementation (Array)
   Exercise: Queue Implementation
   Solution: Queue Implementation
   Queues Using Stacks
   Stacks + Queues Review
   Trees Introduction
   Binary Trees
   O(log n)
   Correction: Binary Search Trees
   Binary Search Trees
   Balanced VS Unbalanced BST
   BST Pros and Cons
   Exercise: Binary Search Tree
   Solution: insert()
   Solution: lookup()
   Bonus Exercise: remove()
   Solution: remove()
   AVL Trees + Red Black Trees
   Resources: AVL Trees + Red Black Trees
   Binary Heaps
   Quick Note on Heaps
   Priority Queue
   Trie
   Tree Review
   Graphs Introduction
   Types Of Graphs
   Exercise: Guess The Graph
   Graph Data
   Exercise: Graph Implementation
   Solution: Graph Implementation
   Graphs Review
   Data Structures Review
   What Else Is Coming Up?
   Introduction to Algorithms
   Recursion Introduction
   Stack Overflow
   Anatomy Of Recursion
   Exercise: Factorial
   Solution: Factorial
   Exercise: Fibonacci
   Solution: Fibonacci
   Recursive VS Iterative
   When To Use Recursion
   Exercise: Reverse String With Recursion
   Recursion Review

Algorithms: Sorting
   How To Succeed In This Course
   Join Our Online Classroom!
   Exercise: Meet The Community!
   Section Overview
   Resume
   Exercise: Resume Walkthrough
   Resume Review
   Resources: Resume Templates
   What If I Don't Have Enough Experience?
   Optional Exercise: Github Master
   LinkedIn
   Optional Exercise: LinkedIn Endorsements
   Portfolio
   Resources: Free Portfolio Templates
   Email
   Resources: Email
   Where To Find Jobs?
   Resources: Where To Find Jobs?
   When Should You Start Applying?
   Section Summary
   Setting Up Your Environment
   Section Overview
   What Is Good Code?
   Big O and Scalability
   O(n)
   O(1)
   Exercise: Big O Calculation
   Solution: Big O Calculation
   Exercise: Big O Calculation 2
   Solution: Big O Calculation 2
   Simplifying Big O
   Big O Rule 1
   Big O Rule 2
   Big O Rule 3
   O(n^2)
   Big O Rule 4
   Big O Cheat Sheet
   What Does This All Mean?
   O(n!)
   3 Pillars Of Programming
   Space Complexity
   Exercise: Space Complexity
   Exercise: Twitter
   Optional: Javascript Loops
   Section Summary
   Section Overview
   What Are Companies Looking For?
   What We Need For Coding Interviews
   Exercise: Google Interview
   Exercise: Interview Question
   Exercise: Interview Question 2
   Review Google Interview
   Optional Exercise: Google Interview On Your Own
   Section Summary
   Section Overview
   What Is A Data Structure?
   How Computers Store Data
   Data Structures In Different Languages
   Operations On Data Structures
   Arrays Introduction
   Static vs Dynamic Arrays
   Quick Note: Upcoming Video
   Optional: Classes In Javascript
   Implementing An Array
   Strings and Arrays
   Exercise: Reverse A String
   Solution: Reverse A String
   Exercise: Merge Sorted Arrays
   Solution: Merge Sorted Arrays
   Interview Questions: Arrays
   Arrays Review
   Hash Tables Introduction
   Hash Function
   Hash Collisions
   Hash Tables In Different Languages
   Exercise: Implement A Hash Table
   Solution: Implement A Hash Table
   keys()
   Hash Tables VS Arrays
   Exercise: First Recurring Character
   Solution: First Recurring Character
   Hash Tables Review
   Linked Lists Introduction
   What Is A Linked List?
   Exercise: Why Linked Lists?
   Solution: Why Linked Lists?
   What Is A Pointer?
   Our First Linked List
   Solution: append()
   Solution: prepend()
   Node Class
   insert()
   Solution: insert()
   Solution: remove()
   Doubly Linked Lists
   Exercise: Doubly Linked Lists
   Solution: Doubly Linked Lists
   Singly VS Doubly Linked Lists
   Exercise: reverse()
   Solution: reverse()
   Linked Lists Review
   Stacks + Queues Introduction
   Stacks
   Queues
   Exercise: Stacks VS Queues
   Solution: Stacks VS Queues
   Quick Note: Upcoming Video
   Optional: How Javascript Works
   Exercise: Stack Implementation (Linked Lists)
   Solution: Stack Implementation (Linked Lists)
   Exercise: Stack Implementation (Array)
   Solution: Stack Implementation (Array)
   Exercise: Queue Implementation
   Solution: Queue Implementation
   Queues Using Stacks
   Stacks + Queues Review
   Trees Introduction
   Binary Trees
   O(log n)
   Correction: Binary Search Trees
   Binary Search Trees
   Balanced VS Unbalanced BST
   BST Pros and Cons
   Exercise: Binary Search Tree
   Solution: insert()
   Solution: lookup()
   Bonus Exercise: remove()
   Solution: remove()
   AVL Trees + Red Black Trees
   Resources: AVL Trees + Red Black Trees
   Binary Heaps
   Quick Note on Heaps
   Priority Queue
   Trie
   Tree Review
   Graphs Introduction
   Types Of Graphs
   Exercise: Guess The Graph
   Graph Data
   Exercise: Graph Implementation
   Solution: Graph Implementation
   Graphs Review
   Data Structures Review
   What Else Is Coming Up?
   Introduction to Algorithms
   Recursion Introduction
   Stack Overflow
   Anatomy Of Recursion
   Exercise: Factorial
   Solution: Factorial
   Exercise: Fibonacci
   Solution: Fibonacci
   Recursive VS Iterative
   When To Use Recursion
   Exercise: Reverse String With Recursion
   Recursion Review
   Sorting Introduction
   The Issue With sort()
   Sorting Algorithms
   Bubble Sort
   Exercise: Bubble Sort
   Solution: Bubble Sort
   Selection Sort
   Exercise: Selection Sort
   Solution: Selection Sort
   Dancing Algorithms
   Insertion Sort
   Exercise: Insertion Sort
   Solution: Insertion Sort
   Merge Sort and O(n log n)
   Exercise: Merge Sort
   Solution: Merge Sort
   Stable VS Unstable Algorithms
   Quick Sort
   Optional Exercise: Quick Sort
   Which Sort Is Best?
   Resources: Heap Sort
   Radix Sort + Counting Sort
   Resources: Radix Sort + Counting Sort
   Exercise: Sorting Interview
   Solution: Sorting Interview
   Sorting In Your Language
   Sorting Review

Algorithms: Searching + BFS + DFS
   How To Succeed In This Course
   Join Our Online Classroom!
   Exercise: Meet The Community!
   Section Overview
   Resume
   Exercise: Resume Walkthrough
   Resume Review
   Resources: Resume Templates
   What If I Don't Have Enough Experience?
   Optional Exercise: Github Master
   LinkedIn
   Optional Exercise: LinkedIn Endorsements
   Portfolio
   Resources: Free Portfolio Templates
   Email
   Resources: Email
   Where To Find Jobs?
   Resources: Where To Find Jobs?
   When Should You Start Applying?
   Section Summary
   Setting Up Your Environment
   Section Overview
   What Is Good Code?
   Big O and Scalability
   O(n)
   O(1)
   Exercise: Big O Calculation
   Solution: Big O Calculation
   Exercise: Big O Calculation 2
   Solution: Big O Calculation 2
   Simplifying Big O
   Big O Rule 1
   Big O Rule 2
   Big O Rule 3
   O(n^2)
   Big O Rule 4
   Big O Cheat Sheet
   What Does This All Mean?
   O(n!)
   3 Pillars Of Programming
   Space Complexity
   Exercise: Space Complexity
   Exercise: Twitter
   Optional: Javascript Loops
   Section Summary
   Section Overview
   What Are Companies Looking For?
   What We Need For Coding Interviews
   Exercise: Google Interview
   Exercise: Interview Question
   Exercise: Interview Question 2
   Review Google Interview
   Optional Exercise: Google Interview On Your Own
   Section Summary
   Section Overview
   What Is A Data Structure?
   How Computers Store Data
   Data Structures In Different Languages
   Operations On Data Structures
   Arrays Introduction
   Static vs Dynamic Arrays
   Quick Note: Upcoming Video
   Optional: Classes In Javascript
   Implementing An Array
   Strings and Arrays
   Exercise: Reverse A String
   Solution: Reverse A String
   Exercise: Merge Sorted Arrays
   Solution: Merge Sorted Arrays
   Interview Questions: Arrays
   Arrays Review
   Hash Tables Introduction
   Hash Function
   Hash Collisions
   Hash Tables In Different Languages
   Exercise: Implement A Hash Table
   Solution: Implement A Hash Table
   keys()
   Hash Tables VS Arrays
   Exercise: First Recurring Character
   Solution: First Recurring Character
   Hash Tables Review
   Linked Lists Introduction
   What Is A Linked List?
   Exercise: Why Linked Lists?
   Solution: Why Linked Lists?
   What Is A Pointer?
   Our First Linked List
   Solution: append()
   Solution: prepend()
   Node Class
   insert()
   Solution: insert()
   Solution: remove()
   Doubly Linked Lists
   Exercise: Doubly Linked Lists
   Solution: Doubly Linked Lists
   Singly VS Doubly Linked Lists
   Exercise: reverse()
   Solution: reverse()
   Linked Lists Review
   Stacks + Queues Introduction
   Stacks
   Queues
   Exercise: Stacks VS Queues
   Solution: Stacks VS Queues
   Quick Note: Upcoming Video
   Optional: How Javascript Works
   Exercise: Stack Implementation (Linked Lists)
   Solution: Stack Implementation (Linked Lists)
   Exercise: Stack Implementation (Array)
   Solution: Stack Implementation (Array)
   Exercise: Queue Implementation
   Solution: Queue Implementation
   Queues Using Stacks
   Stacks + Queues Review
   Trees Introduction
   Binary Trees
   O(log n)
   Correction: Binary Search Trees
   Binary Search Trees
   Balanced VS Unbalanced BST
   BST Pros and Cons
   Exercise: Binary Search Tree
   Solution: insert()
   Solution: lookup()
   Bonus Exercise: remove()
   Solution: remove()
   AVL Trees + Red Black Trees
   Resources: AVL Trees + Red Black Trees
   Binary Heaps
   Quick Note on Heaps
   Priority Queue
   Trie
   Tree Review
   Graphs Introduction
   Types Of Graphs
   Exercise: Guess The Graph
   Graph Data
   Exercise: Graph Implementation
   Solution: Graph Implementation
   Graphs Review
   Data Structures Review
   What Else Is Coming Up?
   Introduction to Algorithms
   Recursion Introduction
   Stack Overflow
   Anatomy Of Recursion
   Exercise: Factorial
   Solution: Factorial
   Exercise: Fibonacci
   Solution: Fibonacci
   Recursive VS Iterative
   When To Use Recursion
   Exercise: Reverse String With Recursion
   Recursion Review
   Sorting Introduction
   The Issue With sort()
   Sorting Algorithms
   Bubble Sort
   Exercise: Bubble Sort
   Solution: Bubble Sort
   Selection Sort
   Exercise: Selection Sort
   Solution: Selection Sort
   Dancing Algorithms
   Insertion Sort
   Exercise: Insertion Sort
   Solution: Insertion Sort
   Merge Sort and O(n log n)
   Exercise: Merge Sort
   Solution: Merge Sort
   Stable VS Unstable Algorithms
   Quick Sort
   Optional Exercise: Quick Sort
   Which Sort Is Best?
   Resources: Heap Sort
   Radix Sort + Counting Sort
   Resources: Radix Sort + Counting Sort
   Exercise: Sorting Interview
   Solution: Sorting Interview
   Sorting In Your Language
   Sorting Review
   Searching + Traversal Introduction
   Linear Search
   Binary Search
   Graph + Tree Traversals
   BFS Introduction
   DFS Introduction
   BFS vs DFS
   Resources: BFS vs DFS
   Exercise: BFS vs DFS
   Solution: BFS vs DFS
   breadthFirstSearch()
   breadthFirstSearchRecursive()
   PreOrder, InOrder, PostOrder
   depthFirstSearch()
   Optional Exercise: Validate A BST
   Graph Traversals
   BFS in Graphs
   DFS in Graphs
   Dijkstra + Bellman-Ford Algorithms
   Searching + Traversal Review

Algorithms: Dynamic Programming
   How To Succeed In This Course
   Join Our Online Classroom!
   Exercise: Meet The Community!
   Section Overview
   Resume
   Exercise: Resume Walkthrough
   Resume Review
   Resources: Resume Templates
   What If I Don't Have Enough Experience?
   Optional Exercise: Github Master
   LinkedIn
   Optional Exercise: LinkedIn Endorsements
   Portfolio
   Resources: Free Portfolio Templates
   Email
   Resources: Email
   Where To Find Jobs?
   Resources: Where To Find Jobs?
   When Should You Start Applying?
   Section Summary
   Setting Up Your Environment
   Section Overview
   What Is Good Code?
   Big O and Scalability
   O(n)
   O(1)
   Exercise: Big O Calculation
   Solution: Big O Calculation
   Exercise: Big O Calculation 2
   Solution: Big O Calculation 2
   Simplifying Big O
   Big O Rule 1
   Big O Rule 2
   Big O Rule 3
   O(n^2)
   Big O Rule 4
   Big O Cheat Sheet
   What Does This All Mean?
   O(n!)
   3 Pillars Of Programming
   Space Complexity
   Exercise: Space Complexity
   Exercise: Twitter
   Optional: Javascript Loops
   Section Summary
   Section Overview
   What Are Companies Looking For?
   What We Need For Coding Interviews
   Exercise: Google Interview
   Exercise: Interview Question
   Exercise: Interview Question 2
   Review Google Interview
   Optional Exercise: Google Interview On Your Own
   Section Summary
   Section Overview
   What Is A Data Structure?
   How Computers Store Data
   Data Structures In Different Languages
   Operations On Data Structures
   Arrays Introduction
   Static vs Dynamic Arrays
   Quick Note: Upcoming Video
   Optional: Classes In Javascript
   Implementing An Array
   Strings and Arrays
   Exercise: Reverse A String
   Solution: Reverse A String
   Exercise: Merge Sorted Arrays
   Solution: Merge Sorted Arrays
   Interview Questions: Arrays
   Arrays Review
   Hash Tables Introduction
   Hash Function
   Hash Collisions
   Hash Tables In Different Languages
   Exercise: Implement A Hash Table
   Solution: Implement A Hash Table
   keys()
   Hash Tables VS Arrays
   Exercise: First Recurring Character
   Solution: First Recurring Character
   Hash Tables Review
   Linked Lists Introduction
   What Is A Linked List?
   Exercise: Why Linked Lists?
   Solution: Why Linked Lists?
   What Is A Pointer?
   Our First Linked List
   Solution: append()
   Solution: prepend()
   Node Class
   insert()
   Solution: insert()
   Solution: remove()
   Doubly Linked Lists
   Exercise: Doubly Linked Lists
   Solution: Doubly Linked Lists
   Singly VS Doubly Linked Lists
   Exercise: reverse()
   Solution: reverse()
   Linked Lists Review
   Stacks + Queues Introduction
   Stacks
   Queues
   Exercise: Stacks VS Queues
   Solution: Stacks VS Queues
   Quick Note: Upcoming Video
   Optional: How Javascript Works
   Exercise: Stack Implementation (Linked Lists)
   Solution: Stack Implementation (Linked Lists)
   Exercise: Stack Implementation (Array)
   Solution: Stack Implementation (Array)
   Exercise: Queue Implementation
   Solution: Queue Implementation
   Queues Using Stacks
   Stacks + Queues Review
   Trees Introduction
   Binary Trees
   O(log n)
   Correction: Binary Search Trees
   Binary Search Trees
   Balanced VS Unbalanced BST
   BST Pros and Cons
   Exercise: Binary Search Tree
   Solution: insert()
   Solution: lookup()
   Bonus Exercise: remove()
   Solution: remove()
   AVL Trees + Red Black Trees
   Resources: AVL Trees + Red Black Trees
   Binary Heaps
   Quick Note on Heaps
   Priority Queue
   Trie
   Tree Review
   Graphs Introduction
   Types Of Graphs
   Exercise: Guess The Graph
   Graph Data
   Exercise: Graph Implementation
   Solution: Graph Implementation
   Graphs Review
   Data Structures Review
   What Else Is Coming Up?
   Introduction to Algorithms
   Recursion Introduction
   Stack Overflow
   Anatomy Of Recursion
   Exercise: Factorial
   Solution: Factorial
   Exercise: Fibonacci
   Solution: Fibonacci
   Recursive VS Iterative
   When To Use Recursion
   Exercise: Reverse String With Recursion
   Recursion Review
   Sorting Introduction
   The Issue With sort()
   Sorting Algorithms
   Bubble Sort
   Exercise: Bubble Sort
   Solution: Bubble Sort
   Selection Sort
   Exercise: Selection Sort
   Solution: Selection Sort
   Dancing Algorithms
   Insertion Sort
   Exercise: Insertion Sort
   Solution: Insertion Sort
   Merge Sort and O(n log n)
   Exercise: Merge Sort
   Solution: Merge Sort
   Stable VS Unstable Algorithms
   Quick Sort
   Optional Exercise: Quick Sort
   Which Sort Is Best?
   Resources: Heap Sort
   Radix Sort + Counting Sort
   Resources: Radix Sort + Counting Sort
   Exercise: Sorting Interview
   Solution: Sorting Interview
   Sorting In Your Language
   Sorting Review
   Searching + Traversal Introduction
   Linear Search
   Binary Search
   Graph + Tree Traversals
   BFS Introduction
   DFS Introduction
   BFS vs DFS
   Resources: BFS vs DFS
   Exercise: BFS vs DFS
   Solution: BFS vs DFS
   breadthFirstSearch()
   breadthFirstSearchRecursive()
   PreOrder, InOrder, PostOrder
   depthFirstSearch()
   Optional Exercise: Validate A BST
   Graph Traversals
   BFS in Graphs
   DFS in Graphs
   Dijkstra + Bellman-Ford Algorithms
   Searching + Traversal Review
   Dynamic Programming Introduction
   Memoization 1
   Memoization 2
   Fibonacci and Dynamic Programming
   Dynamic Programming
   Implementing Dynamic Programming
   Interview Questions: Dynamic Programming
   Dynamic Programming Review

Non Technical Interviews
   How To Succeed In This Course
   Join Our Online Classroom!
   Exercise: Meet The Community!
   Section Overview
   Resume
   Exercise: Resume Walkthrough
   Resume Review
   Resources: Resume Templates
   What If I Don't Have Enough Experience?
   Optional Exercise: Github Master
   LinkedIn
   Optional Exercise: LinkedIn Endorsements
   Portfolio
   Resources: Free Portfolio Templates
   Email
   Resources: Email
   Where To Find Jobs?
   Resources: Where To Find Jobs?
   When Should You Start Applying?
   Section Summary
   Setting Up Your Environment
   Section Overview
   What Is Good Code?
   Big O and Scalability
   O(n)
   O(1)
   Exercise: Big O Calculation
   Solution: Big O Calculation
   Exercise: Big O Calculation 2
   Solution: Big O Calculation 2
   Simplifying Big O
   Big O Rule 1
   Big O Rule 2
   Big O Rule 3
   O(n^2)
   Big O Rule 4
   Big O Cheat Sheet
   What Does This All Mean?
   O(n!)
   3 Pillars Of Programming
   Space Complexity
   Exercise: Space Complexity
   Exercise: Twitter
   Optional: Javascript Loops
   Section Summary
   Section Overview
   What Are Companies Looking For?
   What We Need For Coding Interviews
   Exercise: Google Interview
   Exercise: Interview Question
   Exercise: Interview Question 2
   Review Google Interview
   Optional Exercise: Google Interview On Your Own
   Section Summary
   Section Overview
   What Is A Data Structure?
   How Computers Store Data
   Data Structures In Different Languages
   Operations On Data Structures
   Arrays Introduction
   Static vs Dynamic Arrays
   Quick Note: Upcoming Video
   Optional: Classes In Javascript
   Implementing An Array
   Strings and Arrays
   Exercise: Reverse A String
   Solution: Reverse A String
   Exercise: Merge Sorted Arrays
   Solution: Merge Sorted Arrays
   Interview Questions: Arrays
   Arrays Review
   Hash Tables Introduction
   Hash Function
   Hash Collisions
   Hash Tables In Different Languages
   Exercise: Implement A Hash Table
   Solution: Implement A Hash Table
   keys()
   Hash Tables VS Arrays
   Exercise: First Recurring Character
   Solution: First Recurring Character
   Hash Tables Review
   Linked Lists Introduction
   What Is A Linked List?
   Exercise: Why Linked Lists?
   Solution: Why Linked Lists?
   What Is A Pointer?
   Our First Linked List
   Solution: append()
   Solution: prepend()
   Node Class
   insert()
   Solution: insert()
   Solution: remove()
   Doubly Linked Lists
   Exercise: Doubly Linked Lists
   Solution: Doubly Linked Lists
   Singly VS Doubly Linked Lists
   Exercise: reverse()
   Solution: reverse()
   Linked Lists Review
   Stacks + Queues Introduction
   Stacks
   Queues
   Exercise: Stacks VS Queues
   Solution: Stacks VS Queues
   Quick Note: Upcoming Video
   Optional: How Javascript Works
   Exercise: Stack Implementation (Linked Lists)
   Solution: Stack Implementation (Linked Lists)
   Exercise: Stack Implementation (Array)
   Solution: Stack Implementation (Array)
   Exercise: Queue Implementation
   Solution: Queue Implementation
   Queues Using Stacks
   Stacks + Queues Review
   Trees Introduction
   Binary Trees
   O(log n)
   Correction: Binary Search Trees
   Binary Search Trees
   Balanced VS Unbalanced BST
   BST Pros and Cons
   Exercise: Binary Search Tree
   Solution: insert()
   Solution: lookup()
   Bonus Exercise: remove()
   Solution: remove()
   AVL Trees + Red Black Trees
   Resources: AVL Trees + Red Black Trees
   Binary Heaps
   Quick Note on Heaps
   Priority Queue
   Trie
   Tree Review
   Graphs Introduction
   Types Of Graphs
   Exercise: Guess The Graph
   Graph Data
   Exercise: Graph Implementation
   Solution: Graph Implementation
   Graphs Review
   Data Structures Review
   What Else Is Coming Up?
   Introduction to Algorithms
   Recursion Introduction
   Stack Overflow
   Anatomy Of Recursion
   Exercise: Factorial
   Solution: Factorial
   Exercise: Fibonacci
   Solution: Fibonacci
   Recursive VS Iterative
   When To Use Recursion
   Exercise: Reverse String With Recursion
   Recursion Review
   Sorting Introduction
   The Issue With sort()
   Sorting Algorithms
   Bubble Sort
   Exercise: Bubble Sort
   Solution: Bubble Sort
   Selection Sort
   Exercise: Selection Sort
   Solution: Selection Sort
   Dancing Algorithms
   Insertion Sort
   Exercise: Insertion Sort
   Solution: Insertion Sort
   Merge Sort and O(n log n)
   Exercise: Merge Sort
   Solution: Merge Sort
   Stable VS Unstable Algorithms
   Quick Sort
   Optional Exercise: Quick Sort
   Which Sort Is Best?
   Resources: Heap Sort
   Radix Sort + Counting Sort
   Resources: Radix Sort + Counting Sort
   Exercise: Sorting Interview
   Solution: Sorting Interview
   Sorting In Your Language
   Sorting Review
   Searching + Traversal Introduction
   Linear Search
   Binary Search
   Graph + Tree Traversals
   BFS Introduction
   DFS Introduction
   BFS vs DFS
   Resources: BFS vs DFS
   Exercise: BFS vs DFS
   Solution: BFS vs DFS
   breadthFirstSearch()
   breadthFirstSearchRecursive()
   PreOrder, InOrder, PostOrder
   depthFirstSearch()
   Optional Exercise: Validate A BST
   Graph Traversals
   BFS in Graphs
   DFS in Graphs
   Dijkstra + Bellman-Ford Algorithms
   Searching + Traversal Review
   Dynamic Programming Introduction
   Memoization 1
   Memoization 2
   Fibonacci and Dynamic Programming
   Dynamic Programming
   Implementing Dynamic Programming
   Interview Questions: Dynamic Programming
   Dynamic Programming Review
   Section Overview
   During The Interview
   Exercise: Hero Stories
   Tell Me About Yourself
   Exercise: Your Pitch
   Why Us?
   Tell Me About A Problem You Have Solved
   Exercise: Past Projects
   What Is Your Biggest Weakness
   Exercise: Your Biggest Weakness
   Any Questions For Us?
   Resources: Questions To Ask A Company
   Secret Weapon
   After The Interview
   Section Summary

Offer + Negotiation
   How To Succeed In This Course
   Join Our Online Classroom!
   Exercise: Meet The Community!
   Section Overview
   Resume
   Exercise: Resume Walkthrough
   Resume Review
   Resources: Resume Templates
   What If I Don't Have Enough Experience?
   Optional Exercise: Github Master
   LinkedIn
   Optional Exercise: LinkedIn Endorsements
   Portfolio
   Resources: Free Portfolio Templates
   Email
   Resources: Email
   Where To Find Jobs?
   Resources: Where To Find Jobs?
   When Should You Start Applying?
   Section Summary
   Setting Up Your Environment
   Section Overview
   What Is Good Code?
   Big O and Scalability
   O(n)
   O(1)
   Exercise: Big O Calculation
   Solution: Big O Calculation
   Exercise: Big O Calculation 2
   Solution: Big O Calculation 2
   Simplifying Big O
   Big O Rule 1
   Big O Rule 2
   Big O Rule 3
   O(n^2)
   Big O Rule 4
   Big O Cheat Sheet
   What Does This All Mean?
   O(n!)
   3 Pillars Of Programming
   Space Complexity
   Exercise: Space Complexity
   Exercise: Twitter
   Optional: Javascript Loops
   Section Summary
   Section Overview
   What Are Companies Looking For?
   What We Need For Coding Interviews
   Exercise: Google Interview
   Exercise: Interview Question
   Exercise: Interview Question 2
   Review Google Interview
   Optional Exercise: Google Interview On Your Own
   Section Summary
   Section Overview
   What Is A Data Structure?
   How Computers Store Data
   Data Structures In Different Languages
   Operations On Data Structures
   Arrays Introduction
   Static vs Dynamic Arrays
   Quick Note: Upcoming Video
   Optional: Classes In Javascript
   Implementing An Array
   Strings and Arrays
   Exercise: Reverse A String
   Solution: Reverse A String
   Exercise: Merge Sorted Arrays
   Solution: Merge Sorted Arrays
   Interview Questions: Arrays
   Arrays Review
   Hash Tables Introduction
   Hash Function
   Hash Collisions
   Hash Tables In Different Languages
   Exercise: Implement A Hash Table
   Solution: Implement A Hash Table
   keys()
   Hash Tables VS Arrays
   Exercise: First Recurring Character
   Solution: First Recurring Character
   Hash Tables Review
   Linked Lists Introduction
   What Is A Linked List?
   Exercise: Why Linked Lists?
   Solution: Why Linked Lists?
   What Is A Pointer?
   Our First Linked List
   Solution: append()
   Solution: prepend()
   Node Class
   insert()
   Solution: insert()
   Solution: remove()
   Doubly Linked Lists
   Exercise: Doubly Linked Lists
   Solution: Doubly Linked Lists
   Singly VS Doubly Linked Lists
   Exercise: reverse()
   Solution: reverse()
   Linked Lists Review
   Stacks + Queues Introduction
   Stacks
   Queues
   Exercise: Stacks VS Queues
   Solution: Stacks VS Queues
   Quick Note: Upcoming Video
   Optional: How Javascript Works
   Exercise: Stack Implementation (Linked Lists)
   Solution: Stack Implementation (Linked Lists)
   Exercise: Stack Implementation (Array)
   Solution: Stack Implementation (Array)
   Exercise: Queue Implementation
   Solution: Queue Implementation
   Queues Using Stacks
   Stacks + Queues Review
   Trees Introduction
   Binary Trees
   O(log n)
   Correction: Binary Search Trees
   Binary Search Trees
   Balanced VS Unbalanced BST
   BST Pros and Cons
   Exercise: Binary Search Tree
   Solution: insert()
   Solution: lookup()
   Bonus Exercise: remove()
   Solution: remove()
   AVL Trees + Red Black Trees
   Resources: AVL Trees + Red Black Trees
   Binary Heaps
   Quick Note on Heaps
   Priority Queue
   Trie
   Tree Review
   Graphs Introduction
   Types Of Graphs
   Exercise: Guess The Graph
   Graph Data
   Exercise: Graph Implementation
   Solution: Graph Implementation
   Graphs Review
   Data Structures Review
   What Else Is Coming Up?
   Introduction to Algorithms
   Recursion Introduction
   Stack Overflow
   Anatomy Of Recursion
   Exercise: Factorial
   Solution: Factorial
   Exercise: Fibonacci
   Solution: Fibonacci
   Recursive VS Iterative
   When To Use Recursion
   Exercise: Reverse String With Recursion
   Recursion Review
   Sorting Introduction
   The Issue With sort()
   Sorting Algorithms
   Bubble Sort
   Exercise: Bubble Sort
   Solution: Bubble Sort
   Selection Sort
   Exercise: Selection Sort
   Solution: Selection Sort
   Dancing Algorithms
   Insertion Sort
   Exercise: Insertion Sort
   Solution: Insertion Sort
   Merge Sort and O(n log n)
   Exercise: Merge Sort
   Solution: Merge Sort
   Stable VS Unstable Algorithms
   Quick Sort
   Optional Exercise: Quick Sort
   Which Sort Is Best?
   Resources: Heap Sort
   Radix Sort + Counting Sort
   Resources: Radix Sort + Counting Sort
   Exercise: Sorting Interview
   Solution: Sorting Interview
   Sorting In Your Language
   Sorting Review
   Searching + Traversal Introduction
   Linear Search
   Binary Search
   Graph + Tree Traversals
   BFS Introduction
   DFS Introduction
   BFS vs DFS
   Resources: BFS vs DFS
   Exercise: BFS vs DFS
   Solution: BFS vs DFS
   breadthFirstSearch()
   breadthFirstSearchRecursive()
   PreOrder, InOrder, PostOrder
   depthFirstSearch()
   Optional Exercise: Validate A BST
   Graph Traversals
   BFS in Graphs
   DFS in Graphs
   Dijkstra + Bellman-Ford Algorithms
   Searching + Traversal Review
   Dynamic Programming Introduction
   Memoization 1
   Memoization 2
   Fibonacci and Dynamic Programming
   Dynamic Programming
   Implementing Dynamic Programming
   Interview Questions: Dynamic Programming
   Dynamic Programming Review
   Section Overview
   During The Interview
   Exercise: Hero Stories
   Tell Me About Yourself
   Exercise: Your Pitch
   Why Us?
   Tell Me About A Problem You Have Solved
   Exercise: Past Projects
   What Is Your Biggest Weakness
   Exercise: Your Biggest Weakness
   Any Questions For Us?
   Resources: Questions To Ask A Company
   Secret Weapon
   After The Interview
   Section Summary
   Section Overview
   Handling Rejection
   Negotiation 101
   Handling An Offer
   Handling Multiple Offers
   Getting A Raise
   Exercise: Negotiation Master
   Section Summary

Thank You
   How To Succeed In This Course
   Join Our Online Classroom!
   Exercise: Meet The Community!
   Section Overview
   Resume
   Exercise: Resume Walkthrough
   Resume Review
   Resources: Resume Templates
   What If I Don't Have Enough Experience?
   Optional Exercise: Github Master
   LinkedIn
   Optional Exercise: LinkedIn Endorsements
   Portfolio
   Resources: Free Portfolio Templates
   Email
   Resources: Email
   Where To Find Jobs?
   Resources: Where To Find Jobs?
   When Should You Start Applying?
   Section Summary
   Setting Up Your Environment
   Section Overview
   What Is Good Code?
   Big O and Scalability
   O(n)
   O(1)
   Exercise: Big O Calculation
   Solution: Big O Calculation
   Exercise: Big O Calculation 2
   Solution: Big O Calculation 2
   Simplifying Big O
   Big O Rule 1
   Big O Rule 2
   Big O Rule 3
   O(n^2)
   Big O Rule 4
   Big O Cheat Sheet
   What Does This All Mean?
   O(n!)
   3 Pillars Of Programming
   Space Complexity
   Exercise: Space Complexity
   Exercise: Twitter
   Optional: Javascript Loops
   Section Summary
   Section Overview
   What Are Companies Looking For?
   What We Need For Coding Interviews
   Exercise: Google Interview
   Exercise: Interview Question
   Exercise: Interview Question 2
   Review Google Interview
   Optional Exercise: Google Interview On Your Own
   Section Summary
   Section Overview
   What Is A Data Structure?
   How Computers Store Data
   Data Structures In Different Languages
   Operations On Data Structures
   Arrays Introduction
   Static vs Dynamic Arrays
   Quick Note: Upcoming Video
   Optional: Classes In Javascript
   Implementing An Array
   Strings and Arrays
   Exercise: Reverse A String
   Solution: Reverse A String
   Exercise: Merge Sorted Arrays
   Solution: Merge Sorted Arrays
   Interview Questions: Arrays
   Arrays Review
   Hash Tables Introduction
   Hash Function
   Hash Collisions
   Hash Tables In Different Languages
   Exercise: Implement A Hash Table
   Solution: Implement A Hash Table
   keys()
   Hash Tables VS Arrays
   Exercise: First Recurring Character
   Solution: First Recurring Character
   Hash Tables Review
   Linked Lists Introduction
   What Is A Linked List?
   Exercise: Why Linked Lists?
   Solution: Why Linked Lists?
   What Is A Pointer?
   Our First Linked List
   Solution: append()
   Solution: prepend()
   Node Class
   insert()
   Solution: insert()
   Solution: remove()
   Doubly Linked Lists
   Exercise: Doubly Linked Lists
   Solution: Doubly Linked Lists
   Singly VS Doubly Linked Lists
   Exercise: reverse()
   Solution: reverse()
   Linked Lists Review
   Stacks + Queues Introduction
   Stacks
   Queues
   Exercise: Stacks VS Queues
   Solution: Stacks VS Queues
   Quick Note: Upcoming Video
   Optional: How Javascript Works
   Exercise: Stack Implementation (Linked Lists)
   Solution: Stack Implementation (Linked Lists)
   Exercise: Stack Implementation (Array)
   Solution: Stack Implementation (Array)
   Exercise: Queue Implementation
   Solution: Queue Implementation
   Queues Using Stacks
   Stacks + Queues Review
   Trees Introduction
   Binary Trees
   O(log n)
   Correction: Binary Search Trees
   Binary Search Trees
   Balanced VS Unbalanced BST
   BST Pros and Cons
   Exercise: Binary Search Tree
   Solution: insert()
   Solution: lookup()
   Bonus Exercise: remove()
   Solution: remove()
   AVL Trees + Red Black Trees
   Resources: AVL Trees + Red Black Trees
   Binary Heaps
   Quick Note on Heaps
   Priority Queue
   Trie
   Tree Review
   Graphs Introduction
   Types Of Graphs
   Exercise: Guess The Graph
   Graph Data
   Exercise: Graph Implementation
   Solution: Graph Implementation
   Graphs Review
   Data Structures Review
   What Else Is Coming Up?
   Introduction to Algorithms
   Recursion Introduction
   Stack Overflow
   Anatomy Of Recursion
   Exercise: Factorial
   Solution: Factorial
   Exercise: Fibonacci
   Solution: Fibonacci
   Recursive VS Iterative
   When To Use Recursion
   Exercise: Reverse String With Recursion
   Recursion Review
   Sorting Introduction
   The Issue With sort()
   Sorting Algorithms
   Bubble Sort
   Exercise: Bubble Sort
   Solution: Bubble Sort
   Selection Sort
   Exercise: Selection Sort
   Solution: Selection Sort
   Dancing Algorithms
   Insertion Sort
   Exercise: Insertion Sort
   Solution: Insertion Sort
   Merge Sort and O(n log n)
   Exercise: Merge Sort
   Solution: Merge Sort
   Stable VS Unstable Algorithms
   Quick Sort
   Optional Exercise: Quick Sort
   Which Sort Is Best?
   Resources: Heap Sort
   Radix Sort + Counting Sort
   Resources: Radix Sort + Counting Sort
   Exercise: Sorting Interview
   Solution: Sorting Interview
   Sorting In Your Language
   Sorting Review
   Searching + Traversal Introduction
   Linear Search
   Binary Search
   Graph + Tree Traversals
   BFS Introduction
   DFS Introduction
   BFS vs DFS
   Resources: BFS vs DFS
   Exercise: BFS vs DFS
   Solution: BFS vs DFS
   breadthFirstSearch()
   breadthFirstSearchRecursive()
   PreOrder, InOrder, PostOrder
   depthFirstSearch()
   Optional Exercise: Validate A BST
   Graph Traversals
   BFS in Graphs
   DFS in Graphs
   Dijkstra + Bellman-Ford Algorithms
   Searching + Traversal Review
   Dynamic Programming Introduction
   Memoization 1
   Memoization 2
   Fibonacci and Dynamic Programming
   Dynamic Programming
   Implementing Dynamic Programming
   Interview Questions: Dynamic Programming
   Dynamic Programming Review
   Section Overview
   During The Interview
   Exercise: Hero Stories
   Tell Me About Yourself
   Exercise: Your Pitch
   Why Us?
   Tell Me About A Problem You Have Solved
   Exercise: Past Projects
   What Is Your Biggest Weakness
   Exercise: Your Biggest Weakness
   Any Questions For Us?
   Resources: Questions To Ask A Company
   Secret Weapon
   After The Interview
   Section Summary
   Section Overview
   Handling Rejection
   Negotiation 101
   Handling An Offer
   Handling Multiple Offers
   Getting A Raise
   Exercise: Negotiation Master
   Section Summary
   Become an Alumni
   Thank You.
   What You Can Do Now

Extras: Google, Amazon, Facebook Interview Questions
   How To Succeed In This Course
   Join Our Online Classroom!
   Exercise: Meet The Community!
   Section Overview
   Resume
   Exercise: Resume Walkthrough
   Resume Review
   Resources: Resume Templates
   What If I Don't Have Enough Experience?
   Optional Exercise: Github Master
   LinkedIn
   Optional Exercise: LinkedIn Endorsements
   Portfolio
   Resources: Free Portfolio Templates
   Email
   Resources: Email
   Where To Find Jobs?
   Resources: Where To Find Jobs?
   When Should You Start Applying?
   Section Summary
   Setting Up Your Environment
   Section Overview
   What Is Good Code?
   Big O and Scalability
   O(n)
   O(1)
   Exercise: Big O Calculation
   Solution: Big O Calculation
   Exercise: Big O Calculation 2
   Solution: Big O Calculation 2
   Simplifying Big O
   Big O Rule 1
   Big O Rule 2
   Big O Rule 3
   O(n^2)
   Big O Rule 4
   Big O Cheat Sheet
   What Does This All Mean?
   O(n!)
   3 Pillars Of Programming
   Space Complexity
   Exercise: Space Complexity
   Exercise: Twitter
   Optional: Javascript Loops
   Section Summary
   Section Overview
   What Are Companies Looking For?
   What We Need For Coding Interviews
   Exercise: Google Interview
   Exercise: Interview Question
   Exercise: Interview Question 2
   Review Google Interview
   Optional Exercise: Google Interview On Your Own
   Section Summary
   Section Overview
   What Is A Data Structure?
   How Computers Store Data
   Data Structures In Different Languages
   Operations On Data Structures
   Arrays Introduction
   Static vs Dynamic Arrays
   Quick Note: Upcoming Video
   Optional: Classes In Javascript
   Implementing An Array
   Strings and Arrays
   Exercise: Reverse A String
   Solution: Reverse A String
   Exercise: Merge Sorted Arrays
   Solution: Merge Sorted Arrays
   Interview Questions: Arrays
   Arrays Review
   Hash Tables Introduction
   Hash Function
   Hash Collisions
   Hash Tables In Different Languages
   Exercise: Implement A Hash Table
   Solution: Implement A Hash Table
   keys()
   Hash Tables VS Arrays
   Exercise: First Recurring Character
   Solution: First Recurring Character
   Hash Tables Review
   Linked Lists Introduction
   What Is A Linked List?
   Exercise: Why Linked Lists?
   Solution: Why Linked Lists?
   What Is A Pointer?
   Our First Linked List
   Solution: append()
   Solution: prepend()
   Node Class
   insert()
   Solution: insert()
   Solution: remove()
   Doubly Linked Lists
   Exercise: Doubly Linked Lists
   Solution: Doubly Linked Lists
   Singly VS Doubly Linked Lists
   Exercise: reverse()
   Solution: reverse()
   Linked Lists Review
   Stacks + Queues Introduction
   Stacks
   Queues
   Exercise: Stacks VS Queues
   Solution: Stacks VS Queues
   Quick Note: Upcoming Video
   Optional: How Javascript Works
   Exercise: Stack Implementation (Linked Lists)
   Solution: Stack Implementation (Linked Lists)
   Exercise: Stack Implementation (Array)
   Solution: Stack Implementation (Array)
   Exercise: Queue Implementation
   Solution: Queue Implementation
   Queues Using Stacks
   Stacks + Queues Review
   Trees Introduction
   Binary Trees
   O(log n)
   Correction: Binary Search Trees
   Binary Search Trees
   Balanced VS Unbalanced BST
   BST Pros and Cons
   Exercise: Binary Search Tree
   Solution: insert()
   Solution: lookup()
   Bonus Exercise: remove()
   Solution: remove()
   AVL Trees + Red Black Trees
   Resources: AVL Trees + Red Black Trees
   Binary Heaps
   Quick Note on Heaps
   Priority Queue
   Trie
   Tree Review
   Graphs Introduction
   Types Of Graphs
   Exercise: Guess The Graph
   Graph Data
   Exercise: Graph Implementation
   Solution: Graph Implementation
   Graphs Review
   Data Structures Review
   What Else Is Coming Up?
   Introduction to Algorithms
   Recursion Introduction
   Stack Overflow
   Anatomy Of Recursion
   Exercise: Factorial
   Solution: Factorial
   Exercise: Fibonacci
   Solution: Fibonacci
   Recursive VS Iterative
   When To Use Recursion
   Exercise: Reverse String With Recursion
   Recursion Review
   Sorting Introduction
   The Issue With sort()
   Sorting Algorithms
   Bubble Sort
   Exercise: Bubble Sort
   Solution: Bubble Sort
   Selection Sort
   Exercise: Selection Sort
   Solution: Selection Sort
   Dancing Algorithms
   Insertion Sort
   Exercise: Insertion Sort
   Solution: Insertion Sort
   Merge Sort and O(n log n)
   Exercise: Merge Sort
   Solution: Merge Sort
   Stable VS Unstable Algorithms
   Quick Sort
   Optional Exercise: Quick Sort
   Which Sort Is Best?
   Resources: Heap Sort
   Radix Sort + Counting Sort
   Resources: Radix Sort + Counting Sort
   Exercise: Sorting Interview
   Solution: Sorting Interview
   Sorting In Your Language
   Sorting Review
   Searching + Traversal Introduction
   Linear Search
   Binary Search
   Graph + Tree Traversals
   BFS Introduction
   DFS Introduction
   BFS vs DFS
   Resources: BFS vs DFS
   Exercise: BFS vs DFS
   Solution: BFS vs DFS
   breadthFirstSearch()
   breadthFirstSearchRecursive()
   PreOrder, InOrder, PostOrder
   depthFirstSearch()
   Optional Exercise: Validate A BST
   Graph Traversals
   BFS in Graphs
   DFS in Graphs
   Dijkstra + Bellman-Ford Algorithms
   Searching + Traversal Review
   Dynamic Programming Introduction
   Memoization 1
   Memoization 2
   Fibonacci and Dynamic Programming
   Dynamic Programming
   Implementing Dynamic Programming
   Interview Questions: Dynamic Programming
   Dynamic Programming Review
   Section Overview
   During The Interview
   Exercise: Hero Stories
   Tell Me About Yourself
   Exercise: Your Pitch
   Why Us?
   Tell Me About A Problem You Have Solved
   Exercise: Past Projects
   What Is Your Biggest Weakness
   Exercise: Your Biggest Weakness
   Any Questions For Us?
   Resources: Questions To Ask A Company
   Secret Weapon
   After The Interview
   Section Summary
   Section Overview
   Handling Rejection
   Negotiation 101
   Handling An Offer
   Handling Multiple Offers
   Getting A Raise
   Exercise: Negotiation Master
   Section Summary
   Become an Alumni
   Thank You.
   What You Can Do Now
   Coding Problems
   Top Interview Questions
   Amazon Interview Questions
   Facebook Interview Questions
   Google Interview Questions
   Domain Specific Questions

Contributing To Open Source To Gain Experience
   How To Succeed In This Course
   Join Our Online Classroom!
   Exercise: Meet The Community!
   Section Overview
   Resume
   Exercise: Resume Walkthrough
   Resume Review
   Resources: Resume Templates
   What If I Don't Have Enough Experience?
   Optional Exercise: Github Master
   LinkedIn
   Optional Exercise: LinkedIn Endorsements
   Portfolio
   Resources: Free Portfolio Templates
   Email
   Resources: Email
   Where To Find Jobs?
   Resources: Where To Find Jobs?
   When Should You Start Applying?
   Section Summary
   Setting Up Your Environment
   Section Overview
   What Is Good Code?
   Big O and Scalability
   O(n)
   O(1)
   Exercise: Big O Calculation
   Solution: Big O Calculation
   Exercise: Big O Calculation 2
   Solution: Big O Calculation 2
   Simplifying Big O
   Big O Rule 1
   Big O Rule 2
   Big O Rule 3
   O(n^2)
   Big O Rule 4
   Big O Cheat Sheet
   What Does This All Mean?
   O(n!)
   3 Pillars Of Programming
   Space Complexity
   Exercise: Space Complexity
   Exercise: Twitter
   Optional: Javascript Loops
   Section Summary
   Section Overview
   What Are Companies Looking For?
   What We Need For Coding Interviews
   Exercise: Google Interview
   Exercise: Interview Question
   Exercise: Interview Question 2
   Review Google Interview
   Optional Exercise: Google Interview On Your Own
   Section Summary
   Section Overview
   What Is A Data Structure?
   How Computers Store Data
   Data Structures In Different Languages
   Operations On Data Structures
   Arrays Introduction
   Static vs Dynamic Arrays
   Quick Note: Upcoming Video
   Optional: Classes In Javascript
   Implementing An Array
   Strings and Arrays
   Exercise: Reverse A String
   Solution: Reverse A String
   Exercise: Merge Sorted Arrays
   Solution: Merge Sorted Arrays
   Interview Questions: Arrays
   Arrays Review
   Hash Tables Introduction
   Hash Function
   Hash Collisions
   Hash Tables In Different Languages
   Exercise: Implement A Hash Table
   Solution: Implement A Hash Table
   keys()
   Hash Tables VS Arrays
   Exercise: First Recurring Character
   Solution: First Recurring Character
   Hash Tables Review
   Linked Lists Introduction
   What Is A Linked List?
   Exercise: Why Linked Lists?
   Solution: Why Linked Lists?
   What Is A Pointer?
   Our First Linked List
   Solution: append()
   Solution: prepend()
   Node Class
   insert()
   Solution: insert()
   Solution: remove()
   Doubly Linked Lists
   Exercise: Doubly Linked Lists
   Solution: Doubly Linked Lists
   Singly VS Doubly Linked Lists
   Exercise: reverse()
   Solution: reverse()
   Linked Lists Review
   Stacks + Queues Introduction
   Stacks
   Queues
   Exercise: Stacks VS Queues
   Solution: Stacks VS Queues
   Quick Note: Upcoming Video
   Optional: How Javascript Works
   Exercise: Stack Implementation (Linked Lists)
   Solution: Stack Implementation (Linked Lists)
   Exercise: Stack Implementation (Array)
   Solution: Stack Implementation (Array)
   Exercise: Queue Implementation
   Solution: Queue Implementation
   Queues Using Stacks
   Stacks + Queues Review
   Trees Introduction
   Binary Trees
   O(log n)
   Correction: Binary Search Trees
   Binary Search Trees
   Balanced VS Unbalanced BST
   BST Pros and Cons
   Exercise: Binary Search Tree
   Solution: insert()
   Solution: lookup()
   Bonus Exercise: remove()
   Solution: remove()
   AVL Trees + Red Black Trees
   Resources: AVL Trees + Red Black Trees
   Binary Heaps
   Quick Note on Heaps
   Priority Queue
   Trie
   Tree Review
   Graphs Introduction
   Types Of Graphs
   Exercise: Guess The Graph
   Graph Data
   Exercise: Graph Implementation
   Solution: Graph Implementation
   Graphs Review
   Data Structures Review
   What Else Is Coming Up?
   Introduction to Algorithms
   Recursion Introduction
   Stack Overflow
   Anatomy Of Recursion
   Exercise: Factorial
   Solution: Factorial
   Exercise: Fibonacci
   Solution: Fibonacci
   Recursive VS Iterative
   When To Use Recursion
   Exercise: Reverse String With Recursion
   Recursion Review
   Sorting Introduction
   The Issue With sort()
   Sorting Algorithms
   Bubble Sort
   Exercise: Bubble Sort
   Solution: Bubble Sort
   Selection Sort
   Exercise: Selection Sort
   Solution: Selection Sort
   Dancing Algorithms
   Insertion Sort
   Exercise: Insertion Sort
   Solution: Insertion Sort
   Merge Sort and O(n log n)
   Exercise: Merge Sort
   Solution: Merge Sort
   Stable VS Unstable Algorithms
   Quick Sort
   Optional Exercise: Quick Sort
   Which Sort Is Best?
   Resources: Heap Sort
   Radix Sort + Counting Sort
   Resources: Radix Sort + Counting Sort
   Exercise: Sorting Interview
   Solution: Sorting Interview
   Sorting In Your Language
   Sorting Review
   Searching + Traversal Introduction
   Linear Search
   Binary Search
   Graph + Tree Traversals
   BFS Introduction
   DFS Introduction
   BFS vs DFS
   Resources: BFS vs DFS
   Exercise: BFS vs DFS
   Solution: BFS vs DFS
   breadthFirstSearch()
   breadthFirstSearchRecursive()
   PreOrder, InOrder, PostOrder
   depthFirstSearch()
   Optional Exercise: Validate A BST
   Graph Traversals
   BFS in Graphs
   DFS in Graphs
   Dijkstra + Bellman-Ford Algorithms
   Searching + Traversal Review
   Dynamic Programming Introduction
   Memoization 1
   Memoization 2
   Fibonacci and Dynamic Programming
   Dynamic Programming
   Implementing Dynamic Programming
   Interview Questions: Dynamic Programming
   Dynamic Programming Review
   Section Overview
   During The Interview
   Exercise: Hero Stories
   Tell Me About Yourself
   Exercise: Your Pitch
   Why Us?
   Tell Me About A Problem You Have Solved
   Exercise: Past Projects
   What Is Your Biggest Weakness
   Exercise: Your Biggest Weakness
   Any Questions For Us?
   Resources: Questions To Ask A Company
   Secret Weapon
   After The Interview
   Section Summary
   Section Overview
   Handling Rejection
   Negotiation 101
   Handling An Offer
   Handling Multiple Offers
   Getting A Raise
   Exercise: Negotiation Master
   Section Summary
   Become an Alumni
   Thank You.
   What You Can Do Now
   Coding Problems
   Top Interview Questions
   Amazon Interview Questions
   Facebook Interview Questions
   Google Interview Questions
   Domain Specific Questions
   Contributing To Open Source
   Contributing To Open Source 2
   Exercise: Contribute To Open Source

Bonus: Extra Bits
   How To Succeed In This Course
   Join Our Online Classroom!
   Exercise: Meet The Community!
   Section Overview
   Resume
   Exercise: Resume Walkthrough
   Resume Review
   Resources: Resume Templates
   What If I Don't Have Enough Experience?
   Optional Exercise: Github Master
   LinkedIn
   Optional Exercise: LinkedIn Endorsements
   Portfolio
   Resources: Free Portfolio Templates
   Email
   Resources: Email
   Where To Find Jobs?
   Resources: Where To Find Jobs?
   When Should You Start Applying?
   Section Summary
   Setting Up Your Environment
   Section Overview
   What Is Good Code?
   Big O and Scalability
   O(n)
   O(1)
   Exercise: Big O Calculation
   Solution: Big O Calculation
   Exercise: Big O Calculation 2
   Solution: Big O Calculation 2
   Simplifying Big O
   Big O Rule 1
   Big O Rule 2
   Big O Rule 3
   O(n^2)
   Big O Rule 4
   Big O Cheat Sheet
   What Does This All Mean?
   O(n!)
   3 Pillars Of Programming
   Space Complexity
   Exercise: Space Complexity
   Exercise: Twitter
   Optional: Javascript Loops
   Section Summary
   Section Overview
   What Are Companies Looking For?
   What We Need For Coding Interviews
   Exercise: Google Interview
   Exercise: Interview Question
   Exercise: Interview Question 2
   Review Google Interview
   Optional Exercise: Google Interview On Your Own
   Section Summary
   Section Overview
   What Is A Data Structure?
   How Computers Store Data
   Data Structures In Different Languages
   Operations On Data Structures
   Arrays Introduction
   Static vs Dynamic Arrays
   Quick Note: Upcoming Video
   Optional: Classes In Javascript
   Implementing An Array
   Strings and Arrays
   Exercise: Reverse A String
   Solution: Reverse A String
   Exercise: Merge Sorted Arrays
   Solution: Merge Sorted Arrays
   Interview Questions: Arrays
   Arrays Review
   Hash Tables Introduction
   Hash Function
   Hash Collisions
   Hash Tables In Different Languages
   Exercise: Implement A Hash Table
   Solution: Implement A Hash Table
   keys()
   Hash Tables VS Arrays
   Exercise: First Recurring Character
   Solution: First Recurring Character
   Hash Tables Review
   Linked Lists Introduction
   What Is A Linked List?
   Exercise: Why Linked Lists?
   Solution: Why Linked Lists?
   What Is A Pointer?
   Our First Linked List
   Solution: append()
   Solution: prepend()
   Node Class
   insert()
   Solution: insert()
   Solution: remove()
   Doubly Linked Lists
   Exercise: Doubly Linked Lists
   Solution: Doubly Linked Lists
   Singly VS Doubly Linked Lists
   Exercise: reverse()
   Solution: reverse()
   Linked Lists Review
   Stacks + Queues Introduction
   Stacks
   Queues
   Exercise: Stacks VS Queues
   Solution: Stacks VS Queues
   Quick Note: Upcoming Video
   Optional: How Javascript Works
   Exercise: Stack Implementation (Linked Lists)
   Solution: Stack Implementation (Linked Lists)
   Exercise: Stack Implementation (Array)
   Solution: Stack Implementation (Array)
   Exercise: Queue Implementation
   Solution: Queue Implementation
   Queues Using Stacks
   Stacks + Queues Review
   Trees Introduction
   Binary Trees
   O(log n)
   Correction: Binary Search Trees
   Binary Search Trees
   Balanced VS Unbalanced BST
   BST Pros and Cons
   Exercise: Binary Search Tree
   Solution: insert()
   Solution: lookup()
   Bonus Exercise: remove()
   Solution: remove()
   AVL Trees + Red Black Trees
   Resources: AVL Trees + Red Black Trees
   Binary Heaps
   Quick Note on Heaps
   Priority Queue
   Trie
   Tree Review
   Graphs Introduction
   Types Of Graphs
   Exercise: Guess The Graph
   Graph Data
   Exercise: Graph Implementation
   Solution: Graph Implementation
   Graphs Review
   Data Structures Review
   What Else Is Coming Up?
   Introduction to Algorithms
   Recursion Introduction
   Stack Overflow
   Anatomy Of Recursion
   Exercise: Factorial
   Solution: Factorial
   Exercise: Fibonacci
   Solution: Fibonacci
   Recursive VS Iterative
   When To Use Recursion
   Exercise: Reverse String With Recursion
   Recursion Review
   Sorting Introduction
   The Issue With sort()
   Sorting Algorithms
   Bubble Sort
   Exercise: Bubble Sort
   Solution: Bubble Sort
   Selection Sort
   Exercise: Selection Sort
   Solution: Selection Sort
   Dancing Algorithms
   Insertion Sort
   Exercise: Insertion Sort
   Solution: Insertion Sort
   Merge Sort and O(n log n)
   Exercise: Merge Sort
   Solution: Merge Sort
   Stable VS Unstable Algorithms
   Quick Sort
   Optional Exercise: Quick Sort
   Which Sort Is Best?
   Resources: Heap Sort
   Radix Sort + Counting Sort
   Resources: Radix Sort + Counting Sort
   Exercise: Sorting Interview
   Solution: Sorting Interview
   Sorting In Your Language
   Sorting Review
   Searching + Traversal Introduction
   Linear Search
   Binary Search
   Graph + Tree Traversals
   BFS Introduction
   DFS Introduction
   BFS vs DFS
   Resources: BFS vs DFS
   Exercise: BFS vs DFS
   Solution: BFS vs DFS
   breadthFirstSearch()
   breadthFirstSearchRecursive()
   PreOrder, InOrder, PostOrder
   depthFirstSearch()
   Optional Exercise: Validate A BST
   Graph Traversals
   BFS in Graphs
   DFS in Graphs
   Dijkstra + Bellman-Ford Algorithms
   Searching + Traversal Review
   Dynamic Programming Introduction
   Memoization 1
   Memoization 2
   Fibonacci and Dynamic Programming
   Dynamic Programming
   Implementing Dynamic Programming
   Interview Questions: Dynamic Programming
   Dynamic Programming Review
   Section Overview
   During The Interview
   Exercise: Hero Stories
   Tell Me About Yourself
   Exercise: Your Pitch
   Why Us?
   Tell Me About A Problem You Have Solved
   Exercise: Past Projects
   What Is Your Biggest Weakness
   Exercise: Your Biggest Weakness
   Any Questions For Us?
   Resources: Questions To Ask A Company
   Secret Weapon
   After The Interview
   Section Summary
   Section Overview
   Handling Rejection
   Negotiation 101
   Handling An Offer
   Handling Multiple Offers
   Getting A Raise
   Exercise: Negotiation Master
   Section Summary
   Become an Alumni
   Thank You.
   What You Can Do Now
   Coding Problems
   Top Interview Questions
   Amazon Interview Questions
   Facebook Interview Questions
   Google Interview Questions
   Domain Specific Questions
   Contributing To Open Source
   Contributing To Open Source 2
   Exercise: Contribute To Open Source
   Learning Guideline
   Quick Note: Upcoming Videos
   From JTS: Learn to Learn
   From JTS: Start With Why
   Coding Challenges
   How To Use Leetcode
   AMA - 100,000 Students!!

Extras
   How To Succeed In This Course
   Join Our Online Classroom!
   Exercise: Meet The Community!
   Section Overview
   Resume
   Exercise: Resume Walkthrough
   Resume Review
   Resources: Resume Templates
   What If I Don't Have Enough Experience?
   Optional Exercise: Github Master
   LinkedIn
   Optional Exercise: LinkedIn Endorsements
   Portfolio
   Resources: Free Portfolio Templates
   Email
   Resources: Email
   Where To Find Jobs?
   Resources: Where To Find Jobs?
   When Should You Start Applying?
   Section Summary
   Setting Up Your Environment
   Section Overview
   What Is Good Code?
   Big O and Scalability
   O(n)
   O(1)
   Exercise: Big O Calculation
   Solution: Big O Calculation
   Exercise: Big O Calculation 2
   Solution: Big O Calculation 2
   Simplifying Big O
   Big O Rule 1
   Big O Rule 2
   Big O Rule 3
   O(n^2)
   Big O Rule 4
   Big O Cheat Sheet
   What Does This All Mean?
   O(n!)
   3 Pillars Of Programming
   Space Complexity
   Exercise: Space Complexity
   Exercise: Twitter
   Optional: Javascript Loops
   Section Summary
   Section Overview
   What Are Companies Looking For?
   What We Need For Coding Interviews
   Exercise: Google Interview
   Exercise: Interview Question
   Exercise: Interview Question 2
   Review Google Interview
   Optional Exercise: Google Interview On Your Own
   Section Summary
   Section Overview
   What Is A Data Structure?
   How Computers Store Data
   Data Structures In Different Languages
   Operations On Data Structures
   Arrays Introduction
   Static vs Dynamic Arrays
   Quick Note: Upcoming Video
   Optional: Classes In Javascript
   Implementing An Array
   Strings and Arrays
   Exercise: Reverse A String
   Solution: Reverse A String
   Exercise: Merge Sorted Arrays
   Solution: Merge Sorted Arrays
   Interview Questions: Arrays
   Arrays Review
   Hash Tables Introduction
   Hash Function
   Hash Collisions
   Hash Tables In Different Languages
   Exercise: Implement A Hash Table
   Solution: Implement A Hash Table
   keys()
   Hash Tables VS Arrays
   Exercise: First Recurring Character
   Solution: First Recurring Character
   Hash Tables Review
   Linked Lists Introduction
   What Is A Linked List?
   Exercise: Why Linked Lists?
   Solution: Why Linked Lists?
   What Is A Pointer?
   Our First Linked List
   Solution: append()
   Solution: prepend()
   Node Class
   insert()
   Solution: insert()
   Solution: remove()
   Doubly Linked Lists
   Exercise: Doubly Linked Lists
   Solution: Doubly Linked Lists
   Singly VS Doubly Linked Lists
   Exercise: reverse()
   Solution: reverse()
   Linked Lists Review
   Stacks + Queues Introduction
   Stacks
   Queues
   Exercise: Stacks VS Queues
   Solution: Stacks VS Queues
   Quick Note: Upcoming Video
   Optional: How Javascript Works
   Exercise: Stack Implementation (Linked Lists)
   Solution: Stack Implementation (Linked Lists)
   Exercise: Stack Implementation (Array)
   Solution: Stack Implementation (Array)
   Exercise: Queue Implementation
   Solution: Queue Implementation
   Queues Using Stacks
   Stacks + Queues Review
   Trees Introduction
   Binary Trees
   O(log n)
   Correction: Binary Search Trees
   Binary Search Trees
   Balanced VS Unbalanced BST
   BST Pros and Cons
   Exercise: Binary Search Tree
   Solution: insert()
   Solution: lookup()
   Bonus Exercise: remove()
   Solution: remove()
   AVL Trees + Red Black Trees
   Resources: AVL Trees + Red Black Trees
   Binary Heaps
   Quick Note on Heaps
   Priority Queue
   Trie
   Tree Review
   Graphs Introduction
   Types Of Graphs
   Exercise: Guess The Graph
   Graph Data
   Exercise: Graph Implementation
   Solution: Graph Implementation
   Graphs Review
   Data Structures Review
   What Else Is Coming Up?
   Introduction to Algorithms
   Recursion Introduction
   Stack Overflow
   Anatomy Of Recursion
   Exercise: Factorial
   Solution: Factorial
   Exercise: Fibonacci
   Solution: Fibonacci
   Recursive VS Iterative
   When To Use Recursion
   Exercise: Reverse String With Recursion
   Recursion Review
   Sorting Introduction
   The Issue With sort()
   Sorting Algorithms
   Bubble Sort
   Exercise: Bubble Sort
   Solution: Bubble Sort
   Selection Sort
   Exercise: Selection Sort
   Solution: Selection Sort
   Dancing Algorithms
   Insertion Sort
   Exercise: Insertion Sort
   Solution: Insertion Sort
   Merge Sort and O(n log n)
   Exercise: Merge Sort
   Solution: Merge Sort
   Stable VS Unstable Algorithms
   Quick Sort
   Optional Exercise: Quick Sort
   Which Sort Is Best?
   Resources: Heap Sort
   Radix Sort + Counting Sort
   Resources: Radix Sort + Counting Sort
   Exercise: Sorting Interview
   Solution: Sorting Interview
   Sorting In Your Language
   Sorting Review
   Searching + Traversal Introduction
   Linear Search
   Binary Search
   Graph + Tree Traversals
   BFS Introduction
   DFS Introduction
   BFS vs DFS
   Resources: BFS vs DFS
   Exercise: BFS vs DFS
   Solution: BFS vs DFS
   breadthFirstSearch()
   breadthFirstSearchRecursive()
   PreOrder, InOrder, PostOrder
   depthFirstSearch()
   Optional Exercise: Validate A BST
   Graph Traversals
   BFS in Graphs
   DFS in Graphs
   Dijkstra + Bellman-Ford Algorithms
   Searching + Traversal Review
   Dynamic Programming Introduction
   Memoization 1
   Memoization 2
   Fibonacci and Dynamic Programming
   Dynamic Programming
   Implementing Dynamic Programming
   Interview Questions: Dynamic Programming
   Dynamic Programming Review
   Section Overview
   During The Interview
   Exercise: Hero Stories
   Tell Me About Yourself
   Exercise: Your Pitch
   Why Us?
   Tell Me About A Problem You Have Solved
   Exercise: Past Projects
   What Is Your Biggest Weakness
   Exercise: Your Biggest Weakness
   Any Questions For Us?
   Resources: Questions To Ask A Company
   Secret Weapon
   After The Interview
   Section Summary
   Section Overview
   Handling Rejection
   Negotiation 101
   Handling An Offer
   Handling Multiple Offers
   Getting A Raise
   Exercise: Negotiation Master
   Section Summary
   Become an Alumni
   Thank You.
   What You Can Do Now
   Coding Problems
   Top Interview Questions
   Amazon Interview Questions
   Facebook Interview Questions
   Google Interview Questions
   Domain Specific Questions
   Contributing To Open Source
   Contributing To Open Source 2
   Exercise: Contribute To Open Source
   Learning Guideline
   Quick Note: Upcoming Videos
   From JTS: Learn to Learn
   From JTS: Start With Why
   Coding Challenges
   How To Use Leetcode
   AMA - 100,000 Students!!
   Bonus: Special Thank You Gift!


Sponsored High Speed Downloads
8145 dl's @ 3442 KB/s
Download Now [Full Version]
9950 dl's @ 3654 KB/s
Download Link 1 - Fast Download
5993 dl's @ 2071 KB/s
Download Mirror - Direct Download



Search More...
Udemy - Master the Coding Interview; Data Structures Algorithms #Last updated 12-2019

Search free ebooks in ebookee.com!


Links
Download this book

No active download links here?
Please check the description for download links if any or do a search to find alternative books.


Related Books

  1. Ebooks list page : 42160
  2. 2020-02-02Master the Coding Interview Data Structures Algorithms
  3. 2019-03-25Master the Coding Interview Data Structures Algorithms
  4. 2018-12-17Master the Coding Interview Data Structures Algorithms
  5. 2019-12-23Udemy - Master your brain; Neuroscience for personal development [Last updated 10-2019]
  6. 2019-03-16SKILLSHARE MASTER THE CODING INTERVIEW ALGORITHMS PLUS DATA STRUCTURES-iLLiTERATE
  7. 2019-04-08The Coding Interview Bootcamp Вђ Algorithms Data Structures
  8. 2019-12-28Udemy - JavaScript Algorithms and Data Structures Masterclass [Last updated 11-2018]
  9. 2019-08-24Udemy - From 0 to 1: Data Structures & Algorithms in Java
  10. 2019-12-25Udemy - The Complete Foundation Stock Trading Course [Last updated 2-2019]
  11. 2019-12-27Udemy - Introduction to Computer Networks for Non-Techies [Last updated 4-2019]
  12. 2019-12-25Udemy - Online Japanese N5 Course(All 15 lessons) [Last updated 2-2019]
  13. 2019-12-23Udemy - Apache Kafka Series – Kafka Cluster Setup & Administration [Last updated 5-2019]
  14. 2019-12-22Udemy - Learn Website Hacking Penetration Testing From Scratch [Last updated 1-2019]
  15. 2007-11-03Algorithms and Data Structures: The Science of Computing - Removed
  16. 2018-06-09Udemy - The Coding Interview Bootcamp Algorithms Data Structures
  17. 2018-06-09The Coding Interview Bootcamp Algorithms Data Structures [Udemy] (2017)
  18. 2018-03-11Udemy - The Coding Interview Bootcamp Algorithms Data Structures
  19. 2019-04-02Data Structures Algorithms Master Coding Interview QA
  20. 2019-01-15Data Structures Algorithms Master Coding Interview QA

Comments

No comments for "Udemy - Master the Coding Interview; Data Structures Algorithms #Last updated 12-2019".


    Add Your Comments
    1. Download links and password may be in the description section, read description carefully!
    2. Do a search to find mirrors if no download links or dead links.
    Back to Top