Here’s a comprehensive list of Algorithms and Data Structures categorized for easy understanding:

---

🔹 Data Structures

Data structures help in organizing and storing data efficiently.

1. Linear Data Structures

• Array – Fixed-size collection of elements.
• Linked List – Dynamically allocated list (Singly, Doubly, Circular).
• Stack – LIFO (Last In, First Out).
• Queue – FIFO (First In, First Out).
  • Deque (Double-ended Queue) – Insertion/removal from both ends.
  • Priority Queue – Elements prioritized based on key.

2. Non-Linear Data Structures

• Trees
  • Binary Tree
  • Binary Search Tree (BST)
  • AVL Tree (Self-balancing BST)
  • B-Trees & B+ Trees (Used in databases)
  • Heap (Max-Heap, Min-Heap)
  • Trie (Prefix Tree)
  • Red-Black Tree
  • Splay Tree
• Graphs
  • Directed and Undirected Graphs
  • Weighted and Unweighted Graphs
  • Adjacency Matrix & Adjacency List
  • DAG (Directed Acyclic Graph)
• Hashing
  • Hash Table (Used in dictionaries, caching)
  • Hash Map (Key-Value Pair Storage)

---

🔹 Algorithms

Algorithms are step-by-step computational procedures for solving problems.

1. Searching Algorithms

• Linear Search (O(n))
• Binary Search (O(log n))
• Jump Search (O(√n))
• Exponential Search (O(log n))
• Ternary Search (Divides search range into three parts)

2. Sorting Algorithms

• Comparison-Based Sorting
  • Bubble Sort (O(n²))
  • Selection Sort (O(n²))
  • Insertion Sort (O(n²))
  • Merge Sort (O(n log n))
  • Quick Sort (O(n log n))
  • Heap Sort (O(n log n)
  • Shell Sort (Improvement over insertion sort)
  • Tim Sort (Hybrid of Merge & Insertion Sort)
• Non-Comparison-Based Sorting
  • Counting Sort (O(n + k))
  • Radix Sort (O(nk))
  • Bucket Sort (O(n))

3. Graph Algorithms

• Breadth-First Search (BFS) – Level-order traversal.
• Depth-First Search (DFS) – Recursive or stack-based traversal.
• Dijkstra’s Algorithm – Shortest path (Single source).
• Bellman-Ford Algorithm – Handles negative weights.
• Floyd-Warshall Algorithm – All-pairs shortest paths.
• Kruskal’s Algorithm – Minimum Spanning Tree (MST).
• Prim’s Algorithm – MST using priority queue.
• A Algorithm* – Heuristic search for shortest path.

4. Dynamic Programming (DP) Algorithms

• Fibonacci Series (Memoization & Tabulation)
• Knapsack Problem (0/1 Knapsack, Fractional Knapsack)
• Longest Common Subsequence (LCS)
• Longest Increasing Subsequence (LIS)
• Matrix Chain Multiplication
• Coin Change Problem
• Edit Distance (Levenshtein Distance)

5. Greedy Algorithms

• Huffman Coding (Data compression)
• Activity Selection Problem
• Job Sequencing Problem
• Kruskal’s Algorithm (for MST)
• Prim’s Algorithm (for MST)
• Dijkstra’s Algorithm (for shortest path)

6. String Algorithms

• Naïve Pattern Matching
• Knuth-Morris-Pratt (KMP) Algorithm
• Rabin-Karp Algorithm
• Z-Algorithm
• Suffix Array and Suffix Tree
• Aho-Corasick Algorithm

7. Bit Manipulation Algorithms

• Bitwise AND, OR, XOR operations
• Counting set bits (Brian Kernighan’s Algorithm)
• Checking if a number is a power of two
• Swapping two numbers without extra space

8. Divide and Conquer Algorithms

• Merge Sort
• Quick Sort
• Binary Search
• Strassen’s Matrix Multiplication
• Closest Pair of Points Problem

9. Backtracking Algorithms

• N-Queens Problem
• Sudoku Solver
• Maze Solving (Rat in a Maze)
• Subset Sum Problem
• Hamiltonian Cycle

10. Computational Geometry Algorithms

• Convex Hull (Graham’s Scan, Jarvis March)
• Line Intersection
• Point in Polygon Test
• Closest Pair of Points Algorithm

11. Number Theory Algorithms

• Greatest Common Divisor (GCD) – Euclidean Algorithm
• Sieve of Eratosthenes (Prime numbers)
• Modular Exponentiation
• Fermat’s Little Theorem
• Chinese Remainder Theorem
• Miller-Rabin Primality Test

12. Game Theory Algorithms

• Minimax Algorithm
• Alpha-Beta Pruning
• Nim Game Strategy
• Sprague-Grundy Theorem

---

This is a high-level overview of the most common data structures and algorithms used in computer science and competitive programming.