Contoh 1: Faktorial Rekursif

Faktorial adalah contoh klasik rekursif. n! = n × (n-1)!

function faktorial(n) {
    // Base case
    if (n <= 1) {
        return 1;
    }
    // Recursive case
    return n * faktorial(n - 1);
}

// Contoh eksekusi faktorial(5):
// 5 * faktorial(4)
// 5 * 4 * faktorial(3)
// 5 * 4 * 3 * faktorial(2)
// 5 * 4 * 3 * 2 * faktorial(1)
// 5 * 4 * 3 * 2 * 1 = 120

console.log(faktorial(5)); // Output: 120

Contoh 2: Fibonacci Rekursif

Deret Fibonacci: 0, 1, 1, 2, 3, 5, 8, 13, 21, ... (setiap angka adalah jumlah dua angka sebelumnya)

function fibonacci(n) {
    // Base cases
    if (n <= 0) return 0;
    if (n === 1) return 1;
    
    // Recursive case
    return fibonacci(n - 1) + fibonacci(n - 2);
}

// Contoh eksekusi fibonacci(6):
// fibonacci(6) = fibonacci(5) + fibonacci(4)
// fibonacci(5) = fibonacci(4) + fibonacci(3)
// ... dan seterusnya sampai base case
// fibonacci(6) = 8

console.log(fibonacci(6)); // Output: 8

Contoh 3: Binary Search Rekursif

Pencarian dalam array terurut dengan kompleksitas O(log n)

function binarySearch(arr, target, left = 0, right = arr.length - 1) {
    // Base case: elemen tidak ditemukan
    if (left > right) {
        return -1;
    }
    
    const mid = Math.floor((left + right) / 2);
    
    // Base case: elemen ditemukan
    if (arr[mid] === target) {
        return mid;
    }
    
    // Recursive cases
    if (arr[mid] > target) {
        return binarySearch(arr, target, left, mid - 1);
    } else {
        return binarySearch(arr, target, mid + 1, right);
    }
}

// Contoh penggunaan
const sortedArray = [1, 3, 5, 7, 9, 11, 13, 15];
console.log(binarySearch(sortedArray, 7)); // Output: 3
console.log(binarySearch(sortedArray, 10)); // Output: -1 (tidak ditemukan)

Contoh 4: Tree Traversal Rekursif

Traversal pohon biner adalah aplikasi natural dari rekursif

class TreeNode {
    constructor(value) {
        this.value = value;
        this.left = null;
        this.right = null;
    }
}

// In-order traversal: Left -> Root -> Right
function inOrderTraversal(node) {
    if (node === null) return; // Base case
    
    inOrderTraversal(node.left);  // Recursive case: traverse left
    console.log(node.value);      // Process root
    inOrderTraversal(node.right); // Recursive case: traverse right
}

// Contoh penggunaan
const root = new TreeNode(1);
root.left = new TreeNode(2);
root.right = new TreeNode(3);
root.left.left = new TreeNode(4);
root.left.right = new TreeNode(5);

// Output: 4, 2, 5, 1, 3
inOrderTraversal(root);

Contah Memoization untuk Fibonacci

const memo = {};

function fibonacciMemo(n) {
    // Cek apakah sudah dihitung
    if (n in memo) return memo[n];
    
    // Base cases
    if (n <= 0) return 0;
    if (n === 1) return 1;
    
    // Recursive case dengan memoization
    memo[n] = fibonacciMemo(n - 1) + fibonacciMemo(n - 2);
    return memo[n];
}

// Kompleksitas waktu: O(n) (bukan O(2^n) seperti versi naif)
console.log(fibonacciMemo(50)); // Output: 12586269025

Contoh 1: Faktorial Iteratif dengan For Loop

function faktorialIteratif(n) {
    let hasil = 1;
    for (let i = 2; i <= n; i++) {
        hasil *= i; // hasil = hasil * i
    }
    return hasil;
}

// Eksekusi faktorialIteratif(5):
// i=2: hasil = 1 * 2 = 2
// i=3: hasil = 2 * 3 = 6
// i=4: hasil = 6 * 4 = 24
// i=5: hasil = 24 * 5 = 120

console.log(faktorialIteratif(5)); // Output: 120

Contoh 2: Fibonacci Iteratif dengan While Loop

function fibonacciIteratif(n) {
    if (n <= 0) return 0;
    if (n === 1) return 1;
    
    let prev = 0;      // F(0)
    let curr = 1;      // F(1)
    let next;
    let i = 2;
    
    while (i <= n) {
        next = prev + curr;  // Calculate next Fibonacci number
        prev = curr;         // Update previous
        curr = next;         // Update current
        i++;
    }
    
    return curr;
}

// Kompleksitas waktu: O(n), Kompleksitas ruang: O(1)
console.log(fibonacciIteratif(10)); // Output: 55

Contoh 3: Linear Search Iteratif

Mencari elemen dalam array satu per satu

function linearSearch(arr, target) {
    for (let i = 0; i < arr.length; i++) {
        if (arr[i] === target) {
            return i;  // Return index jika ditemukan
        }
    }
    return -1;  // Return -1 jika tidak ditemukan
}

// Contoh penggunaan
const numbers = [10, 20, 30, 40, 50];
console.log(linearSearch(numbers, 30)); // Output: 2
console.log(linearSearch(numbers, 35)); // Output: -1

Contoh 4: Bubble Sort Iteratif

Algoritma sorting sederhana dengan nested loops

function bubbleSort(arr) {
    let n = arr.length;
    let swapped;
    
    do {
        swapped = false;
        
        for (let i = 0; i < n - 1; i++) {
            if (arr[i] > arr[i + 1]) {
                // Swap elements
                let temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
                swapped = true;
            }
        }
        
        n--;  // Reduce range karena elemen terbesar sudah di posisi benar
    } while (swapped);
    
    return arr;
}

// Contoh penggunaan
const unsorted = [64, 34, 25, 12, 22, 11, 90];
console.log(bubbleSort(unsorted)); // Output: [11, 12, 22, 25, 34, 64, 90]

Contoh 5: Array Processing dengan Map dan Filter

Iterative methods untuk transformasi dan filtering array

// Map: Transform setiap elemen
const numbers = [1, 2, 3, 4, 5];
const doubled = numbers.map(num => num * 2);
console.log(doubled); // Output: [2, 4, 6, 8, 10]

// Filter: Pilih elemen yang memenuhi kondisi
const even = numbers.filter(num => num % 2 === 0);
console.log(even); // Output: [2, 4]

// Reduce: Combine semua elemen
const sum = numbers.reduce((acc, num) => acc + num, 0);
console.log(sum); // Output: 15

// ForEach: Eksekusi fungsi untuk setiap elemen
numbers.forEach(num => console.log(num * 3));
// Output: 3, 6, 9, 12, 15

Contah Konversi Rekursif ke Iteratif (Accumulator Pattern)

// Rekursif (tidak tail-recursive)
function sumRecursive(arr, index = 0) {
    if (index >= arr.length) return 0;
    return arr[index] + sumRecursive(arr, index + 1);
}

// Iteratif dengan accumulator
function sumIterative(arr) {
    let accumulator = 0;
    for (let i = 0; i < arr.length; i++) {
        accumulator += arr[i];
    }
    return accumulator;
}

// Rekursif tail-recursive (bisa dioptimasi)
function sumTailRecursive(arr, index = 0, accumulator = 0) {
    if (index >= arr.length) return accumulator;
    return sumTailRecursive(arr, index + 1, accumulator + arr[index]);
}

// Semua menghasilkan hasil yang sama
const numbers = [1, 2, 3, 4, 5];
console.log(sumRecursive(numbers));      // Output: 15
console.log(sumIterative(numbers));      // Output: 15
console.log(sumTailRecursive(numbers));  // Output: 15

Contoh 1: Nearest Neighbor untuk Traveling Salesman

Algoritma greedy yang memilih kota terdekat berikutnya - contoh classic heuristic

// Algoritma Nearest Neighbor untuk Traveling Salesman Problem
function nearestNeighborTSP(cities, startCity) {
    let unvisited = cities.filter(c => c !== startCity);
    let path = [startCity];
    let current = startCity;
    let totalDistance = 0;
    
    while (unvisited.length > 0) {
        // Heuristic: Pilih kota terdekat saat ini
        let nearest = unvisited.reduce((closest, city) => {
            return distance(current, city) < distance(current, closest) 
                ? city : closest;
        });
        
        totalDistance += distance(current, nearest);
        path.push(nearest);
        unvisited = unvisited.filter(c => c !== nearest);
        current = nearest;
    }
    
    // Kembali ke kota awal
    totalDistance += distance(current, startCity);
    path.push(startCity);
    
    return { path, totalDistance };
}

// Fungsi helper untuk menghitung jarak Euclidean
function distance(city1, city2) {
    return Math.sqrt(
        Math.pow(city2.x - city1.x, 2) + 
        Math.pow(city2.y - city1.y, 2)
    );
}

// Contoh penggunaan
const cities = [
    { name: 'A', x: 0, y: 0 },
    { name: 'B', x: 1, y: 2 },
    { name: 'C', x: 3, y: 1 },
    { name: 'D', x: 2, y: 3 }
];

const result = nearestNeighborTSP(cities, cities[0]);
console.log("Path:", result.path.map(c => c.name));
console.log("Total Distance:", result.totalDistance);

Contoh 2: A* Algorithm untuk Pathfinding

Algoritma pencarian jalan yang menggunakan heuristic untuk mempercepat pencarian

// A* Algorithm dengan heuristic function
function aStar(graph, start, goal, heuristic) {
    let openSet = [start];
    let cameFrom = {};
    let gScore = {}; // Cost dari start ke node
    let fScore = {}; // gScore + heuristic
    
    gScore[start] = 0;
    fScore[start] = heuristic(start, goal);
    
    while (openSet.length > 0) {
        // Pilih node dengan fScore terendah
        let current = openSet.reduce((min, node) => 
            (fScore[node] < fScore[min] ? node : min)
        );
        
        if (current === goal) {
            return reconstructPath(cameFrom, current);
        }
        
        openSet = openSet.filter(node => node !== current);
        
        // Explore neighbors
        for (let neighbor of graph[current]) {
            let tentativeGScore = gScore[current] + neighbor.cost;
            
            if (tentativeGScore < (gScore[neighbor.node] || Infinity)) {
                cameFrom[neighbor.node] = current;
                gScore[neighbor.node] = tentativeGScore;
                fScore[neighbor.node] = tentativeGScore + heuristic(neighbor.node, goal);
                
                if (!openSet.includes(neighbor.node)) {
                    openSet.push(neighbor.node);
                }
            }
        }
    }
    
    return null; // No path found
}

// Contoh heuristic: Manhattan distance untuk grid
function manhattanDistance(node1, node2) {
    return Math.abs(node1.x - node2.x) + Math.abs(node1.y - node2.y);
}

Contoh 3: Hill Climbing untuk Optimization

Algoritma optimization sederhana yang bergerak menuju arah "naik"

// Hill Climbing untuk mencari maximum function
function hillClimbing(initialState, getStateValue, getNeighbors, maxIterations = 1000) {
    let currentState = initialState;
    let currentValue = getStateValue(currentState);
    
    for (let i = 0; i < maxIterations; i++) {
        let neighbors = getNeighbors(currentState);
        let bestNeighbor = null;
        let bestValue = currentValue;
        
        // Cari neighbor dengan nilai terbaik
        for (let neighbor of neighbors) {
            let neighborValue = getStateValue(neighbor);
            if (neighborValue > bestValue) {
                bestValue = neighborValue;
                bestNeighbor = neighbor;
            }
        }
        
        // Jika tidak ada improvement, stop (local maximum)
        if (bestNeighbor === null) {
            break;
        }
        
        currentState = bestNeighbor;
        currentValue = bestValue;
    }
    
    return { state: currentState, value: currentValue };
}

// Contoh: Mencari maximum dari function f(x) = -x^2 + 4x + 10
function functionValue(x) {
    return -Math.pow(x, 2) + 4 * x + 10;
}

function getNeighbors(x) {
    return [x - 0.1, x + 0.1]; // Step kecil
}

let result = hillClimbing(0, functionValue, getNeighbors);
console.log("Maximum found at x:", result.state);
console.log("Maximum value:", result.value);

Contoh 4: Greedy Algorithm untuk Knapsack Problem

Pendekatan greedy yang memilih item berdasarkan value-to-weight ratio

// Fractional Knapsack dengan Greedy approach
function fractionalKnapsack(capacity, items) {
    // Sort items by value-to-weight ratio (descending)
    items.sort((a, b) => (b.value / b.weight) - (a.value / a.weight));
    
    let totalValue = 0;
    let selectedItems = [];
    let remainingCapacity = capacity;
    
    for (let item of items) {
        if (item.weight <= remainingCapacity) {
            // Ambil item secara penuh
            selectedItems.push({ ...item, fraction: 1 });
            totalValue += item.value;
            remainingCapacity -= item.weight;
        } else {
            // Ambil sebagian dari item
            let fraction = remainingCapacity / item.weight;
            selectedItems.push({ ...item, fraction: fraction });
            totalValue += item.value * fraction;
            break; // Knapsack sudah penuh
        }
    }
    
    return { totalValue, selectedItems };
}

// Contoh penggunaan
const items = [
    { name: 'Laptop', value: 2000, weight: 2 },
    { name: 'Phone', value: 1500, weight: 1 },
    { name: 'Tablet', value: 1000, weight: 1.5 },
    { name: 'Watch', value: 500, weight: 0.5 }
];

const result = fractionalKnapsack(3, items);
console.log("Total Value:", result.totalValue);
console.log("Selected Items:", result.selectedItems);