JavaScript'te Algoritmalar (Sıralama, Arama)

Algoritmalar, bir problemin çözümünü belirli adımların bir kombinasyonu olarak tanımlayan matematiksel ve mantıksal işlemlerdir. JavaScript, çeşitli algoritmaları uygulamak için bir dizi fonksiyon ve yöntem sağlar. En yaygın kullanılan algoritmalar arasında sıralama (sorting) ve arama (searching) algoritmaları bulunmaktadır.

Sıralama (Sorting) Algoritmaları

1. Bubble Sort

Bubble sort, listedeki elemanları karşılaştırarak sıralayan temel bir sıralama algoritmasıdır. Kompleksitesi O(n^2)dir.

function bubbleSort(arr) {
    let len = arr.length;

    for (let i = 0; i < len - 1; i++) {
        for (let j = 0; j < len - 1 - i; j++) {
            if (arr[j] > arr[j + 1]) {
                [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
            }
        }
    }

    return arr;
}

let sortedArray = bubbleSort([5, 3, 8, 2, 1]);
console.log(sortedArray); // [1, 2, 3, 5, 8]

2. Quick Sort

Quick sort, bir pivot eleman seçerek liste elemanlarını küçük ve büyük olmak üzere iki parçaya ayırarak sıralayan hızlı bir sıralama algoritmasıdır. Ortalama durumda O(n log n) karmaşıklığına sahiptir.

function quickSort(arr) {
    if (arr.length <= 1) {
        return arr;
    }

    const pivot = arr[0];
    const left = [];
    const right = [];

    for (let i = 1; i < arr.length; i++) {
        if (arr[i] < pivot) {
            left.push(arr[i]);
        } else {
            right.push(arr[i]);
        }
    }

    return quickSort(left).concat(pivot, quickSort(right));
}

let sortedArray = quickSort([5, 3, 8, 2, 1]);
console.log(sortedArray); // [1, 2, 3, 5, 8]

Arama (Searching) Algoritmaları

1. Linear Search

Linear search, elemanları sıralı olmayan bir listede sırayla arayarak hedef elemanı bulan basit bir arama algoritmasıdır. En kötü durumda O(n) karmaşıklığına sahiptir.

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

let index = linearSearch([5, 3, 8, 2, 1], 8);
console.log(index); // 2

2. Binary Search

Binary search, sıralı bir listede hedef elemanı bulmak için sıralanmış elemanlar arasında bölünmüş bir arama algoritmasıdır. En kötü durumda O(log n) karmaşıklığına sahiptir.

function binarySearch(arr, target) {
    let low = 0;
    let high = arr.length - 1;

    while (low <= high) {
        let mid = Math.floor((low + high) / 2);

        if (arr[mid] === target) {
            return mid;
        } else if (arr[mid] < target) {
            low = mid + 1;
        } else {
            high = mid - 1;
        }
    }

    return -1;
}

let index = binarySearch([1, 2, 3, 5, 8], 5);
console.log(index); // 3

JavaScript, bu ve benzeri algoritmaları uygulamak için zengin bir fonksiyon ve dizi yöntemi setine sahiptir. Bu algoritmaların yanı sıra daha karmaşık ve optimize edilmiş sıralama ve arama yöntemleri de bulunmaktadır. En uygun algoritmayı seçmek için, veri yapısının boyutu ve tipine göre karmaşıklık ve performans analizi yapmak önemlidir.