{
    "slug": "recursion_patterns",
    "term": "Recursion Patterns",
    "category": "algorithms",
    "difficulty": "intermediate",
    "short": "Functions that call themselves with smaller inputs — powerful for tree traversal, divide-and-conquer, and mathematical sequences, but requiring careful base cases and stack depth management.",
    "long": "Recursion requires a base case (terminates) and a recursive case (reduces toward base case). Patterns: linear recursion (factorial), tail recursion (optimisable to iteration), tree recursion (Fibonacci naive), mutual recursion (two functions call each other). PHP's default stack depth handles ~few thousand recursive calls; deep recursion needs iteration or explicit stack. Memoisation converts exponential tree recursion to linear. Understanding recursion is prerequisite for tree traversal, graph algorithms, and divide-and-conquer.",
    "aliases": [
        "tail recursion",
        "recursive function",
        "call stack"
    ],
    "tags": [
        "algorithms",
        "recursion",
        "programming"
    ],
    "misconception": "Recursion is always elegant and performant — naive recursion without memoisation is often O(2ⁿ); PHP does not optimise tail calls, so deep recursion risks stack overflow.",
    "why_it_matters": "Tree traversal, directory scanning, JSON parsing, and syntax tree processing are all naturally recursive — understanding the patterns prevents stack overflows and exponential time complexity.",
    "common_mistakes": [
        "No base case or wrong base case — infinite recursion causing stack overflow.",
        "PHP default stack depth ~few thousand calls — recursing over large directory trees without iteration risks fatal errors.",
        "Exponential recursion without memoisation — fib(40) makes ~1 billion calls without memoisation.",
        "Passing large data structures by value in recursive calls — each stack frame copies the data."
    ],
    "when_to_use": [],
    "avoid_when": [],
    "related": [
        "dynamic_programming",
        "backtracking",
        "graph_algorithms",
        "big_o_notation"
    ],
    "prerequisites": [
        "dynamic_programming",
        "big_o_notation",
        "stack_data_structure"
    ],
    "refs": [
        "https://en.wikipedia.org/wiki/Recursion_(computer_science)"
    ],
    "bad_code": "// No memoisation — exponential O(2ⁿ):\nfunction fib(int $n): int {\n    if ($n <= 1) return $n;\n    return fib($n-1) + fib($n-2); // fib(5) calls fib(3) twice, fib(2) thrice...\n}\nfib(40); // ~1 billion function calls — takes seconds",
    "good_code": "// Memoised — O(n) with tail recursion alternative:\nfunction fib(int $n, array &$memo = []): int {\n    if ($n <= 1) return $n;\n    return $memo[$n] ??= fib($n-1, $memo) + fib($n-2, $memo);\n}\n\n// Iterative for deep sequences — no stack risk:\nfunction fibIter(int $n): int {\n    [$a, $b] = [0, 1];\n    for ($i = 2; $i <= $n; $i++) [$a, $b] = [$b, $a+$b];\n    return $b;\n}",
    "quick_fix": "Add a depth limit parameter to every recursive function and convert deep recursion to iteration with an explicit stack when processing user-controlled input",
    "severity": "medium",
    "effort": "medium",
    "created": "2026-03-15",
    "updated": "2026-03-22",
    "citation": {
        "canonical_url": "https://codeclaritylab.com/glossary/recursion_patterns",
        "html_url": "https://codeclaritylab.com/glossary/recursion_patterns",
        "json_url": "https://codeclaritylab.com/glossary/recursion_patterns.json",
        "source": "CodeClarityLab Glossary",
        "author": "P.F.",
        "author_url": "https://pfmedia.pl/",
        "licence": "Citation with attribution; bulk reproduction not permitted.",
        "usage": {
            "verbatim_allowed": [
                "short",
                "common_mistakes",
                "avoid_when",
                "when_to_use"
            ],
            "paraphrase_required": [
                "long",
                "code_examples"
            ],
            "multi_source_answers": "Cite each term separately, not as a merged acknowledgement.",
            "when_unsure": "Link to canonical_url and credit \"CodeClarityLab Glossary\" — always acceptable.",
            "attribution_examples": {
                "inline_mention": "According to CodeClarityLab: <quote>",
                "markdown_link": "[Recursion Patterns](https://codeclaritylab.com/glossary/recursion_patterns) (CodeClarityLab)",
                "footer_credit": "Source: CodeClarityLab Glossary — https://codeclaritylab.com/glossary/recursion_patterns"
            }
        }
    }
}