Data Structures & Algorithms In Python

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

What you'll 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

Requirements

Basic python programming

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.The course covers the following topics:GeneralWhy Should You Learn Data Structures and Algorithms ?What are Data Structures ?What are Algorithms ?Big O NotationLinear Complexity - O(n)Constant Complexity - O(1)Quadratic Complexity - O(n^2)Logarithmic Complexity - O(logn)Constants in Big ODominant and Non-Dominant Factors in Big OComplexities ComparisonData StructuresLinked ListsPython Built-In ListsStacksQueuesSetsTreesHeapsHash TablesGraphsAlgorithmsLinear SearchBinary SearchBubble SortInsertion SortSelection SortMerge SortRecursionTree TraversalGraph TraversalI'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 :)

Overview

Section 1: Introduction

Lecture 1 Why Should You Learn Data Structures and Algorithms ?

Lecture 2 What are Data Structures ?

Lecture 3 What are Algorithms ?

Lecture 4 Information about the Course

Section 2: Big O Notation

Lecture 5 Introduction to Big O Notation

Lecture 6 Linear Complexity - O(n)

Lecture 7 Constant Complexity - O(1)

Lecture 8 Quadratic Complexity - O(n^2)

Lecture 9 Logarithmic Complexity - O(logn)

Lecture 10 Constants in Big O

Lecture 11 Dominant and Non-Dominant Factors in Big O

Lecture 12 Complexities Comparison

Section 3: Big O Notation: Practical

Section 4: Linked Lists

Lecture 13 Introduction to Linked Lists

Lecture 14 Linked List Class Implementation

Lecture 15 Linked List: Add Element

Lecture 16 Linked List: Append Implementation

Lecture 17 Linked List: Prepend Implementation

Lecture 18 Linked List: Iterating

Lecture 19 Linked List: Iterating Implementation

Lecture 20 Linked List: Removing Elements

Lecture 21 Linked List: Removing Elements Implementation

Lecture 22 Time Complexity of Linked Lists Operations

Lecture 23 When to Use Linked Lists

Section 5: Linked Lists: Practical

Lecture 24 Leetcode Challenge - Reverse Linked List: Solution

Lecture 25 Leetcode Challenge - Middle of the Linked List: Solution

Section 6: Linked Lists: Python Built-In Lists

Lecture 26 Creating Lists

Lecture 27 Iterating Lists

Lecture 28 Append

Lecture 29 Extend

Lecture 30 Insert

Lecture 31 Remove

Lecture 32 Pop

Lecture 33 Clear

Lecture 34 Count

Lecture 35 Reverse

Section 7: Python Built-In Lists: Practical

Section 8: Stacks

Lecture 36 Introduction to Stacks

Lecture 37 Stack Implementation: Stack and Node Classes

Lecture 38 Stack Implementation: Push

Lecture 39 Stack Implementation: Pop & isEmpty

Lecture 40 Python Built-In List as Stack

Section 9: Stacks: Practical

Lecture 41 Leetcode Challenge - Valid Parentheses: Solution

Section 10: Queues

Lecture 42 Introduction to Queues

Lecture 43 Queue Implementation: Queue and Node Classes

Lecture 44 Queue Implementation: isEmpty

Lecture 45 Queue Implementation: Enqueue

Lecture 46 Queue Imeplementation: Dequeue

Section 11: Queues: Practical

Lecture 47 Leetcode Challenge - Implement Queue Using Two Stacks: Solution

Section 12: Sets

Lecture 48 Introduction to Sets

Lecture 49 Creating and Initializing Sets

Lecture 50 Set's Methods and Operations

Lecture 51 Sets Big O

Section 13: Sets Practical

Section 14: Trees

Lecture 52 Introduction to Trees

Lecture 53 Binary Trees

Lecture 54 Complete Binary Trees

Lecture 55 Binary Search Trees

Lecture 56 Binary Search Trees: Insert Operation

Lecture 57 Binary Search Trees: Class Implementation

Lecture 58 Binary Search Trees: Insert Operation Implementation

Lecture 59 Binary Search Trees: Search Operation Implementation

Section 15: Trees: Practical

Lecture 60 Leetcode Challenge - Search in a Binary Search Tree: Solution

Section 16: Heaps

Lecture 61 Introduction to Heaps

Lecture 62 Heaps: Insert

Lecture 63 Heaps: Pop

Lecture 64 Heap Implementation

Lecture 65 Heap Implementation: Insert & Heapify Up

Lecture 66 Heap Implementation: Pop

Lecture 67 Heap Implementation: Heapify Down

Lecture 68 Using heapq as Minimum Heap in Python

Lecture 69 Heap Operations Time Complexities

Section 17: Heaps: Practical

Lecture 70 Leetcode Challenge - Kth Largest Element in a Stream: Solution

Section 18: Hash Tables

Lecture 71 Introduction to Hash Tables

Lecture 72 Using Dictionaries as Hash Tables in Python

Lecture 73 Hash Tables Time & Space Complexities

Section 19: Hash Tables: Practical

Lecture 74 Leetcode Challenge - 2 Sum: Solution

Section 20: Graphs

Lecture 75 Introduction to Graphs

Lecture 76 Graphs: Adjacency Matrix

Lecture 77 Graphs: Adjacency List

Lecture 78 Graph Implementation: Class & Constructor

Lecture 79 Graph Implementation: Add Node

Lecture 80 Graph Implementation: Add Edge

Lecture 81 Graph Implementation: Remove Edge

Lecture 82 Graph Implementation: Remove Node

Lecture 83 Graph Implementation: Display

Lecture 84 Graph Time & Space Complexities

Section 21: Graphs: Practical

Section 22: Searching Algorithms

Lecture 85 Linear Search

Lecture 86 Linear Search Implementation

Lecture 87 Binary Search

Lecture 88 Binary Search Implementation

Lecture 89 Searching Algorithms Big O

Section 23: Searching Algorithms: Practical

Section 24: Sorting Algorithms

Lecture 90 Bubble Sort

Lecture 91 Bubble Sort Implementation

Lecture 92 Insertion Sort

Lecture 93 Insertion Sort Implementation

Lecture 94 Selection Sort

Lecture 95 Selection Sort Implementation

Lecture 96 Merge Sort

Lecture 97 Merge Sort Implementation

Lecture 98 Sorting Algorithms Big O

Section 25: Sorting Algorithms: Practical

Lecture 99 Leetcode Challenge - Cout Pairs Whose Sum is Less than Target: Solution

Section 26: Recursion

Lecture 100 Introduction to Recursion

Lecture 101 Call Stack

Lecture 102 Recursion Example: Factorial

Lecture 103 Recursion Big O

Section 27: Recursion: Practical

Lecture 104 Leetcode Challenge - Fibonacci Number: Solution

Section 28: Tree Traversal

Lecture 105 Introduction

Lecture 106 Inorder

Lecture 107 Inorder Implementation

Lecture 108 Preorder

Lecture 109 Preorder Implementation

Lecture 110 Postorder

Lecture 111 Postorder Implementation

Lecture 112 Tree Traversal Big O

Section 29: Tree Traversal: Practical

Lecture 113 Leetcode Challenge - Range Sum of BST: Solution

Section 30: Graph Traversal

Lecture 114 Introduction

Lecture 115 BFS

Lecture 116 BFS Implementation

Lecture 117 DFS

Lecture 118 DFS Implementation

Lecture 119 Graph Traversal Big O

Section 31: Graph Traversal: Practical

Lecture 120 Leetcode Challenge - Find if Path Exists in Graph: Solution

Section 32: Conclusion

Lecture 121 Final Thoughts

Python Programmers Who Want to Master Data Structures and Algorithms,Python Programmers Preparing for Coding Interviews,Python Programmers Who Want to Write More Efficient Code and Improve Their Problem-Solving Skills