CodeOrbitPro

O(n log n)

Graph

P vs NP

Recursion

📐 Algorithms & Complexity

Master the Heart of Computer Science — from Sorting to P vs NP

Explore 40+ algorithmic concepts, complexity classes, and optimization techniques. From fundamental data structures to advanced computational theories — sharpen your problem-solving edge.

40+

Algorithmic Topics & Complexity Classes

Bubble Sort

Simple comparison-based sorting. Repeatedly steps through list, swaps adjacent elements.

O(n²) Time | O(1) Space

Merge Sort

Divide-and-conquer, stable sort with guaranteed O(n log n).

O(n log n) Time | O(n) Space

Quick Sort

In-place divide-and-conquer, widely used in practice.

O(n log n) avg | O(n²) worst

Insertion Sort

Builds final sorted array one item at a time. Efficient for small datasets.

O(n²) Time | O(1) Space

Dijkstra's Algorithm

Shortest path in weighted graphs (non-negative weights).

BFS & DFS

Fundamental graph traversal: Breadth-first and Depth-first search.

Bellman-Ford

Shortest path with negative weights, detects negative cycles.

Floyd-Warshall

All-pairs shortest path using dynamic programming.

P vs NP

The biggest open problem in CS: does P = NP?

Millennium Problem

Big O Notation

Asymptotic analysis of algorithm efficiency.

O(1), O(log n), O(n), O(n²)

NP-Complete

Hardest problems in NP: SAT, TSP, Knapsack.

Reduction-based

Arrays & Linked Lists

Foundational linear data structures.

Access O(1) vs O(n)

Data Structures

Hash Tables

O(1) average-case lookup, collision resolution.

O(1) avg | O(n) worst

Data Structures

Binary Search Trees

Hierarchical structure with O(log n) operations.

Data Structures

AVL & Red-Black Trees

Self-balancing BSTs for guaranteed log-time ops.

O(log n) guaranteed

Data Structures

Dynamic Programming

Optimal substructure + overlapping subproblems.

Memoization / Tabulation

Knapsack Problem

Classic DP: 0/1 and fractional knapsack.

O(nW) pseudo-polynomial

Edit Distance

Levenshtein distance, string alignment.

Binary Search

Divide-and-conquer search on sorted arrays.

Backtracking

N-Queens, Sudoku, combinatorial search.

Exponential worst-case

KMP Algorithm

Efficient pattern matching in O(n+m) time.

MST: Prim / Kruskal

Minimum Spanning Tree algorithms for graphs.

Max Flow / Min Cut

Ford-Fulkerson, Edmonds-Karp, network flow.

O(VE²) or better

Computational Geometry

Convex hull, line sweep, polygon triangulation.

Heaps & Priority Queues

Efficient extract-min/max, heap sort.

O(log n) insertion/extract

Data Structures

Trie & Suffix Tree

Efficient string storage and prefix queries.

O(L) operations

Linear Search

Sequential element search in unsorted data.

Topological Sort

Linear ordering of DAG vertices (Kahn / DFS).

Strongly Connected Components

Kosaraju / Tarjan's algorithm for SCC.

Sliding Window

Optimized subarray/substring queries.

📊 Algorithm Mastery Path

🚀 Beginner

Fundamental sorts, simple searches, basic data structures.

⭐ Intermediate

Graph traversals, divide & conquer, dynamic programming basics.

👑 Advanced

Complex graph algos, NP-completeness, string matching.

🏆 Expert

P vs NP, advanced flow, computational geometry, reductions.

⚡ Sharpen Your Algorithmic Thinking

Join interactive challenges and visualize complex algorithms in action.

Back to Home Leaderboard