• Post category:StudyBullet-16

Data Structures and Algorithms in Python | Leetcode + Video Solutions | Animated Explanation | Ace Coding Inteviews

What you will learn

### 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.

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

• 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

Introduction to Linked Lists
Linked List Class Implementation
Linked List: Append Implementation
Linked List: Prepend Implementation
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

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

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
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

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

Final Thoughts