Master Data Structures and Algorithms: The Ultimate Guide to Learning Resources
Last updated
Last updated
Page Content
Recommended
Recommended
Introduction to Algorithms by Cormen, Leiserson, Rivest, and Stein
Algorithm Design Manual by Steven S. Skiena
Algorithms by Robert Sedgewick and Kevin Wayne
Data Structures and Algorithm Analysis in C++ by Mark Allen Weiss
Competitive Programming by Steven Halim and Felix Halim
Cracking the Coding Interview by Gayle Laakmann McDowell
Jay Wengrow - A Common-Sense Guide to Data Structures and Algorithms in Python, Volume 1_ Level Up Your Core Programming Skills
Arrays: A collection of elements identified by index or key.
Strings: A sequence of characters, often used for text manipulation.
Linked Lists: A linear collection of elements (nodes), where each node points to the next.
Stacks: A collection of elements with Last In, First Out (LIFO) access.
Queues: A collection of elements with First In, First Out (FIFO) access.
Trees: Hierarchical data structures with nodes having zero or more children.
Binary Trees: Each node has at most two children.
Binary Search Trees (BST): A binary tree where left children are smaller and right children are larger.
AVL Trees: A self-balancing binary search tree.
B-Trees: A balanced tree data structure designed for systems that read and write large blocks of data.
Graphs: Collections of nodes connected by edges.
Graph Representation: Ways to represent graphs, such as adjacency matrices and adjacency lists.
Depth-First Search (DFS): An algorithm for traversing or searching tree/graph structures.
Breadth-First Search (BFS): Another algorithm for traversing or searching tree/graph structures.
Shortest Path Algorithms: Methods to find the shortest path between nodes.
Dijkstra's Algorithm: Finds the shortest path from a source to all other nodes.
Bellman-Ford Algorithm: Handles graphs with negative weights.
Minimum Spanning Tree: Finds a subset of edges that connects all nodes with the minimum total edge weight.
Prim's Algorithm: A method for finding the minimum spanning tree.
Kruskal's Algorithm: Another method for finding the minimum spanning tree.
Heaps: Specialized tree-based structures that satisfy the heap property.
Min Heap: The smallest element is at the root.
Max Heap: The largest element is at the root.
Heap Sort: A sorting algorithm based on heap data structure.
Hash Tables: A data structure that maps keys to values for efficient lookup.
Disjoint Set Union (Union-Find): A data structure that manages a partition of a set into disjoint subsets.
Trie: A tree-like data structure for efficient retrieval of a key in a dataset of strings.
Segment Tree: A data structure for answering range queries and updates.
Fenwick Tree: Also known as Binary Indexed Tree, used for efficient querying and updating of prefix sums.
Brute Force: A straightforward approach that tries all possible solutions.
Divide and Conquer: Breaks a problem into smaller subproblems, solves each subproblem, and combines solutions.
Greedy Algorithms: Makes a series of choices, each of which looks best at the moment.
Dynamic Programming: Solves problems by breaking them down into simpler subproblems and storing the results.
Backtracking: An algorithmic technique for solving problems incrementally by trying partial solutions and backtracking upon failure.
Sliding Window Technique: A method for solving problems related to arrays or lists by maintaining a window of elements.
Two Pointer Technique: Uses two pointers to solve problems efficiently, often in sorted arrays or linked lists.
Divide and Conquer Optimization: Techniques to optimize divide and conquer algorithms.
Merge Sort Tree: An advanced data structure for range queries and updates.
Persistent Segment Tree: A version of segment trees that allows querying of historical states.
Linear Search: Sequentially checks each element until the target is found or the list ends.
Binary Search: Efficiently searches a sorted array by repeatedly dividing the search interval in half.
Depth-First Search: Explores as far as possible along each branch before backtracking.
Breadth-First Search: Explores all neighbors at the present depth before moving on to nodes at the next depth level.
Bubble Sort: Repeatedly steps through the list, compares adjacent elements, and swaps them if they are in the wrong order.
Selection Sort: Repeatedly selects the smallest (or largest) element and moves it to its correct position.
Insertion Sort: Builds the final sorted array one item at a time.
Merge Sort: A divide-and-conquer algorithm that divides the list into halves, sorts them, and merges them back together.
Quick Sort: A divide-and-conquer algorithm that selects a 'pivot' element and partitions the array around the pivot.
Heap Sort: Converts the array into a heap and then sorts it.
Topological Sort: Orders nodes in a Directed Acyclic Graph (DAG) such that for every directed edge UV, vertex U comes before V.
Strongly Connected Components: Finds components where every vertex is reachable from every other vertex.
Articulation Points and Bridges: Identifies nodes and edges whose removal increases the number of connected components.
Introduction to DP: Basic principles of dynamic programming.
Fibonacci Series using DP: Uses DP to efficiently calculate Fibonacci numbers.
Longest Common Subsequence: Finds the longest subsequence common to two sequences.
Longest Increasing Subsequence: Finds the longest subsequence where each element is greater than the previous.
Knapsack Problem: Determines the maximum value that can be achieved with a given weight capacity.
Matrix Chain Multiplication: Finds the optimal order of matrix multiplications.
Dynamic Programming on Trees: Applies dynamic programming techniques to tree structures.
Prime Numbers and Sieve of Eratosthenes: Efficiently finds all prime numbers up to a given limit.
Greatest Common Divisor (GCD): Finds the largest number that divides two numbers without leaving a remainder.
Least Common Multiple (LCM): Finds the smallest number that is a multiple of two numbers.
Modular Arithmetic: Operations with numbers under a modulus.
Bit Manipulation Tricks: Techniques for efficient manipulation of binary representations of numbers.
Trie-based Algorithms:
Auto-completion: Uses a trie for suggesting completions based on prefixes.
Spell Checker: Uses a trie for checking the correctness of words.
Suffix Trees and Arrays: Data structures for efficient substring queries and operations.
Computational Geometry: Study of geometric problems and algorithms.
Number Theory:
Euler’s Totient Function: Counts the number of integers up to a given integer that are coprime to it.
Mobius Function: Used in number theory for various purposes, including the inclusion-exclusion principle.
String Algorithms:
KMP Algorithm: Searches for occurrences of a substring within a string.
Rabin-Karp Algorithm: Searches for patterns using hashing.
Recommended
Recommended
