Here is a list of 25 data structures, 25 algorithms, 25 data types, and 25 types of programming. This is here as a general look up.

25 Data Structures

  • Array – Basic ordered list of elements, useful for lists and collections.
  • Object/Associative Array – Key-value pairs, important for structured data (PHP and JSON).
  • Queue – First-In-First-Out structure, used in background processing.
  • Stack – Last-In-First-Out structure, often used in function calls and form handling.
  • Hash Table – Fast lookup structure, used for sessions and caching.
  • Set – Collection of unique elements, helpful for removing duplicates.
  • Tree – Hierarchical data structure, useful for categories, menus, and file systems.
  • Binary Search Tree (BST) – A tree that allows efficient searching, insertion, and deletion.
  • Heap – Binary tree for priority-based task handling (e.g., task scheduling).
  • Graph – Nodes and edges, used in relationships (e.g., social networks).
  • Trie – Tree structure used for efficient search, especially in autocomplete features.
  • Doubly Linked List – Linked list where each node points to both next and previous, useful for bidirectional navigation.
  • Linked List – Each element points to the next, used in UIs for navigation.
  • Deque – Double-ended queue, allows insertion/removal from both ends, useful in certain task management systems.
  • Priority Queue – Queue with priority-based task handling, useful in job scheduling.
  • Circular Queue – A queue that wraps around when the end is reached, useful for memory management.
  • Matrix – A 2D array, useful in handling grid-based layouts or spatial data.
  • Adjacency List (for Graphs) – Representation of a graph using lists, useful in representing networks.
  • Adjacency Matrix (for Graphs) – A 2D matrix used to represent edges between nodes in a graph.
  • Bloom Filter – Probabilistic data structure for checking if an element is present in a set, used in caching.
  • Sparse Array – An array where most elements are empty or zero, used to save memory.
  • Segment Tree – A tree for storing intervals or segments, useful in range queries (like time range queries).
  • B-Tree – A self-balancing tree structure, used in databases for indexing.
  • Red-Black Tree – A balanced binary search tree that ensures no path is twice as long as another, used in ordered data structures.
  • Ternary Search Tree – A type of tree used for efficient searching and sorting of strings.

25 Algorithms

  • QuickSort – Sorting algorithm, quick and efficient for large datasets.
  • Merge Sort – Sorting algorithm, great for stable sorting of large datasets.
  • Binary Search – Search algorithm for quickly finding elements in a sorted array.
  • Hashing – Used for fast data retrieval, crucial for handling user sessions or caches.
  • CRUD Operations – Core database actions (Create, Read, Update, Delete).
  • Pagination – Divides large datasets into pages for efficient display and management.
  • Knuth-Morris-Pratt (KMP) – A string matching algorithm, useful for searching substrings.
  • Dijkstra's Algorithm – Finds the shortest path in graphs, useful for route-finding systems.
  • Depth-First Search (DFS) – Explores a graph or tree deeply before moving to the next node, useful in traversing hierarchical data.
  • Breadth-First Search (BFS) – Explores a graph or tree level by level, useful for shallow search.
  • Dynamic Programming – Breaks problems down into simpler subproblems (e.g., caching results).
  • A* Algorithm – A pathfinding algorithm, efficient in route planning and graph traversal.
  • QuickSelect – A selection algorithm to find the k-th smallest element, useful in ranking systems.
  • Floyd-Warshall Algorithm – Finds shortest paths between all pairs of nodes in a graph.
  • Greedy Algorithm – Makes local optimum choices at each step, useful in scheduling tasks.
  • Insertion Sort – Simple sorting algorithm, efficient for small or nearly sorted datasets.
  • Bubble Sort – Basic sorting algorithm, useful for small or simple datasets.
  • Selection Sort – Simple algorithm for finding the smallest element in each iteration and placing it in order.
  • Heap Sort – Efficient sorting algorithm that uses a heap data structure, useful for priority queues.
  • Counting Sort – Sorting algorithm for small range integers, faster than comparison-based sorts in specific cases.
  • Radix Sort – Non-comparative sorting algorithm that processes digits or characters, good for sorting long integers or strings.
  • Bellman-Ford Algorithm – Finds shortest paths from a single source in graphs, handles negative weights (unlike Dijkstra's).
  • Topological Sort – Sorts a directed graph, useful for dependency resolution.
  • Backtracking Algorithm – Tries to solve problems incrementally and backtracks when necessary, useful in solving constraint satisfaction problems (e.g., form validation or captcha systems).
  • Segment Tree Algorithm – Used for range queries on arrays, useful in querying large datasets.

25 Data Types (Across Different Languages/Platforms)

  • Integer – Whole numbers (e.g., 42 in PHP, Python, C).
  • Float/Double – Decimal numbers (e.g., 3.14 in PHP, Python, C).
  • String – Sequence of characters (e.g., "Hello World" in PHP, Python).
  • Boolean – True/False values (e.g., True or False in Python, PHP).
  • Array – Ordered collection of elements (e.g., [1, 2, 3] in Python, PHP).
  • Object – A collection of key-value pairs (e.g., JSON in JavaScript, Classes in Python, PHP).
  • Null/Nil – Represents no value (e.g., NULL in PHP, None in Python).
  • Pointer – A memory address (C, C++ specific).
  • Byte – 8 bits of data, often used in low-level programming (C, Assembly).
  • Tuple – Immutable ordered collection (e.g., (1, 2) in Python).
  • List – Dynamic array (e.g., [] in Python).
  • Dictionary/HashMap – Key-value pair structure (e.g., Python's dict).
  • Set – Unordered collection of unique elements (e.g., set() in Python).
  • Struct – A composite data type (used in C for grouping data).
  • Char – A single character (e.g., 'A' in C).
  • Enum – A set of named values (used in C, PHP 8.1+, Python).
  • ByteArray – Mutable sequence of bytes (Python, C).
  • Complex Number – Numbers with real and imaginary parts (e.g., 1 + 2j in Python).
  • Function/Callable – A block of code that can be invoked (functions in Python, PHP, C).
  • Lambda/Anonymous Function – Short function definitions (e.g., lambda in Python).
  • Class/Instance – Blueprint of objects (OOP concept in PHP, Python, C++).
  • Coroutine – Functions that can pause execution and resume (Python async).
  • Union – A data structure where all members share the same memory (C).
  • Decimal – Arbitrary-precision decimal numbers (used in Python for financial calculations).
  • Record – Immutable data structure for storing related data (like structs, found in many languages).

25 Types of Programming

  • Imperative Programming – Explicitly specifies how the computation proceeds (e.g., C, Python)
  • Declarative Programming – Specifies what to do, not how (e.g., SQL, HTML, CSS)
  • Functional Programming – Emphasizes pure functions and immutability (e.g., Haskell, Lisp, Python)
  • Object-Oriented Programming (OOP) – Organizes software into objects (e.g., C++, Python, PHP)
  • Procedural Programming – A type of imperative programming that uses procedures/functions (e.g., C, PHP)
  • Event-Driven Programming – Execution is driven by events (e.g., JavaScript with DOM events, UE4 Blueprints)
  • Parallel Programming – Concurrent execution of tasks (e.g., threading in C, Python)
  • Concurrent Programming – Dealing with multiple tasks at the same time (e.g., Go, Python with async)
  • Monadic Programming – Composing functions with monads to handle side effects (e.g., Haskell)
  • Scripting – Lightweight programming for automating tasks (e.g., Python, PHP, Bash)
  • Reactive Programming – Asynchronous data streams (e.g., RxJS in JavaScript)
  • Logic Programming – Based on formal logic (e.g., Prolog)
  • Metaprogramming – Writing programs that manipulate other programs (e.g., macros in C, Python decorators)
  • Distributed Programming – Programs that run across multiple machines (e.g., Hadoop, Apache Spark)
  • Dataflow Programming – Data propagates through nodes of computation (e.g., LabVIEW, TensorFlow)
  • Machine Learning Programming – Building algorithms that learn (e.g., PyTorch, TensorFlow)
  • Domain-Specific Languages (DSL) – Languages focused on a specific area (e.g., SQL for databases)
  • Constraint Programming – Solving problems by stating constraints (e.g., in AI and operations research)
  • Component-Based Programming – Building reusable software components (e.g., React in JavaScript)
  • Aspect-Oriented Programming – Separating cross-cutting concerns (e.g., logging, security in Java)
  • Blueprint Scripting (UE4) – Visual programming paradigm for Unreal Engine
  • Rule-Based Programming – Applies rules to a knowledge base (e.g., CLIPS, expert systems)
  • Symbolic Programming – Manipulating symbols rather than numeric data (e.g., in AI, Prolog)
  • Neural Network Programming – Building layers of neurons for deep learning (e.g., PyTorch, TensorFlow)
  • Actor Model – Treats "actors" as the universal primitives of concurrent computation (e.g., Erlang, Akka in Scala)