Data Structures and Algorithms | Coding Interview Q&A

Learn Data Structures & Algorithms from Scratch. + Master Coding Interviews . From basic to advanced.

3.15 (167 reviews)
Udemy
platform
English
language
Software Engineering
category
instructor
Data Structures and Algorithms | Coding Interview Q&A
9,743
students
12.5 hours
content
Feb 2019
last update
$19.99
regular price

What you will learn

Master any coding interview in the largest tech companies in the world

Have an excellent understanding of how each Data Structure works and how to get the best out of them.

Know how to create by yourself the most efficient algorithms that can exist for any problem

Feel completely confident when talking about complex DS & Algorithms and how they work

Know how to implement each Data Structure from scratch.

Downloadable code of ALL the examples covered in this course

Why take this course?

  • Want to Master a Coding Interview in one of the largest technology companies in the world?

  • Want to go from Zero to Expert in Data Structures & Algorithms?

  • Want to know how to approach every coding problem and get the best solution?

Most of the world's leading technology companies have a similar interview process. The key part of them is the coding interview, and the only way to ace it is having the correct knowledge about Data Structures and how to code not just to solve a problem, but also coding the most efficient solution. In this course you will learn all this content from scratch!


This course starts from scratch, you don't need to know anything about this amazing topic!

Most of the developers struggle a lot when they have to work with Data Structures and really efficient Algorithms. That's why we created this complete course about it.

Buy once, get this incredible knowledge forever!


We're gonna go from the very basic Data Structures like Arrays, Linked Lists, Stacks and Queues to the advanced ones like Hashing, Trees, Graphs and brilliant techniques that are used by the best developers in the world like Dynamic Programming and the Divide & Conquer Paradigm.

This is the course I wanted to have available when I learned this topic. Now it's yours for a few dollars!

Note: The coding examples of this course are coded using Java. However, each example is explained line by line and knowing just the basics of any programming language is enough. If you have never coded in Java, there's a section with some examples to understand the syntax, so you'll be absolutely fine!


Join the most comprehensive course about Data Structures & Algorithms on Udemy!




Content

Introduction

Don't skip this! - Frequently Asked Questions & Answers of this Course

Time Complexity & Space Complexity - How to know the time of an algorithm?

Overview - What are we gonna cover about Time Complexity & Space Complexity?
Introduction - Why are these concepts so important?
What is Big O? + O(1) Algorithms - Constant Time
O(N) Algorithms - Example #1 - Linear Time
O(N) Algorithms - Example #2
O(N+M) Algorithms
O(N*M / N²) Algorithms
O(N² + N)? => O(N²) Algorithms
O(N³) Algorithms
O(logN) Algorithms
Big Omega
Big Theta
Space Complexity - Part #1
Space Complexity - Part #2
Coding Interview Question & Answer - Part I
Coding Interview Question & Answer - Part II
Conclusion
Quiz - What's the Big O of this algorithm?

[OPTIONAL] Installing Eclipse

Why Eclipse? Is it necessary?
Eclipse Installation in Windows
Eclipse installation in Linux
Eclipse installation in Mac
How to import the Downloadable Code examples in Eclipse

[OPTIONAL] Basics about Java Syntax

Introduction to Basics about Java Syntax section
How to read the variables declaration in Java
How to read a declaration of a method in Java
Type Object & Type T (Generic Type)
Two+ Methods with the same name

Recursion

Overview - Recursion
Why is Recursion important? Why is it useful?
Concept - Part #1
[Downloadable Code] recursive example
[OPTIONAL] Concept - Part #2
Concept - Part #3
[Downloadable Code] Sleep / Tell a Story Example
Multiplication - Easy Example - Part #1
Multiplication - Easy Example - Part #2
Simple Example: Factorial
How Recursion impacts Memory?
Recursive Solutions vs Iterative Solutions
Conclusion

Arrays & Strings

Overview - Arrays & Strings
Introduction
Linear Search / Sequential Search
Linear Search - Implementation
[Downloadable Code] LinearSearch Implementation
Binary Search / Dichotomous Search
Binary Search - Implementation - Part #1
Binary Search - Implementation - Part #2
[Downloadable Code] Binary Search Implementation
Mutable vs Immutable
Two dimensional arrays (Matrix)
Coding Interview Question - Permutation Problem
Coding Interview Answer - Permutation Problem - Solution #1
Coding Interview Answer - Permutation Problem - Solution #1 - TEST
[Downloadable Code] Coding Interview Answer - Permutation Problem - Solution #1
Coding Interview Answer - Permutation Problem - CONCEPTS for Solution #2
Coding Interview Answer - Permutation Problem - Solution #2 - PART ONE
Coding Interview Answer - Permutation Problem - Solution #2 - TEST & BUG FIXES!
Coding Interview Answer - Permutation - Solution #2 - Space & Space Complexity
Coding Interview Answer - Permutation Problem - Solution #2 - FINAL IMPROVEMENT
[Downloadable Code] Coding Interview Answer - Permutation Problem - Solution #2

Linked List

Overview - Linked List
Introduction - Internal Structure of a Linked List
How Linked Lists are stored in memory (RAM)
Linked Lists vs Arrays
Types of Linked Lists
Basic Structure of Linked List - Implementation
Searching in a Linked List - Theory
Searching in a Linked List - Implementation
[OPTIONAL] Searching in a Linked List - Testing the implementation
Inserting at the beginning of a Linked Link
Inserting at the beginning of a Linked Link - Implementation
Methods get() & printElements() in a Linked List - Implementation
[OPTIONAL] Inserting at the beginning of a Linked Link - Implementation (TEST)
Inserting at the end of a Linked List with a Tail pointer
Inserting at the end of a Linked List without a Tail pointer
Inserting at the end of a Linked List without a Tail pointer - Implementation
[OPTIONAL] Inserting at the end of a Linked List - TEST of the implementation
Inserting in the middle of a Linked List
Inserting in the middle of a Linked List - Implementation
[OPTIONAL] Inserting in the middle of a Linked List - TEST Implementation
Removing the first element of a Linked List
Removing the first element of a Linked List - Implementation
[OPTIONAL] Removing the first element of a Linked List - TEST Implementation
Removing the last element of a Linked List
Removing the last element of a Linked List - Implementation
[OPTIONAL] Removing the last element of a Linked List - TEST Implementation
Removing in the middle of a Linked List
Removing in the middle of a Linked List - Implementation
[OPTIONAL] Removing in the middle of a Linked List - TEST Implementation
[Downloadable Code] Linked List Implementation

ArrayList

What is an ArrayList?
How it works internally?
Most common operations

Stacks

Introduction to Stacks
Operations
How to implement an Stack from scratch? - Part #1
How to implement an Stack from scratch? - Part #2
How to use Stacks in Java
[Downloadable Code] Stack Implementation

Queues

Introduction to Queues
Operations
How to implement a Queue from scratch - Part #1
How to implement a Queue from scratch - Part #2
How to use Queues in Java
[Downloadable Code] Queue Implementation

Hashing & HashTables

Dictionary Example
Overview - Hashing & HashTables
Introduction
HashMap vs HashTable in Java - Part #1
HashMap vs HashTable in Java - Part #2
HashMap Operations
[OPTIONAL] HashTable/HashMap equivalent in Python, Javascript and Ruby
[OPTIONAL] HashTable/HashMap equivalent in C++
HashTables vs Arrays
How a Hash Table works internally? - Part #1
How a Hash Table works internally? - Part #2
How a Hash Table works internally? - Part #3
What is a Hash Function? How it works?
Collisions and how are they handled internally - Separate Chaining - Part #1
Collisions and how are they handled internally - Separate Chaining - Part #2
LinkedHashMap
TreeMap
HashSet (Not a Hash Table!)
HashTable Time Complexity & Space Complexity

Screenshots

Data Structures and Algorithms | Coding Interview Q&A - Screenshot_01Data Structures and Algorithms | Coding Interview Q&A - Screenshot_02Data Structures and Algorithms | Coding Interview Q&A - Screenshot_03Data Structures and Algorithms | Coding Interview Q&A - Screenshot_04

Our review

--- **Overall Course Rating:** 3.15 ### Course Review #### Pros: - **Solid Content**: The course provides solid content with explanations and implementations, catering to a variety of learning styles as seen in the review from a learner who appreciated the availability of implementation details without extensive explanation. (Review #2) - **Structured and Clear**: The course structure is well-organized and appears to be easy to follow and understand. This is confirmed by a recent reviewer who found the course solid and well-structured upon starting it. (Review #3) - **Inclusivity for Non-native Speakers**: Subtitles are available for those who may struggle with the accent, making the course more accessible to a wider audience. (Review #4) - **Thought-Provoking Approach**: The instructor encourages learners to think deeply about concepts and relate them to languages they are familiar with, which is particularly appreciated by someone coming from a Python and JavaScript background. (Review #5) - **Enhanced Understanding**: Several learners have reported gaining new insights and improved understanding of data structures and algorithms, as well as when and how to apply recursive functions. (Reviews #6 & 8) #### Cons: - **Pacing Issues**: There are concerns about the timing of voice and slides, with some learners feeling that the pace at which new topics are introduced is off, leading to a disjointed learning experience. (Review #7) - **Accent and Volume Concerns**: A few learners have mentioned difficulties with understanding due to the instructor's accent and volume of voice, which can be a barrier to comprehension. (Reviews #2 & 9) - **Script Feels Like a Work in Progress**: The script appears to be under development, suggesting that it may need further refinement and editing for clarity and coherence. (Review #7) - **Technical Issues with Synchronization**: The synchronization between voice and slides needs improvement; topics sometimes start before the previous discussion concludes, or vice versa. (Review #7) - **Desire for More Visuals**: Some learners would appreciate seeing both the instructor and their screen simultaneously to enhance the learning experience. (Review #7) - **Clarification Needed**: There is a request for more concrete examples to clarify concepts, particularly regarding Big O notation calculations and how they apply to different numerical values. (Review #4) - **Additional Resources Suggested**: Learners have suggested adding resources, such as a Big-O Cheat Sheet or comparison graphs, to each section for further learning and reference. (Review #4) In summary, the course is well-received for its educational content, clear structure, and ability to enhance understanding of complex concepts. However, it faces challenges with pacing, audio clarity, and technical synchronization. These issues, along with a few other suggestions, provide opportunities for improvement. With adjustments in these areas, the course could offer an even more enriching experience for learners of all backgrounds.

Charts

Price

Data Structures and Algorithms | Coding Interview Q&A - Price chart

Rating

Data Structures and Algorithms | Coding Interview Q&A - Ratings chart

Enrollment distribution

Data Structures and Algorithms | Coding Interview Q&A - Distribution chart
2052993
udemy ID
11/27/2018
course created date
6/17/2019
course indexed date
Bot
course submited by