Data Structures and Algorithms | Coding Interview Q&A

Course Curriculum

Chapter 1: Introduction

Lecture 1: Don't skip this! – Frequently Asked Questions & Answers of this Course

Chapter 2: Time Complexity & Space Complexity – How to know the time of an algorithm?

Lecture 1: Overview – What are we gonna cover about Time Complexity & Space Complexity?

Lecture 2: Introduction – Why are these concepts so important?

Lecture 3: What is Big O? + O(1) Algorithms – Constant Time

Lecture 4: O(N) Algorithms – Example #1 – Linear Time

Lecture 5: O(N) Algorithms – Example #2

Lecture 6: O(N+M) Algorithms

Lecture 7: O(N*M / N²) Algorithms

Lecture 8: O(N² + N)? => O(N²) Algorithms

Lecture 9: O(N³) Algorithms

Lecture 10: O(logN) Algorithms

Lecture 11: Big Omega

Lecture 12: Big Theta

Lecture 13: Space Complexity – Part #1

Lecture 14: Space Complexity – Part #2

Lecture 15: Coding Interview Question & Answer – Part I

Lecture 16: Coding Interview Question & Answer – Part II

Lecture 17: Conclusion

Chapter 3: [OPTIONAL] Installing Eclipse

Lecture 1: Why Eclipse? Is it necessary?

Lecture 2: Eclipse Installation in Windows

Lecture 3: Eclipse installation in Linux

Lecture 4: Eclipse installation in Mac

Lecture 5: How to import the Downloadable Code examples in Eclipse

Chapter 4: [OPTIONAL] Basics about Java Syntax

Lecture 1: Introduction to Basics about Java Syntax section

Lecture 2: How to read the variables declaration in Java

Lecture 3: How to read a declaration of a method in Java

Lecture 4: Type Object & Type T (Generic Type)

Lecture 5: Two+ Methods with the same name

Chapter 5: Recursion

Lecture 1: Overview – Recursion

Lecture 2: Why is Recursion important? Why is it useful?

Lecture 3: Concept – Part #1

Lecture 4: [Downloadable Code] recursive example

Lecture 5: [OPTIONAL] Concept – Part #2

Lecture 6: Concept – Part #3

Lecture 7: [Downloadable Code] Sleep / Tell a Story Example

Lecture 8: Multiplication – Easy Example – Part #1

Lecture 9: Multiplication – Easy Example – Part #2

Lecture 10: Simple Example: Factorial

Lecture 11: How Recursion impacts Memory?

Lecture 12: Recursive Solutions vs Iterative Solutions

Lecture 13: Conclusion

Chapter 6: Arrays & Strings

Lecture 1: Overview – Arrays & Strings

Lecture 2: Introduction

Lecture 3: Linear Search / Sequential Search

Lecture 4: Linear Search – Implementation

Lecture 5: [Downloadable Code] LinearSearch Implementation

Lecture 6: Binary Search / Dichotomous Search

Lecture 7: Binary Search – Implementation – Part #1

Lecture 8: Binary Search – Implementation – Part #2

Lecture 9: [Downloadable Code] Binary Search Implementation

Lecture 10: Mutable vs Immutable

Lecture 11: Two dimensional arrays (Matrix)

Lecture 12: Coding Interview Question – Permutation Problem

Lecture 13: Coding Interview Answer – Permutation Problem – Solution #1

Lecture 14: Coding Interview Answer – Permutation Problem – Solution #1 – TEST

Lecture 15: [Downloadable Code] Coding Interview Answer – Permutation Problem – Solution #1

Lecture 16: Coding Interview Answer – Permutation Problem – CONCEPTS for Solution #2

Lecture 17: Coding Interview Answer – Permutation Problem – Solution #2 – PART ONE

Lecture 18: Coding Interview Answer – Permutation Problem – Solution #2 – TEST & BUG FIXES!

Lecture 19: Coding Interview Answer – Permutation – Solution #2 – Space & Space Complexity

Lecture 20: Coding Interview Answer – Permutation Problem – Solution #2 – FINAL IMPROVEMENT

Lecture 21: [Downloadable Code] Coding Interview Answer – Permutation Problem – Solution #2

Chapter 7: Linked List

Lecture 1: Overview – Linked List

Lecture 2: Introduction – Internal Structure of a Linked List

Lecture 3: How Linked Lists are stored in memory (RAM)

Lecture 4: Linked Lists vs Arrays

Lecture 5: Types of Linked Lists

Lecture 6: Basic Structure of Linked List – Implementation

Lecture 7: Searching in a Linked List – Theory

Lecture 8: Searching in a Linked List – Implementation

Lecture 9: [OPTIONAL] Searching in a Linked List – Testing the implementation

Lecture 10: Inserting at the beginning of a Linked Link

Lecture 11: Inserting at the beginning of a Linked Link – Implementation

Lecture 12: Methods get() & printElements() in a Linked List – Implementation

Lecture 13: [OPTIONAL] Inserting at the beginning of a Linked Link – Implementation (TEST)

Lecture 14: Inserting at the end of a Linked List with a Tail pointer

Lecture 15: Inserting at the end of a Linked List without a Tail pointer

Lecture 16: Inserting at the end of a Linked List without a Tail pointer – Implementation

Lecture 17: [OPTIONAL] Inserting at the end of a Linked List – TEST of the implementation

Lecture 18: Inserting in the middle of a Linked List

Lecture 19: Inserting in the middle of a Linked List – Implementation

Lecture 20: [OPTIONAL] Inserting in the middle of a Linked List – TEST Implementation

Lecture 21: Removing the first element of a Linked List

Lecture 22: Removing the first element of a Linked List – Implementation

Lecture 23: [OPTIONAL] Removing the first element of a Linked List – TEST Implementation

Lecture 24: Removing the last element of a Linked List

Lecture 25: Removing the last element of a Linked List – Implementation

Lecture 26: [OPTIONAL] Removing the last element of a Linked List – TEST Implementation

Lecture 27: Removing in the middle of a Linked List

Lecture 28: Removing in the middle of a Linked List – Implementation

Lecture 29: [OPTIONAL] Removing in the middle of a Linked List – TEST Implementation

Lecture 30: [Downloadable Code] Linked List Implementation