Teach on Udemy

Turn what you know into an opportunity and reach millions around the world.

Learn More

Your cart is empty.

Keep shopping

The Complete Data Structures and Algorithms Course in Python

Name: The Complete Data Structures and Algorithms Course in Python
Rating: 4.5 (11372 reviews)

100+ DSA Interview Questions for Cracking FAANG with Animated Examples for Deeper Understanding and Faster Learning

Bestseller

Highest Rated

Created byElshad Karimov

Last updated 7/2025

English

What you'll learn

Learn, implement, and use different Data Structures
Learn, implement and use different Algorithms
Become a better developer by mastering computer science fundamentals
Learn everything you need to ace difficult coding interviews
Cracking the Coding Interview with 100+ questions with explanations
Time and Space Complexity of Data Structures and Algorithms
Recursion
Big O

Coding Exercises

This course includes our updated coding exercises so you can practice your skills as you learn.

Course content

53 sections • 553 lectures • 46h 31m total length

Curriculum Walkthrough8:31
Explore a comprehensive curriculum from basics to advanced data structures and algorithms in Python, including recursion, Big O, arrays, lists, dictionaries, tuples, trees, graphs, and dynamic programming with coding exercises.
What is a Data Structure?2:53
Explore what a data structure is and why organizing data matters for efficiency. Learn how data organization and storage affect software performance and selection for use cases.
Getting the Most Out of This Course4:27
Join a supportive learning community for self-learners that keeps you motivated and connected via discord and website channels, connect with a learning buddy, explore course channels, and set goals.
What is an algorithm?3:49
Learn what an algorithm is: a set of steps to perform a task, illustrated with everyday tasks and computing examples, and the criteria for a correct, efficient solution.
Why are Data Structures and Algorithms important?3:45
Explore why data structures and algorithms matter for efficient data processing and problem solving, with real-world examples like Google Maps and interview-focused performance considerations.
Types of Data Structures4:24
Explore primitive and non-primitive data structures in Python, including linear and non-linear types, built-in and user-defined options, with examples like lists, dictionaries, sets, and graphs.
Types of Algorithms2:09
Explore common types of algorithms in Python, including sorting, searching, graph, dynamic programming, divide and conquer, and recursive approaches, with examples like bubble sort, DFS, and mergesort.
Python Programming For Everyone0:43
Discover python for everyone, a nine-part course starting from zero that covers all python concepts for beginners and advanced developers, with a resource link to minimum price for current students.
Introduction to DS and Algorithms
Student Community0:07
Lecture Notes0:10
Code Editor3:25
Set up your coding environment to match the course, using VS Code or your preferred editor. Install the Python extension, open a project folder, and run a hello world test.

What is Big O?5:41
Explore what big o means, measure time and space complexity to compare algorithms, and learn to evaluate code efficiency with examples of time complexity and o-notation.
Big O Notations - Theta , Omega and Big O4:51
Define and compare big O, omega, and theta notations for algorithm performance, illustrating best, worst, and average cases with intuitive examples and industry usage.
Big O - O(1)2:44
Explore constant time complexity (O(1)) and the idea of order one, where operations stay constant regardless of input, with examples like multiplying numbers and removing a card from a deck.
Big O - O(N)2:51
Explore linear time complexity, or O(n), and how a function's run time grows with input size. Learn with simple loops, practical examples, and deck-of-cards analogies to visualize O(n).
Drop Constants4:06
Learn how to drop constants in big O analysis, simplifying O(2n) to O(n) and focusing on the rate of increase while ignoring hardware-specific factors.
Big O - O(n^2)4:15
Demonstrate O(n^2) time complexity with nested loops and a deck of cards example, then show how adding a third loop yields O(n^3) time growth.
Drop Non Dominant Terms2:55
Learn how to simplify Big O by dropping non-dominant terms, using a nested loop versus a separate loop to reveal dominant O(n^2) terms in time complexity.
Big O - O(logN)5:37
Discover how to locate a number in a sorted array using divide and conquer to achieve O(log n) time by halving the search space each step.
Space Complexity6:58
Explore space complexity, measuring an algorithm’s memory use and how it grows with input size. See how recursion stacks produce O(n) space, while certain loops stay at O(1) in memory.
Different Terms for Input - Add vs Multiply3:56
Explore how input terms influence time complexity by examining non-nested and nested loops, using a and b to illustrate big O and dropping constants, yielding O(a)+O(b) or O(a*b).
How to measure the codes using Big O?5:51
Analyze code complexity with Big O by applying rules for constant, linear, quadratic, and logarithmic time, and sum complexities to find the dominant term, illustrated by a Python max-in-array example.
Time Complexities
Download the Resources0:09
Feedback Time0:12

What is an Array?4:45
Explore how Python uses lists as flexible analogs to arrays and how NumPy and the array module provide memory-efficient, contiguous storage for numeric data of a single type.
Types of Array8:06
Explore one dimensional, two dimensional, and three dimensional arrays, learn how to access elements with a[i] and a[0][4], and understand why multidimensional arrays are useful.
Arrays in Memory7:09
Explore how one-, two-, and three-dimensional arrays are stored contiguously in RAM, with the compiler allocating contiguous cells and mapping multi-dimensional arrays to a single memory row.
Create an Array8:14
Learn to create Python arrays using the built-in array module and NumPy. Create empty arrays and arrays with elements, and analyze time and space complexity.
Insertion to Array4:44
Insert elements into an array at the beginning, middle, or end; have elements shift accordingly and note worst-case time complexity O(n) with space complexity O(1) using the array insert method.
Traversal Operation3:57
Learn how to traverse an array by looping through each element and printing them, demonstrated in a traverseArray function, and analyze its time complexity O(N) and space O(1).
Accessing an element of Array8:46
Access an array element by index in Python, starting at zero, with out-of-range error handling in a Visual Studio Code workflow, and evaluate constant time and space complexity.
Searching for an element in Array5:14
Learn how linear search scans an array by iterating elements, comparing each to the target, and returns the index or -1 if not found, with Python example and complexity notes.
Deleting an element from Array3:52
Delete an element from an array while preserving contiguous memory and fast index access by shifting subsequent elements, and learn that last-element deletion is O(1) while middle deletions are O(N).
Time and Space Complexity of One Dimensional Array2:52
Explore the time and space complexity of one dimensional arrays in Python and NumPy. Learn how creating, inserting, traversing, accessing, searching, and deleting affect O(1) or O(n) time and space.
One Dimensional Array Practice27:09
Explore one dimensional arrays in Python through a hands-on practice of 16 operations, including creation, traversal, indexing, insertion, extension, removal, and slicing.
Create Two Dimensional Array7:12
Identify two dimensional arrays as grids of rows and columns built from one dimensional arrays, using numpy in Python to model matrices and access values with two brackets.
Insertion - Two Dimensional Array9:09
Learn how to insert columns or rows into a two-dimensional array, using NumPy insert or append, and understand time complexity o(mn) for shifting rows or columns in a matrix.
Accessing an element of Two Dimensional Array8:47
Learn to access an element in a two dimensional array using row and column indices. See Python examples and bounds checks to prevent errors; runs in constant time and space.
Traversal - Two Dimensional Array7:30
Traverse a two dimensional array by visiting cells row by row using nested loops, printing each value, and analyze time complexity MN (or quadratic if square) and space complexity O(1).
Searching for an element in Two Dimensional Array8:51
Search a value in a two dimensional array with linear search, locating the first occurrence and reporting its row and column indices, while discussing time and space complexity.
Deletion - Two Dimensional Array4:58
Deletion in a two dimensional numpy array creates a new array, copies data without the deleted row or column, and uses an axis parameter; time is O(mn), space O(n).
Time and Space Complexity of 2D Array4:03
Explore the time and space complexity of common two dimensional array operations, including creating empty arrays, initializing with values, inserting rows or columns, traversing, accessing, searching, and deleting elements.
When to use/avoid array3:09
Discover when to use arrays to store many variables of the same type and access elements in constant time, and when to avoid them for mixed types and resizing costs.
Download the Resources0:09
Feedback Time0:12

What is a List? How to create it?6:07
Explore Python lists, a built-in, ordered data structure that stores items of mixed types, including nested lists, with square brackets and commas for creation in Visual Studio Code.
Accessing/Traversing a list10:11
Access and traverse a Python list by zero-based index (including negative indices) and the in operator, and update elements using range and len, while noting out-of-range errors.
Update/Insert a List10:28
Update and insert elements in Python lists by indexing and assigning values, leveraging the list's ordered, mutable nature. Explore insertion methods—insert, append, and extend—alongside their time and space complexities.
Slice/Delete from a List9:10
Explore list slicing to select and update multiple elements, then compare deletion methods, pop, delete, and remove, and their time complexities, from O(1) to O(N), with space complexity O(2).
Searching for an element in a List7:21
Explore how to search for an element in a Python list using the in operator and linear search, compare time complexities, and note how sets and dictionaries enable faster lookups.
List Operations/Functions10:12
Learn Python list operations and functions, including + for concatenation and * for repetition, then use len, max, min, sum, and average with lists.
Lists and strings4:07
Learn to convert strings to lists and lists to strings in Python using the list and join functions, and split with delimiters to handle words.
Common List pitfalls and ways to avoid them4:38
Master common list pitfalls in Python by recognizing that many list methods modify the original and return none; compare append and concatenate, avoid nested lists, and copy before sorting.
Lists vs Arrays3:54
Compare arrays and Python lists by highlighting mutability, indexing, iteration, and slicing, then show that arrays excel at arithmetic operations with homogeneous data types, as demonstrated with NumPy arrays.
Time and Space Complexity of List3:34
Explore the time and space complexity of list operations, from creating an empty list to inserting, traversing, accessing, searching, and deleting elements, with O(1) or O(n) costs.
List Comprehension7:03
Learn list comprehension in Python, a concise way to create a new list from the previous list. Replace for loops and apply to strings and other sequences for cleaner code.
Conditional List Comprehension8:38
Master conditional list comprehension in Python by filtering and transforming items with if conditions, including using else expressions and embedded functions.
List Interview Questions
Download the Resources0:09
Feedback Time0:12

Goals - what you will make by the end of this section2:34
Use an array or Python list to build a real life project that inputs daily temperatures, calculates the average, and identifies days above average in two steps.
Calculate Average Temperature5:08
Collect daily temperatures with Python input, convert to integers, sum them, and compute a rounded average. Learn how lists (arrays) store data to count days above the average.
Find the Days Above Average Temperature5:10
Explore using an array data structure or Python list to collect daily temperatures, compute the average, and count the days above that average.

Missing Number
Solution to Missing Number0:35
Missing Number Explanation4:23
Discover how to find the missing number in a one to one hundred array using the sum of series formula, implement a Python function findMissing, and verify with list sum.
Pairs / Two Sum - LeetCode 16:31
Demonstrate how to solve the two sum problem in Python by finding index pairs in an array that total a target, with distinct pairs and example runs for target nine.
LeetCode Solution1:20
Finding a number in an Array3:19
Learn to perform a linear search on a numpy array to find a number, using a loop and index checks, printing the element's index or nothing if absent.
Max Product of Two Integers
SOLUTION - Time and Space Complexity of Max Product of Two Integers1:52
Middle Function
SOLUTION - Time and Space Complexity of Middle Function0:54
2D Lists
SOLUTION - Time and Space Complexity of 2D Lists0:46
Best Score
SOLUTION - Time and Space Complexity of Best Score1:17
Duplicate Number
SOLUTION - Time and Space Complexity of Duplicate Number0:58
Pairs
SOLUTION - Time and Space Complexity of Pairs1:34
Contains Duplicate
SOLUTION - Time and Space Complexity of Contains Duplicate1:20
Permutation5:33
Determine if two lists are permutations by comparing lengths, sorting both lists, and checking for equality.
Rotate Matrix/ Image - LeetCode 48
SOLUTION - Time and Space Complexity of Rotate Matrix/Image0:56
Download the Resources0:09
Feedback Time0:12

Question 1 - Product and Sum3:03
Explore the runtime analysis of code that computes the sum and product of an array, using two linear-time loops, tied to interview questions from cracking the coding interview.
Question 2 - Print Pairs2:07
Explore a function with nested loops that prints all pairs from an array, illustrating how the number of pairs grows as O(n^2).
Question 3 - Print Unordered Pairs3:47
Analyze the runtime of a nested loop with the inner loop starting at i plus one, summing n minus one down to one, to reveal n squared time complexity.
Question 4 - Print Unordered Pairs 2 Arrays1:53
Analyze time complexity for two different arrays with nested loops, yielding a runtime of O(ab); clarify that this is not quadratic unless the loops use the same array.
Question 5 - Print Unordered Pairs 2 Arrays 100000 Units1:46
Analyze the runtime of a double loop over two arrays, A and B, with a constant 100000 inner loop, showing the total complexity remains O(ab) despite the fixed iteration.
Question 6 - Reverse2:42
Analyze how the reverse function takes an array, outputs it in reverse, and shows a linear runtime of O(N) with constant time steps.
Question 7 - O(N) Equivalents3:02
Identify true equivalents of O(N) by dropping non-dominant terms using the time complexity graph, and analyze examples with constants, log N, and N log N.
Download the Resources0:09
Feedback Time0:12

What is a Dictionary?4:07
Identify Python dictionaries as an unordered, changeable, and indexed key-value data structure. Retrieve values by their keys and compare this to a coat check system using names as keys.
Create a Dictionary7:57
Learn how to create dictionaries in Python using the dict constructor or curly braces, including empty dictionaries and English to Spanish mappings, with notes on time and space complexity.
Dictionaries in memory4:24
Explore how Python dictionaries use hash tables to map keys to memory, distribute values with a hash function, and handle collisions using linked lists.
Insert /Update an element in a Dictionary4:03
Update existing dictionary values and add new key–value pairs with assignment, achieving constant time for updates and amortized constant space even as the dictionary grows.
Traverse through a Dictionary3:42
Traverse a dictionary by looping through its keys, printing each key and its corresponding value, and observe O(n) time and O(n) space complexity.
Search for an element in a Dictionary3:57
Learn how to search for an element in a dictionary using linear search by traversing each key-value pair and returning the matching key and value.
Delete/ Remove an element from a Dictionary4:32
Learn practical techniques to delete dictionary elements using del, pop, pop item, and clear, including handling missing keys with defaults and understanding their time and space costs.
Dictionary Methods15:20
Explore Python dictionary methods such as clear, copy, fromkeys, get, items, keys, popitem, setdefault, pop, values, and update, with practical demonstrations of behavior and return values.
Dictionary Operations / Builtin Functions6:47
Explore dictionary operations in Python by examining in and not in with keys vs values, and using builtin functions like len, all, any, and sorted on dictionaries.
Dictionary vs List2:05
Explore differences between dictionary and list: dictionary uses keys for access and enforces unique keys, while lists use indices and allow duplicates. Dictionaries favor unique keys, while lists support ordered data.
Time and Space Complexity of a Dictionary3:33
Explore time and space complexity for Python dictionaries, covering creation, insertion, traversal, access, search, and deletion with O(1) and O(n) cases and hash function indexing.
Dictionary Comprehension6:20
Learn to build dictionaries with dictionary comprehension in Python, creating new dictionaries from lists or existing dictionaries using the items method, and apply conditions to filter results.
Dictionary Quiz
Download the Resources0:09
Feedback Time0:12

Count Word Frequency
SOLUTION - Time and Space Complexity of Count Word Frequency0:48
Common Keys
SOLUTION - Time and Space Complexity of Common Keys1:19
Key with the Highest Value
SOLUTION - Time and Space Complexity of Key with the Highest Value0:56
Reverse Key-Value Pairs
SOLUTION - Time and Space Complexity of Reverse Key-Value Pairs0:55
Conditional Filter
SOLUTION - Time and Space Complexity of Conditional Filter1:11
Same Frequency
SOLUTION - Time and Space Complexity of Same Frequency1:20

What is a Tuple? How to create it?5:40
Define and create tuples in Python, including syntax with commas and optional parentheses. Compare tuples with lists and dictionaries, and explore memory, accessing elements, slicing, and time and space complexity.
Tuples in Memory / Accessing an element of Tuple5:33
Learn how tuples are stored contiguously in memory and how to access elements using indexing, slicing, and negative indices, while noting that tuples are immutable.
Traversing a Tuple2:08
Traverse a tuple using a for loop or range-based indexing, printing each element, and analyze time complexity O(n) and space complexity O(1).
Search for an element in Tuple6:15
Learn three ways to search for an element in a tuple: the in operator for a result, the index method, and a custom search that reports findings in linear time.
Tuple Operations/Functions5:14
Explore tuple operations and methods, including plus operator concatenation, star operator repetition, in operator membership, and use count, index, length function, maximum, minimum, and tuple to convert lists to tuples.
Tuple vs List8:50
Compare tuples and lists by mutability: lists are mutable, tuples immutable. Explain when to use each, including reassignments, deletions, slicing, nesting, and dictionary-key implications.
Time and Space complexity of Tuples2:08
Explore time and space complexity of Python tuples, noting immutability prevents updates and deletes. Examine creating, traversing, accessing, and searching with O(1) and O(n) complexities.
Tuple Questions
Download the Resources0:09
Feedback Time0:12

Requirements

Basic Python Programming skills

Description

Welcome to the Complete Data Structures and Algorithms in Python Bootcamp, the most modern, and the most complete Data Structures and Algorithms in Python course on the internet.

At 40+ hours, this is the most comprehensive course online to help you ace your coding interviews and learn about Data Structures and Algorithms in Python. You will see 100+ Interview Questions done at the top technology companies such as Apple,Amazon, Google and Microsoft and how to face Interviews with comprehensive visual explanatory video materials which will bring you closer towards landing the tech job of your dreams!

Learning Python is one of the fastest ways to improve your career prospects as it is one of the most in demand tech skills! This course will help you in better understanding every detail of Data Structures and how algorithms are implemented in high level programming language.

We'll take you step-by-step through engaging video tutorials and teach you everything you need to succeed as a professional programmer.

After finishing this course, you will be able to:

Learn basic algorithmic techniques such as greedy algorithms, binary search, sorting and dynamic programming to solve programming challenges.

Learn the strengths and weaknesses of a variety of data structures, so you can choose the best data structure for your data and applications

Learn many of the algorithms commonly used to sort data, so your applications will perform efficiently when sorting large datasets

Learn how to apply graph and string algorithms to solve real-world challenges: finding shortest paths on huge maps and assembling genomes from millions of pieces.

Why this course is so special and different from any other resource available online?

This course will take you from very beginning to a very complex and advanced topics in understanding Data Structures and Algorithms!

You will get video lectures explaining concepts clearly with comprehensive visual explanations throughout the course.

You will also see Interview Questions done at the top technology companies such as Apple,Amazon, Google and Microsoft.

I cover everything you need to know about technical interview process!

So whether you are interested in learning the top programming language in the world in-depth

And interested in learning the fundamental Algorithms, Data Structures and performance analysis that make up the core foundational skillset of every accomplished programmer/designer or software architect and is excited to ace your next technical interview this is the course for you!

And this is what you get by signing up today:

Lifetime access to 40+ hours of HD quality videos. No monthly subscription. Learn at your own pace, whenever you want

Friendly and fast support in the course Q&A whenever you have questions or get stuck

FULL money back guarantee for 30 days!

Who is this course for?

Self-taught programmers who have a basic knowledge in Python and want to be professional in Data Structures and Algorithms and begin interviewing in tech positions!

As well as students currently studying computer science and want supplementary material on Data Structures and Algorithms and interview preparation for after graduation!

As well as professional programmers who need practice for upcoming coding interviews.

And finally anybody interested in learning more about data structures and algorithms or the technical interview process!

This course is designed to help you to achieve your career goals. Whether you are looking to get more into Data Structures and Algorithms , increase your earning potential or just want a job with more freedom, this is the right course for you!

The topics that are covered in this course.

Section 1 - Introduction

What are Data Structures?
What is an algorithm?
Why are Data Structures and Algorithms important?
Types of Data Structures
Types of Algorithms

Section 2 - Recursion

What is Recursion?
Why do we need recursion?
How Recursion works?
Recursive vs Iterative Solutions
When to use/avoid Recursion?
How to write Recursion in 3 steps?
How to find Fibonacci numbers using Recursion?

Section 3 - Cracking Recursion Interview Questions

Question 1 - Sum of Digits
Question 2 - Power
Question 3 - Greatest Common Divisor
Question 4 - Decimal To Binary

Section 4 - Bonus CHALLENGING Recursion Problems (Exercises)

power
factorial
productofArray
recursiveRange
fib
reverse
isPalindrome
someRecursive
flatten
captalizeFirst
nestedEvenSum
capitalizeWords
stringifyNumbers
collectStrings

Section 5 - Big O Notation

Analogy and Time Complexity
Big O, Big Theta and Big Omega
Time complexity examples
Space Complexity
Drop the Constants and the non dominant terms
Add vs Multiply
How to measure the codes using Big O?
How to find time complexity for Recursive calls?
How to measure Recursive Algorithms that make multiple calls?

Section 6 - Top 10 Big O Interview Questions (Amazon, Facebook, Apple and Microsoft)

Product and Sum
Print Pairs
Print Unordered Pairs
Print Unordered Pairs 2 Arrays
Print Unordered Pairs 2 Arrays 100000 Units
Reverse
O(N) Equivalents
Factorial Complexity
Fibonacci Complexity
Powers of 2

Section 7 - Arrays

What is an Array?
Types of Array
Arrays in Memory
Create an Array
Insertion Operation
Traversal Operation
Accessing an element of Array
Searching for an element in Array
Deleting an element from Array
Time and Space complexity of One Dimensional Array
One Dimensional Array Practice
Create Two Dimensional Array
Insertion - Two Dimensional Array
Accessing an element of Two Dimensional Array
Traversal - Two Dimensional Array
Searching for an element in Two Dimensional Array
Deletion - Two Dimensional Array
Time and Space complexity of Two Dimensional Array
When to use/avoid array

Section 8 - Python Lists

What is a List? How to create it?
Accessing/Traversing a list
Update/Insert a List
Slice/ from a List
Searching for an element in a List
List Operations/Functions
Lists and strings
Common List pitfalls and ways to avoid them
Lists vs Arrays
Time and Space Complexity of List
List Interview Questions

Section 9 - Cracking Array/List Interview Questions (Amazon, Facebook, Apple and Microsoft)

Question 1 - Missing Number
Question 2 - Pairs
Question 3 - Finding a number in an Array
Question 4 - Max product of two int
Question 5 - Is Unique
Question 6 - Permutation
Question 7 - Rotate Matrix

Section 10 - CHALLENGING Array/List Problems (Exercises)

Middle Function
2D Lists
Best Score
Missing Number
Duplicate Number
Pairs

Section 11 - Dictionaries

What is a Dictionary?
Create a Dictionary
Dictionaries in memory
Insert /Update an element in a Dictionary
Traverse through a Dictionary
Search for an element in a Dictionary
Delete / Remove an element from a Dictionary
Dictionary Methods
Dictionary operations/ built in functions
Dictionary vs List
Time and Space Complexity of a Dictionary
Dictionary Interview Questions

Section 12 - Tuples

What is a Tuple? How to create it?
Tuples in Memory / Accessing an element of Tuple
Traversing a Tuple
Search for an element in Tuple
Tuple Operations/Functions
Tuple vs List
Time and Space complexity of Tuples
Tuple Questions

Section 13 - Linked List

What is a Linked List?
Linked List vs Arrays
Types of Linked List
Linked List in the Memory
Creation of Singly Linked List
Insertion in Singly Linked List in Memory
Insertion in Singly Linked List Algorithm
Insertion Method in Singly Linked List
Traversal of Singly Linked List
Search for a value in Single Linked List
Deletion of node from Singly Linked List
Deletion Method in Singly Linked List
Deletion of entire Singly Linked List
Time and Space Complexity of Singly Linked List

Section 14 - Circular Singly Linked List

Creation of Circular Singly Linked List
Insertion in Circular Singly Linked List
Insertion Algorithm in Circular Singly Linked List
Insertion method in Circular Singly Linked List
Traversal of Circular Singly Linked List
Searching a node in Circular Singly Linked List
Deletion of a node from Circular Singly Linked List
Deletion Algorithm in Circular Singly Linked List
Method in Circular Singly Linked List
Deletion of entire Circular Singly Linked List
Time and Space Complexity of Circular Singly Linked List

Section 15 - Doubly Linked List

Creation of Doubly Linked List
Insertion in Doubly Linked List
Insertion Algorithm in Doubly Linked List
Insertion Method in Doubly Linked List
Traversal of Doubly Linked List
Reverse Traversal of Doubly Linked List
Searching for a node in Doubly Linked List
Deletion of a node in Doubly Linked List
Deletion Algorithm in Doubly Linked List
Deletion Method in Doubly Linked List
Deletion of entire Doubly Linked List
Time and Space Complexity of Doubly Linked List

Section 16 - Circular Doubly Linked List

Creation of Circular Doubly Linked List
Insertion in Circular Doubly Linked List
Insertion Algorithm in Circular Doubly Linked List
Insertion Method in Circular Doubly Linked List
Traversal of Circular Doubly Linked List
Reverse Traversal of Circular Doubly Linked List
Search for a node in Circular Doubly Linked List
Delete a node from Circular Doubly Linked List
Deletion Algorithm in Circular Doubly Linked List
Deletion Method in Circular Doubly Linked List
Entire Circular Doubly Linked List
Time and Space Complexity of Circular Doubly Linked List
Time Complexity of Linked List vs Arrays

Section 17 - Cracking Linked List Interview Questions (Amazon, Facebook, Apple and Microsoft)

Linked List Class
Question 1 - Remove Dups
Question 2 - Return Kth to Last
Question 3 - Partition
Question 4 - Sum Linked Lists
Question 5 - Intersection

Section 18 - Stack

What is a Stack?
Stack Operations
Create Stack using List without size limit
Operations on Stack using List (push, pop, peek, isEmpty, )
Create Stack with limit (pop, push, peek, isFull, isEmpty, )
Create Stack using Linked List
Operation on Stack using Linked List (pop, push, peek, isEmpty, )
Time and Space Complexity of Stack using Linked List
When to use/avoid Stack
Stack Quiz

Section 19 - Queue

What is Queue?
Queue using Python List - no size limit
Queue using Python List - no size limit , operations (enqueue, dequeue, peek)
Circular Queue - Python List
Circular Queue - Python List, Operations (enqueue, dequeue, peek, )
Queue - Linked List
Queue - Linked List, Operations (Create, Enqueue)
Queue - Linked List, Operations (Dequeue(), isEmpty, Peek)
Time and Space complexity of Queue using Linked List
List vs Linked List Implementation
Collections Module
Queue Module
Multiprocessing module

Section 20 - Cracking Stack and Queue Interview Questions (Amazon,Facebook, Apple, Microsoft)

Question 1 - Three in One
Question 2 - Stack Minimum
Question 3 - Stack of Plates
Question 4 - Queue via Stacks
Question 5 - Animal Shelter

Section 21 - Tree / Binary Tree

What is a Tree?
Why Tree?
Tree Terminology
How to create a basic tree in Python?
Binary Tree
Types of Binary Tree
Binary Tree Representation
Create Binary Tree (Linked List)
PreOrder Traversal Binary Tree (Linked List)
InOrder Traversal Binary Tree (Linked List)
PostOrder Traversal Binary Tree (Linked List)
LevelOrder Traversal Binary Tree (Linked List)
Searching for a node in Binary Tree (Linked List)
Inserting a node in Binary Tree (Linked List)
Delete a node from Binary Tree (Linked List)
Delete entire Binary Tree (Linked List)
Create Binary Tree (Python List)
Insert a value Binary Tree (Python List)
Search for a node in Binary Tree (Python List)
PreOrder Traversal Binary Tree (Python List)
InOrder Traversal Binary Tree (Python List)
PostOrder Traversal Binary Tree (Python List)
Level Order Traversal Binary Tree (Python List)
Delete a node from Binary Tree (Python List)
Entire Binary Tree (Python List)
Linked List vs Python List Binary Tree

Section 22 - Binary Search Tree

What is a Binary Search Tree? Why do we need it?
Create a Binary Search Tree
Insert a node to BST
Traverse BST
Search in BST
Delete a node from BST
Delete entire BST
Time and Space complexity of BST

Section 23 - AVL Tree

What is an AVL Tree?
Why AVL Tree?
Common Operations on AVL Trees
Insert a node in AVL (Left Left Condition)
Insert a node in AVL (Left Right Condition)
Insert a node in AVL (Right Right Condition)
Insert a node in AVL (Right Left Condition)
Insert a node in AVL (all together)
Insert a node in AVL (method)
Delete a node from AVL (LL, LR, RR, RL)
Delete a node from AVL (all together)
Delete a node from AVL (method)
Delete entire AVL
Time and Space complexity of AVL Tree

Section 24 - Binary Heap

What is Binary Heap? Why do we need it?
Common operations (Creation, Peek, sizeofheap) on Binary Heap
Insert a node in Binary Heap
Extract a node from Binary Heap
Delete entire Binary Heap
Time and space complexity of Binary Heap

Section 25 - Trie

What is a Trie? Why do we need it?
Common Operations on Trie (Creation)
Insert a string in Trie
Search for a string in Trie
Delete a string from Trie
Practical use of Trie

Section 26 - Hashing

What is Hashing? Why do we need it?
Hashing Terminology
Hash Functions
Types of Collision Resolution Techniques
Hash Table is Full
Pros and Cons of Resolution Techniques
Practical Use of Hashing
Hashing vs Other Data structures

Section 27 - Sort Algorithms

What is Sorting?
Types of Sorting
Sorting Terminologies
Bubble Sort
Selection Sort
Insertion Sort
Bucket Sort
Merge Sort
Quick Sort
Heap Sort
Comparison of Sorting Algorithms

Section 28 - Searching Algorithms

Introduction to Searching Algorithms
Linear Search
Linear Search in Python
Binary Search
Binary Search in Python
Time Complexity of Binary Search

Section 29 - Graph Algorithms

What is a Graph? Why Graph?
Graph Terminology
Types of Graph
Graph Representation
Create a graph using Python
Graph traversal - BFS
BFS Traversal in Python
Graph Traversal - DFS
DFS Traversal in Python
BFS Traversal vs DFS Traversal
Topological Sort
Topological Sort Algorithm
Topological Sort in Python
Single Source Shortest Path Problem (SSSPP)
BFS for Single Source Shortest Path Problem (SSSPP)
BFS for Single Source Shortest Path Problem (SSSPP) in Python
Why does BFS not work with weighted Graphs?
Why does DFS not work for SSSP?
Dijkstra's Algorithm for SSSP
Dijkstra's Algorithm in Python
Dijkstra Algorithm with negative cycle
Bellman Ford Algorithm
Bellman Ford Algorithm with negative cycle
Why does Bellman Ford run V-1 times?
Bellman Ford in Python
BFS vs Dijkstra vs Bellman Ford
All pairs shortest path problem
Dry run for All pair shortest path
Floyd Warshall Algorithm
Why Floyd Warshall?
Floyd Warshall with negative cycle,
Floyd Warshall in Python,
BFS vs Dijkstra vs Bellman Ford vs Floyd Warshall,
Minimum Spanning Tree,
Disjoint Set,
Disjoint Set in Python,
Kruskal Algorithm,
Kruskal Algorithm in Python,
Prim's Algorithm,
Prim's Algorithm in Python,
Prim's vs Kruskal

Section 30 - Greedy Algorithms

What is Greedy Algorithm?
Well known Greedy Algorithms
Activity Selection Problem
Activity Selection Problem in Python
Coin Change Problem
Coin Change Problem in Python
Fractional Knapsack Problem
Fractional Knapsack Problem in Python

Section 31 - Divide and Conquer Algorithms

What is a Divide and Conquer Algorithm?
Common Divide and Conquer algorithms
How to solve Fibonacci series using Divide and Conquer approach?
Number Factor
Number Factor in Python
House Robber
House Robber Problem in Python
Convert one string to another
Convert One String to another in Python
Zero One Knapsack problem
Zero One Knapsack problem in Python
Longest Common Sequence Problem
Longest Common Subsequence in Python
Longest Palindromic Subsequence Problem
Longest Palindromic Subsequence in Python
Minimum cost to reach the Last cell problem
Minimum Cost to reach the Last Cell in 2D array using Python
Number of Ways to reach the Last Cell with given Cost
Number of Ways to reach the Last Cell with given Cost in Python

Section 32 - Dynamic Programming

What is Dynamic Programming? (Overlapping property)
Where does the name of DC come from?
Top Down with Memoization
Bottom Up with Tabulation
Top Down vs Bottom Up
Is Merge Sort Dynamic Programming?
Number Factor Problem using Dynamic Programming
Number Factor : Top Down and Bottom Up
House Robber Problem using Dynamic Programming
House Robber : Top Down and Bottom Up
Convert one string to another using Dynamic Programming
Convert String using Bottom Up
Zero One Knapsack using Dynamic Programming
Zero One Knapsack - Top Down
Zero One Knapsack - Bottom Up

Section 33 - CHALLENGING Dynamic Programming Problems

Longest repeated Subsequence Length problem
Longest Common Subsequence Length problem
Longest Common Subsequence problem
Diff Utility
Shortest Common Subsequence problem
Length of Longest Palindromic Subsequence
Subset Sum Problem
Egg Dropping Puzzle
Maximum Length Chain of Pairs

Section 34 - A Recipe for Problem Solving

Introduction
Step 1 - Understand the problem
Step 2 - Examples
Step 3 - Break it Down
Step 4 - Solve or Simplify
Step 5 - Look Back and Refactor

Who this course is for:

Anybody interested in learning more about data structures and algorithms or the technical interview process!
Self-taught programmers who have a basic knowledge in Python and want to be professional in Data Structure and Algorithm and begin interviewing in tech positions!
Students currently studying computer science and want supplementary material on Data Structure and Algorithm and interview preparation for after graduation!
Professional programmers who need practice for upcoming coding interviews.

The Complete Data Structures and Algorithms Course in Python

What you'll learn

Explore related topics

Coding Exercises

Course content

Introduction11 lectures • 34min

Big O Notation13 lectures • 50min

Arrays21 lectures • 2hr 19min

Python Lists14 lectures • 1hr 26min

PROJECT 1 - Arrays/Lists3 lectures • 13min

Array/List - CODING EXERCISES - LeetCode - Cracking FAANG Interview Questions16 lectures • 32min

Top 10 Big O Interview Questions (Amazon, Facebook, Apple and Microsoft)9 lectures • 19min

Dictionaries14 lectures • 1hr 7min

Dictionary - CODING EXERCISES6 lectures • 6min

Tuples9 lectures • 36min

Requirements

Description

Who this course is for: