Data Structures and Algorithms in Python | Leetcode + Video Solutions | Animated Explanation | Ace Coding Inteviews
What you will learn
Understand Data Structures and Algorithms & How to Implement and Use them in Python
Understand Big O Notation and How to Calculate Space & Time Complexities
Improve your Problem Solving Skills
Enhance your Programming Skills
Leetcode Challenges with Video Solutions
Understand How to Decide When to Use a Specific Algorithm or Data Structure for Different Use Cases
Ace Coding Interviews
Description
Welcome to the Data Structures and Algorithms in Python Course!
Are you a Python programmer who wants to write efficient code and improve your programming and problem solving skills ?
Do you have an upcoming coding interview and you want to ace it with confidence ?
If the answer is yes, then this course is the right choice for you!
In this course you will learn everything about Data Structures and Algorithms and how to implement and use them in Python.
The concepts are explained with animations which makes it much more easier to understand and memorize.
You will also apply your knowledge throughout the course via coding exercises and Leetcode coding challenges with video solutions.
Get Instant Notification of New Courses on our Telegram channel.
Noteβ Make sure your ππππ¦π² cart has only this course you're going to enroll it now, Remove all other courses from the ππππ¦π² cart before Enrolling!
The course covers the following topics:
General
- Why Should You Learn Data Structures and Algorithms ?
- What are Data Structures ?
- What are Algorithms ?
Big O Notation
- Linear Complexity – O(n)
- Constant Complexity – O(1)
- Quadratic Complexity – O(n^2)
- Logarithmic Complexity – O(logn)
- Constants in Big O
- Dominant and Non-Dominant Factors in Big O
- Complexities Comparison
Data Structures
- Linked Lists
- Python Built-In Lists
- Stacks
- Queues
- Sets
- Trees
- Heaps
- Hash Tables
- Graphs
Algorithms
- Linear Search
- Binary Search
- Bubble Sort
- Insertion Sort
- Selection Sort
- Merge Sort
- Recursion
- Tree Traversal
- Graph Traversal
I’m confident that you will enjoy this course, but if you for some reason are not happy with the course it’s backed by Udemy’s 30 day money back guarantee, so nothing to lose π
I’m excited to see you in the course, hit that enroll button and start your mastering Data Structures & Algorithms journey π
English
language
Content
Introduction
Why Should You Learn Data Structures and Algorithms ?
What are Data Structures ?
What are Algorithms ?
Information about the Course
Big O Notation
Introduction to Big O Notation
Linear Complexity – O(n)
Constant Complexity – O(1)
Quadratic Complexity – O(n^2)
Logarithmic Complexity – O(logn)
Constants in Big O
Dominant and Non-Dominant Factors in Big O
Complexities Comparison
Big O Notation: Practical
Big O Notation’s Quiz
Big O Calculation
Linked Lists
Introduction to Linked Lists
Linked List Class Implementation
Linked List: Add Element
Linked List: Append Implementation
Linked List: Prepend Implementation
Linked List: Iterating
Linked List: Iterating Implementation
Linked List: Removing Elements
Linked List: Removing Elements Implementation
Time Complexity of Linked Lists Operations
When to Use Linked Lists
Linked Lists: Practical
Linked List’s Quiz
Append/Prepend Implementation
Leetcode Challenge – Reverse Linked List
Leetcode Challenge – Reverse Linked List: Solution
Leetcode Challenge – Middle of the Linked List
Leetcode Challenge – Middle of the Linked List: Solution
Linked Lists: Python Built-In Lists
Creating Lists
Iterating Lists
Append
Extend
Insert
Remove
Pop
Clear
Count
Reverse
Python Built-In Lists: Practical
Reverse/Extend List
Extend List
Stacks
Introduction to Stacks
Stack Implementation: Stack and Node Classes
Stack Implementation: Push
Stack Implementation: Pop & isEmpty
Python Built-In List as Stack
Stacks: Practical
Stack’s Quiz
Stack Implementation
Reverse String using a Stack
Leetcode Challenge – Valid Parentheses
Leetcode Challenge – Valid Parentheses: Solution
Queues
Introduction to Queues
Queue Implementation: Queue and Node Classes
Queue Implementation: isEmpty
Queue Implementation: Enqueue
Queue Imeplementation: Dequeue
Queues: Practical
Queue’s Quiz
Queue Implementation
Leetcode Challenge – Implement Queue Using Two Stacks
Leetcode Challenge – Implement Queue Using Two Stacks: Solution
Sets
Introduction to Sets
Creating and Initializing Sets
Set’s Methods and Operations
Sets Big O
Sets Practical
Set’s Quiz
Remove Duplicates
Trees
Introduction to Trees
Binary Trees
Complete Binary Trees
Binary Search Trees
Binary Search Trees: Insert Operation
Binary Search Trees: Class Implementation
Binary Search Trees: Insert Operation Implementation
Binary Search Trees: Search Operation Implementation
Trees: Practical
Tree’s Quiz
Leetcode Challenge: Search in a Binary Search Tree
Leetcode Challenge – Search in a Binary Search Tree: Solution
Heaps
Introduction to Heaps
Heaps: Insert
Heaps: Pop
Heap Implementation
Heap Implementation: Insert & Heapify Up
Heap Implementation: Pop
Heap Implementation: Heapify Down
Using heapq as Minimum Heap in Python
Heap Operations Time Complexities
Heaps: Practical
Heap’s Quiz
Leetcode Challenge – Kth Largest Element in a Stream
Leetcode Challenge – Kth Largest Element in a Stream: Solution
Hash Tables
Introduction to Hash Tables
Using Dictionaries as Hash Tables in Python
Hash Tables Time & Space Complexities
Hash Tables: Practical
Hash Table’s Quiz
Leetcode Challenge – 2 Sum
Leetcode Challenge – 2 Sum: Solution
Graphs
Introduction to Graphs
Graphs: Adjacency Matrix
Graphs: Adjacency List
Graph Implementation: Class & Constructor
Graph Implementation: Add Node
Graph Implementation: Add Edge
Graph Implementation: Remove Edge
Graph Implementation: Remove Node
Graph Implementation: Display
Graph Time & Space Complexities
Graphs: Practical
Graph’s Quiz
Code Exercise 1
Searching Algorithms
Linear Search
Linear Search Implementation
Binary Search
Binary Search Implementation
Searching Algorithms Big O
Searching Algorithms: Practical
Searching Algorithm’s Quiz
Coding Exercise 1
Coding Exercise 2
Sorting Algorithms
Bubble Sort
Bubble Sort Implementation
Insertion Sort
Insertion Sort Implementation
Selection Sort
Selection Sort Implementation
Merge Sort
Merge Sort Implementation
Sorting Algorithms Big O
Sorting Algorithms: Practical
Sorting Algorithm’s Quiz
Leetcode Challenge – Count Pairs Whose Sum is Less than Target
Leetcode Challenge – Cout Pairs Whose Sum is Less than Target: Solution
Recursion
Introduction to Recursion
Call Stack
Recursion Example: Factorial
Recursion Big O
Recursion: Practical
Recursion’s Quiz
Leetcode Challenge – Fibonacci Number
Leetcode Challenge – Fibonacci Number: Solution
Tree Traversal
Introduction
Inorder
Inorder Implementation
Preorder
Preorder Implementation
Postorder
Postorder Implementation
Tree Traversal Big O
Tree Traversal: Practical
Tree Traversal’s Quiz
Leetcode Challenge – Range Sum of BST
Leetcode Challenge – Range Sum of BST: Solution
Graph Traversal
Introduction
BFS
BFS Implementation
DFS
DFS Implementation
Graph Traversal Big O
Graph Traversal: Practical
Graph Traversal’s Quiz
Leetcode Challenge – Find if Path Exists in Graph
Leetcode Challenge – Find if Path Exists in Graph: Solution
Conclusion
Final Thoughts