PROWIDIT Education Academy

Blog
About us
How it works
FAQ

+994 77 333 38 36 Trial lesson Account

AZ RU EN

← Back to account

Switch courseAlgorithms and data structures course

AI for developers course104
Algorithms and data structures course129
Django & FastAPI course140
Docker & deployment course103
Full Stack Developer course270
Git & GitHub course103
HTML & CSS course154
JavaScript course169
Laravel course136
Provider Networks: MPLS, BGP and BNG81
Next.js course113
Node.js course123
PHP course144
Python course153
React course122
SQL & databases course122
TypeScript course112
Vue.js course111

Introduction and Algorithmic Thinking
What an Algorithm Is Free
Pseudocode and Flowcharts
Correctness and Loop Invariants
Testing Algorithms and Edge Cases
Measuring Time: timeit and perf_counter
Algorithm Complexity
Why We Measure Complexity
Big-O, Omega and Theta Notation
Growth Classes: from O(1) to O(n!)
Counting Rules: Loops, Nesting, Sequential Blocks
Best, Worst and Average Case
Space Complexity
Amortized Analysis
Complexity of Built-in Python Operations
Analyzing Recursion and the Master Theorem
Empirical Measurement vs Theory
Recursion and Problem-Solving Approaches
Recursion and the Call Stack
Memoization and lru_cache
Backtracking: Permutations and Subsets
Backtracking: N-Queens and Sudoku
Divide and Conquer
Greedy Algorithms
Dynamic Programming: Introduction
DP: The Knapsack Problem
DP: Longest Common Subsequence
DP: Edit Distance (Levenshtein)
Arrays and Strings as Data Structures
Arrays in Memory and the Dynamic Array
Two Pointers
Sliding Window
Prefix Sums
String Problems: Palindromes and Anagrams
String Parsing and Compression
Search Algorithms
Linear Search
Binary Search
Binary Search Pitfalls and bisect
Binary Search on the Answer
Interpolation and Jump Search
Substring Search: Naive and Rabin-Karp
The KMP Algorithm
Quickselect: Finding the k-th Element
Sorting Algorithms
Sorting Properties: Stability and In-Place
Bubble Sort
Selection Sort
Insertion Sort
Shell Sort
Merge Sort
Quick Sort
Heap Sort
Counting, Radix and Bucket Sort
Timsort, sorted and key
Comparing Sorting Algorithms with Benchmarks
Abstract Data Types
ADT vs Data Structure: Interface and Implementation
ADT Catalog: List, Stack, Queue, Deque, Priority Queue, Set, Map, Graph
Implementing ADTs in Python: ABC, Protocol and Contract Tests
Choosing the Right Data Structure
Linear Data Structures
Singly Linked List
Doubly and Circular Linked Lists
Stack Implementation
Stack Applications: Brackets, RPN, Undo
Queue: List, Linked List and Ring Buffer
Deque and Monotonic Queue
Priority Queue: Introduction
Linked List Problems
Hash-Based Structures
Hash Functions
Hash Table: Separate Chaining
Open Addressing
Load Factor and Rehashing
How dict and set Work in CPython
Bloom Filter
Designing an LRU Cache
Trees
Trees: Terminology and Traversals
Binary Tree: Implementation and Properties
Binary Search Tree: Insert and Search
BST: Deleting a Node
AVL Trees
Red-Black Trees: Overview
B-Trees and Databases
Heaps and heapq
Trie (Prefix Tree)
Segment Tree and Fenwick Tree
Tree Problems
Graphs
Graph Representations
Depth-First Search (DFS)
Breadth-First Search (BFS)
Dijkstra's Algorithm
Bellman-Ford and Floyd-Warshall
A* Search
Topological Sort
Union-Find (Disjoint Set Union)
Minimum Spanning Tree: Kruskal and Prim
Cycle Detection
Graph Applications: Maps, Dependencies, Social Networks
Object-Oriented Design
From OOP to Design: Cohesion and Coupling
UML: Class and Sequence Diagrams
SOLID: Single Responsibility Principle
SOLID: Open/Closed Principle
SOLID: Liskov Substitution Principle
SOLID: Interface Segregation Principle
SOLID: Dependency Inversion Principle
Composition vs Inheritance: Design Decisions
Creational Patterns: Factory Method and Abstract Factory
Builder Pattern
Singleton and Its Pitfalls
Adapter Pattern
Decorator Pattern
Facade Pattern
Strategy Pattern
Observer Pattern
Command Pattern
State Pattern
Iterator Pattern
Design Anti-Patterns
DRY, KISS, YAGNI and the Law of Demeter
Layers and Clean Architecture
OOD Case: Parking Lot
OOD Case: Elevator System
OOD Case: Library Management
OOD Case: ATM
Practice and Interviews
Problem-Solving Patterns
Practice: Easy Problems
Practice: Medium Problems
Practice: Hard Problems
How to Pass an Algorithmic Interview
Analyzing Your Own Solution
Common Mistakes in Algorithm Problems
Final Project
Project: Sorting Visualizer
Project: Route Planner on a Graph
Project: Trie Autocomplete
Project: Your Own dict and LRU Cache
Final Course Test

Algorithms and data structures course · Practice and Interviews

Practice: Medium Problems

🔒 This material is available with a subscription.

Create account Log in

← Previous lesson🔒 Practice: Easy Problems Next lesson →🔒 Practice: Hard Problems

PROWIDIT Education Academy

Online programming courses in Baku. Live lessons in Azerbaijani and Russian, 80% practice, mentor support and job placement assistance.

Front End

HTML & CSS JavaScript TypeScript React Next.js Vue.js

Back End

SQL (PostgreSQL, MySQL) PHP Laravel Python Algorithms Django & FastAPI Node.js Full Stack

Tools & AI

Git & GitHub Docker & deployment AI for developers

Useful links

Free trial lesson Mentoring & interviews For companies Blog FAQ

Contacts

+994 77 333 38 36 info@prowid.com Video lessons Send a request

© 2021–2026 Prowid — IT Education Academy. All rights reserved. Baku, Azerbaijan