Python Data Structures & Algorithms: Ace Coding Interviews from Udemy

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:

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
Doubly Linked Lists
Stacks
Queues
Sets
Trees
Tries
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 :)

What's inside

Learning objectives

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

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

Syllabus

Introduction

Why Should You Learn Data Structures and Algorithms ?

What are Data Structures ?

What are Algorithms ?

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 List Use Case: Shopping Cart

Linked Lists: Practical

Linked List's Quiz

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

Doubly Linked Lists

Introduction to Doubly Linked Lists

Doubly Linked List Class Implementation

Doubly Linked List: Append Implementation

Doubly Linked List: Prepend Implementation

Doubly Linked List: Delete Implementation

Time Complexity of Doubly Linked Lists Operations

Doubly Linked List Use Case: Text Cursor

Doubly Linked Lists: Practical

Doubly Linked Lists Quiz

Stacks

Introduction to Stacks

Stack Implementation: Stack and Node Classes

Stack Implementation: Push

Stack Implementation: Pop & isEmpty

Python Built-In List as Stack

Stack Use Case: Text Editor Undo Functionality

Stacks: Practical

Stack's Quiz

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

Queue Use Case: Print Service

Queues: Practical

Queue's Quiz

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

Set Use Case: Unique Words Count

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

Good to know

Know what's good

, what to watch for

, and possible dealbreakers

Ideal for Python programmers seeking to enhance their programming and problem-solving capabilities

Provides a comprehensive foundation in Data Structures and Algorithms, enabling learners to understand and implement them effectively in Python

Suitable for learners preparing for coding interviews, as it includes Leetcode challenges with video solutions

Emphasizes practical application, with exercises and coding challenges throughout the course

Taught by Ahmed Elsakka, an experienced instructor with a strong understanding of Data Structures and Algorithms

May require familiarity with basic programming concepts and Python syntax before enrolling

Activities

Be better prepared before your course. Deepen your understanding during and after it. Supplement your coursework and achieve mastery of the topics covered in Python Data Structures & Algorithms: Ace Coding Interviews with these activities:

Read 'Grokking Algorithms'

Show steps

Provides a clear and intuitive explanation of algorithms

View Grokking Algorithms, Second Edition on Amazon

Show steps

Purchase or borrow the book
Read the book and take notes
Complete the exercises in the book

Learn about Big O with VisuAlgo

Show steps

VisuAlgo provides a visual and interactive way to understand big O notation

Show steps

Go to the VisuAlgo website
Select the 'Big O' tab
Follow the interactive tutorials

Attend a Python Meetup

Show steps

Attending meetups allows you to connect with others in the field

Show steps

Find a Python meetup in your area
Attend the meetup
Network with other Python developers

Six other activities

Expand to see all activities and additional details

Show all nine activities

Form a Study Group with Coursemates

Show steps

Study groups provide an environment for collaboration and peer learning

Show steps

Reach out to coursemates and form a study group
Schedule regular meetings
Discuss course material and work on projects together

Practice Linked List Problems

Show steps

Solve leetcode problems on linked lists to improve understanding

Show steps

Pick a leetcode problem on linked lists
Implement a solution in Python
Compare your solution to the optimal solution

Build a Simple Python Calculator

Show steps

Building a project helps apply knowledge and skills

Show steps

Plan the calculator's functionality
Implement the calculator's logic in Python
Test and debug the calculator

Practice Binary Search Tree Problems

Show steps

Solving leetcode problems on binary search trees reinforces understanding

Show steps

Pick a leetcode problem on binary search tree
Implement the solution in Python
Compare your solution to the optimal solution

Practice Dynamic Programming Problems

Show steps

Dynamic programming problems help develop problem-solving skills

Show steps

Pick a leetcode problem on dynamic programming
Implement the solution in Python
Compare your solution to the optimal solution

Blog Post: Data Structures in Python

Show steps

Writing a blog post helps solidify knowledge

Show steps

Outline the key concepts of data structures in Python
Provide examples and code snippets
Edit and proofread
Publish the blog post

Career center

Learners who complete Python Data Structures & Algorithms: Ace Coding Interviews will develop knowledge and skills that may be useful to these careers:

Reading list

We haven't picked any books for this reading list yet.

Python Data Structures & Algorithms

Ace Coding Interviews

Here's a deal for you

What's inside

Learning objectives

Syllabus

Good to know

Save this course

Activities

Career center

Reading list

Share

Similar courses