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 Python Data Structures & Algorithms: Ace Coding Interviews
Grasp Big O Notation and How to Calculate Space & Time Complexities
Enhance Your Problem-Solving Skills
Refine Your Programming Skills
Tackle Leetcode Challenges with Video Solutions
Learn 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 looking to write efficient code and enhance your programming and problem-solving skills?
Do you have an upcoming coding interview and want to confidently ace it?
If the answer is yes, then this course is the right choice for you!
In this course, you will delve into everything about Data Structures and Algorithms and learn how to implement and use them in Python.
The concepts are elucidated with animations, making it easier to understand and memorize.
Throughout the course, you'll apply your knowledge via coding exercises and tackle Leetcode coding challenges with video solutions.
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. However, if for some reason you are not satisfied, the course is backed by Udemy's 30-day money-back guarantee, so there's nothing to lose :)
I'm excited to see you in the course! Hit that enroll button and embark on your journey to master Data Structures & Algorithms :)
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
View Course on View:
