Data Structures In Python Course: Crack Coding Interviews

Master Data Structures in Python | Big O Notation (Space Complexity and Time Complexity) | Crack Coding Interviews

What you'll learn

Understand time and space complexities and how to calculate them

Understand computer science and how do they work

Implement computer science data structures from scratch

Use built-in data structures in Python

Requirements

Basic Python knowledge

Description

Welcome to Data Structures in Python Course: Crack Coding Interviews course :)In this course we will dive deep into Data Structures and learn how to do they work, how to implement them in Python and how to use them for implementing and optimizing your application. We will also take a look at the built-in data structures provided by Python and learn how to use them. And we will learn how to calculate time complexity and space complexity of the code and how to decide which data structure should be used for solving a specific programming problem.Data structures is a very important aspect of computer science, learning and understanding data structures will help you become a better programmer, write more efficient code and solve problems quicker, that's why Tech companies focus on data structures in the coding interviews.Throughout this course we will cover everything you need to master data structures , including:Big O notation (Time Complexity & Space Complexity)Linked listsStacksHeapsQueuesHash TablesTreesBinary Search TreesGraphs (Adjacency List & Adjacency Matrix)I am confident that you will like this course and that you will be a different programmer once you finish it, join me in this course and master data structures and algorithms! :)

Overview

Section 1: Big O Notation

Lecture 1 Introduction to Big O Notation

Lecture 2 Linear Complexity - O(n)

Lecture 3 Constant Complexity - O(1)

Lecture 4 Quadratic Complexity - O(n^2)

Lecture 5 Logarithmic Complexity - O(logn)

Lecture 6 Constants in Big O

Lecture 7 Dominant and Non-Dominant Factors in Big O

Lecture 8 Complexities Comparison

Section 2: Linked Lists

Lecture 9 Introduction to Linked Lists

Lecture 10 Linked List Implementation

Lecture 11 Linked Lists: Adding Elements

Lecture 12 Linked Lists: Append Implementation

Lecture 13 Linked Lists: Prepend Implementation

Lecture 14 Linked Lists: Iterating

Lecture 15 Linked Lists: Iterating Implementation

Lecture 16 Linked Lists: Removing Elements

Lecture 17 Linked Lists: Removing Elements Implementation

Lecture 18 Time Complexity of Linked Lists Operations

Lecture 19 When to Use Linked Lists

Section 3: Linked Lists: Python Built-In Lists

Lecture 20 Introduction to Python Built-In Lists

Lecture 21 Creating Lists

Lecture 22 Iterating Lists

Lecture 23 Append

Lecture 24 Extend

Lecture 25 Insert

Lecture 26 Remove

Lecture 27 Pop

Lecture 28 Clear

Lecture 29 Count

Lecture 30 Reverse

Section 4: Stacks

Lecture 31 Introduction to Stacks

Lecture 32 Stack Implementation: Stack and Node Classes

Lecture 33 Stack Implementation: Push

Lecture 34 Stack Implementation: Pop & isEmpty

Lecture 35 Python Built-In List as Stack

Section 5: Queues

Lecture 36 Introduction to Queues

Lecture 37 Queue Implementation: Queue and Node Classes

Lecture 38 Queue Implementation: isEmpty

Lecture 39 Queue Implementation: Enqueue

Lecture 40 Queue Imeplementation: Dequeue

Section 6: Trees

Lecture 41 Introduction to Trees

Lecture 42 Binary Trees

Lecture 43 Binary Search Trees

Lecture 44 Binary Search Trees: Insert Operation

Lecture 45 Binary Search Trees: Class Implementation

Lecture 46 Binary Search Trees: Insert Operation Implementation

Lecture 47 Binary Search Trees: Search Operation Implementation

Section 7: Heaps

Lecture 48 Introduction to Heaps

Lecture 49 Heaps: Insert

Lecture 50 Heaps: Pop

Lecture 51 Heap Implementation

Lecture 52 Heap Implementation: Insert & Heapify Up

Lecture 53 Heap Implementation: Pop

Lecture 54 Heap Implementation: Heapify Down

Section 8: Hash Tables

Lecture 55 Introduction to Hash Tables

Lecture 56 Using Dictionaries as Hash Tables in Python

Lecture 57 Hash Tables Time & Space Complexities

Section 9: Graphs

Lecture 58 Introduction to Graphs

Lecture 59 Graphs: Adjacency Matrix

Lecture 60 Graphs: Adjacency List

Lecture 61 Graph Implementation: Class & Constructor

Lecture 62 Graph Implementation: Add Node

Lecture 63 Graph Implementation: Add Edge

Lecture 64 Graph Implementation: Remove Edge

Lecture 65 Graph Implementation: Remove Node

Lecture 66 Graph Implementation: Display

Lecture 67 Graph Time & Space Complexities

Python developers who want to become better programmers by learning and understanding data structres and how to implement and use them