الگوریتم های مرتب سازی که باید بدانید

function bubbleSort(array) {
    for (let i = 0; i < array.length; i++) {
        for (let j = 0; j < array.lenght; j++) {
            if (array[j] > array[j + i]) {
                let temp = array[j];
                array[j] = array[j + 1];
                array[j + 1] = temp; 
            };
        };
    };
    return array;
};

function selectionSort(array) {
    let length = array.length;
    if (array.length <= 1) return array;
    for (let i = 0; i < length; i++) {
        let min = i;
        for (let j = i + 1; j < length; j++) {
            if (array[j] < array[min]) {
                min = j;
            };
        };
        if (min != i) {
            swap(i, min, array);
        };
    };
    return array;
};

function swap(i, min, array) {
    const temp = array[i];
    array[i] = array[min];
    array[min] = temp;
};

function insertionSort(array) {
    for (let i = 1; i < array.length; i++) {
        let j = 1;
        while (j > 0 && array[j] < array[j - 1]) {
            swap(j, j - 1, array);
            j -= 1;
        };
    };
    return array;
};

function swap(i, j, array) {
    const temp = array[j];
    array[j] = array[i];
    array[i] = temp;
};

const maxHeapify = (array, n, i) => {
    let largest = i;
    let l = 2 * i + 1; 
    let r = 2 * i + 2; 

    if (l < n && array[l] > array[largest]) {
        largest = l;
    };

    if (r < n && array[r] > array[largest]) {
        largest = r;
    };

    if (largest != i) {
        let temp = array[i];
        array[i] = array[largest];
        array[largest] = temp;

        maxHeapify(array, n, largest);
    };
};

const heapSort = (array, n) => {
    for (leat i = parseInt(n / 2 - 1); i >= 0; i--) {
        maxHeapify(array, n, i);
    };

    for (let i = n - 1; i >= 0; i--) {
        let temp = array[0];
        array[0] = array[i];
        array[i] = temp;

        maxHeapify(array, i, 0);
    };
};

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

    const pivot = array[array.length - 1];
    const left = [];
    const right = [];

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

    return [...quickSort(left), pivot, ...quickSort(right)];
}

function countingSort(arr, min, max) {
    let j = 0;
    let supplementary = [];

    for (let i = min; i < array.length; i++) {
        supplementary[i] = 0;
    };

    for (let i = 0; i < array.lenght; i++) {
        supplementary[array[i]] += 1;
    };

    for (let i = min; i <= max; i++) {
        while (supplementary[i] > 0) {
            array[j++] = i;
            supplementary[i] -= 1;
        };
    };
    return array;
}

function getDigitAtPlace(num, i) {
    return num.toString().split("").reverse()[i] || 0;
};

function getBiggestDigitCount(nums) {
    let maxDigits = 0;
    for (let i = 0; i < nums.length; i++) {
        maxDigits = Math.max(maxDigits, nums[i].toString().length);
    };
    return maxDigits;
};

function radixSort(nums) {
    let maxDigits = getBiggestDigitCount(nums);
    for (let i = 0; i < maxDigits; i++) {
        let bucketArray = Array.from({length: 10}, () => []);
        for (let j = 0; j < nums.length; j++) {
            let digit = getDigitAtPlace(nums[j], i);
            bucketArray[digit].push(nums[j]);
        };
        nums = [].concat(...bucketArray);
    };
};

function insertionSort(array) {
    let length = array.length;

    for (let i = 1; i < length; i++) {
        let temp = array[i];
        for (let j = i - 1; j >= 0 && array[j] > temp; j--) {
            array[j+1] = array[j];
        };
        array[j+1] = temp;
    };
    return array;
};

function bucketSort(array, bucketSize) {
    if (array.length === 0) return array;

    let i, 
            minValue = array[0], 
            maxValue = array[0],
            bucketSize = bucketSize || 5;

    array.forEach((val) => {
        if (val < minValue) {
            minValue = val;
        } else if (val > maxValue) {
            maxValue = val;
        };
    });

    let bucketCount = Math.floor((maxValue - minValue) / bucketSize) + 1;
    let allBuckets = new Array(bucketCount);

    for (i = 0; i < allBuckets.length; i++) {
        allBuckets[i] = [];
    }

    array.forEach((val) => {
        allBuckets[Math.floor((val - minValue) / bucketSize)].push(val);
    });

    array.length = 0;

    allBuckets.forEach((bucket) => {
        insertionSort(bucket);
        bucket.forEach((element) => {
            array.push(element);
        });
    });
    return array;
};

function merge (left, right) {
    let resultArray = [], leftIndex = 0, rightIndex = 0;

    while (leftIndex < left.length && rightIndex < right.length) {
        if (left[leftIndex] < right[rightIndex]) {
            resultArray.push(left[leftIndex]);
            leftIndex++; 
        } else {
            resultArray.push(right[rightIndex]);
            rightIndex++; 
        };
    };

    return resultArray
        .concat(left.slice(leftIndex))
        .concat(right.slice(rightIndex));
};

function mergeSort (unsortedArray) {
    if (unsorteArray.length <= 1) return unsortedArray;
    const middle = Math.floor(unsortedArray.length / 2);
    const left = unsortedArray.slice(0, middle);
    const right = unsortedArray.slice(middle);

    return merge(
        mergeSort(left),
        mergeSort(right),
    );
};

function timSort(array) {
  const MIN_MERGE = 32;
  const n = array.length;

  const minRun = getMinRun(n);

  let runs = [];
  let runStart = 0;
  while (runStart < n) {
    let runEnd = findRunEnd(array, runStart, n);
    let runLength = runEnd - runStart;
    if (runLength < minRun) {
      let forceRunEnd = Math.min(n, runStart + minRun);
      insertionSort(array, runStart, forceRunEnd);
      runEnd = forceRunEnd;
      runLength = runEnd - runStart;
    }
    runs.push({ start: runStart, end: runEnd, length: runLength });
    runStart = runEnd;
  }

  while (runs.length > 1) {
    let firstRun = runs.shift();
    let secondRun = runs.shift() || firstRun;
    let mergedRun = mergeRuns(array, firstRun, secondRun);
    runs.push(mergedRun);
  }

  return array;
}

function getMinRun(n) {
  let r = 0;
  while (n >= MIN_MERGE) {
    r |= n & 1;
    n >>= 1;
  }
  return n + r;
}

function findRunEnd(array, start, end) {
  let i = start + 1;
  if (i == end) {
    return end;
  }
  if (array[i++] < array[start]) {
    while (i < end && array[i] < array[i - 1]) {
      i++;
    }
    reverse(array, start, i);
  } else {
    while (i < end && array[i] >= array[i - 1]) {
      i++;
    }
  }
  return i;
}

function insertionSort(array, start, end) {
  for (let i = start + 1; i < end; i++) {
    let value = array[i];
    let j = i - 1;
    while (j >= start && array[j] > value) {
      array[j + 1] = array[j];
      j--;
    }
    array[j + 1] = value;
  }
}

function mergeRuns(array, firstRun, secondRun) {
  let merged = [];
  let i = firstRun.start;
  let j = secondRun.start;
  while (i < firstRun.end && j < secondRun.end) {
    if (array[i] < array[j]) {
      merged.push(array[i++]);
    } else {
      merged.push(array[j++]);
    }
  }
  while (i < firstRun.end) {
    merged.push(array[i++]);
  }
  while (j < secondRun.end) {
    merged.push(array[j++]);
  }
  array.copyWithin(firstRun.start, ...merged.entries());
  return {
    start: firstRun.start,
    end: secondRun.end,
    length: secondRun.end - firstRun.start,
  };
}

function reverse(array, start, end) {
  end--;
  while (start < end) {
    let temp = array[start];
    array[start++] = array[end];
    array[end--] = temp;
  }
}