Data Structures & Algorithms

Arrays

Arrays are fundamental data structures that store a fixed-size sequential collection of elements of the same type, enabling efficient random access.

Strings

Strings are sequences of characters used to represent text, supporting various operations like concatenation, searching, and manipulation.

Linked List

A Linked List is a linear data structure where elements (nodes) are connected via pointers, allowing efficient insertions and deletions.

Stack

A Stack is a linear data structure that follows the Last-In-First-Out (LIFO) principle, commonly used for function calls, expression evaluation, and undo operations.

Queue

A Queue is a linear data structure that follows the First-In-First-Out (FIFO) principle, essential for task scheduling, breadth-first search, and buffering.

Trees

Trees are hierarchical non-linear data structures consisting of nodes connected by edges, with a single root and no cycles.

Two Pointers

The Two Pointers technique uses two indices to traverse data structures, typically arrays or linked lists, for efficient solutions to search and optimization problems.

Sliding Window

Sliding Window is an algorithmic technique that maintains a subset of data within a fixed or variable size window for efficient computation on arrays or strings.

Hashing

Hashing uses hash functions to map data to fixed-size values, enabling fast data retrieval in hash tables and supporting integrity checks.

Heap

A Heap is a specialized tree-based data structure that satisfies the heap property, commonly used for priority queues and efficient sorting.

Trie

A Trie (prefix tree) is a tree-like data structure used for efficient retrieval of keys in a dataset of strings, ideal for autocomplete and spell checkers.

Recursion

Recursion is a programming technique where a function calls itself to solve smaller instances of the same problem, essential for tree traversal and divide-and-conquer algorithms.

Backtracking

Backtracking is an algorithmic technique for solving constraint satisfaction problems by building candidates incrementally and abandoning invalid paths.

BST

A Binary Search Tree (BST) is a binary tree where left subtree nodes are smaller and right subtree nodes are larger than the root, enabling efficient searching.

Segment Tree

A Segment Tree is a binary tree data structure for storing intervals or segments, allowing efficient range queries and updates.

Graphs

Graphs are non-linear data structures consisting of vertices (nodes) and edges, used to model relationships and networks like social connections or maps.

Union Find

Union Find (Disjoint Set Union) is a data structure for tracking a partition of elements into disjoint sets with efficient union and find operations.

Greedy

Greedy algorithms make the locally optimal choice at each stage, hoping to find a global optimum, and are used in optimization problems.

Dynamic Programming

Dynamic Programming solves complex problems by breaking them into overlapping subproblems and storing results to avoid redundant computations.

Bit Manipulation

Bit Manipulation involves direct operations on binary representations of numbers for efficient low-level optimizations and problem-solving.

Data Structures & Algorithms

Sorting

Complexity Analysis

Complexity Analysis evaluates the time and space efficiency of algorithms using Big O notation.

Math

Mathematics for competitive programming and interviews covers number theory, combinatorics, modular arithmetic, and other essential concepts.

Number Theory

Number Theory deals with properties of integers and is fundamental for solving many competitive programming problems.

Binary Search

Binary Search is an efficient algorithm for finding an element in a sorted array by repeatedly dividing the search interval in half.