The SORTING

Algorithms

• Quick Sort

  function quickSort(arr, start, end) {
  
      if (end - start <= 0) return
      let i = start;
      let j = end - 1
      let pivotVal = arr[end]
  
      /*partition step*/
      while (i <= j) { 
          while (arr[i] < pivotVal) {
              i++
          }
          while (arr[j] > pivotVal) {
              j--
          }
          if (i <= j) {
              [arr[i], arr[j]] = [arr[j], arr[i]];
              i++
              j--
          }
      }
      [arr[end], arr[i]] = [arr[i], arr[end]]
      /*end partition setp*/
  
      quickSort(arr, start, i - 1)
      quickSort(arr, i + 1, end)
      return arr
  }
  

• Merge Sort

  function mergesort(arr, start, end) {
  
      let lastIndex = end - 1
      let half = Math.floor((end + start) / 2)
  
      if (end - start == 3) {
          merge(arr, start + 1, end)
          merge(arr, start, end)
      } else if (end - start == 2) {
          merge(arr, start, end)
      } else {                
          mergesort(arr, half, end)
          mergesort(arr, start, half)
          merge(arr, start, end)
      }
      return arr
  
      function merge(arr, start, end) {
  
          let temp = []
          let mid = Math.floor((end + start) / 2)
          let p = start
          let q = mid
          var pEmpty, qEmpty
  
          for (let i = start; i < end; i++) {
  
              pEmpty = p >= mid
              qEmpty = q >= end
  
              if (qEmpty || (!pEmpty && arr[p] <= arr[q])) {
                  let val = arr[p++]
                  temp.push(val)
              } else if (!qEmpty) {
                  let val = arr[q++]
                  temp.push(val)
              }
          }
          for (let i = 0; i < end - start; i++) {
              arr[start + i] = temp[i]
          }
      }
  } 
  

• Heap Sort

  

  async function heapSort(arr) {
  
      var end = arr.length;
      for (var i = Math.floor(end / 2); i >= 0; i -= 1) {
          heapify(arr, i);
      }
  
      for (i = end - 1; i > 0; i--) {
          [arr[0], arr[i]] = [arr[i], arr[0]]
          end--
          heapify(arr, 0)
      }
      return arr
  
      function heapify(arr, i) {
  
          var left = 2 * i + 1
          var right = 2 * i + 2
          var max = i
  
          if (left < end && arr[left] > arr[max]) {
              max = left
          }
          if (right < end && arr[right] > arr[max]) {
              max = right
          }
          if (max != i) {
              [arr[i], arr[max]] = [arr[max], arr[i]]
              heapify(arr, max)
          }
      }
  }
  

• Shell Sort

  function shellSort(arr) {
      var gaps = [701, 301, 132, 57, 23, 10, 4, 1];
      gaps = gaps.filter(item=>item<arr.length)
      for (var g = 0; g < gaps.length; g++) {
          var h = gaps[g]
          for (var i = h; i < arr.length; i++) {
              var currentValue = arr[i]
              for (var j = i; j >= h && currentValue < arr[j - h]; j -= h) {
                  arr[j] = arr[j - h]
              }
              arr[j] = currentValue;
          }
      }
      return arr
  }
  

• Comb Sort

  function combSort(arr) {
  
      var iterations = 0
      var gap = arr.length - 2
      var decreaseFactor = 1.25
  
      while (!isSorted(arr)) {
          if (iterations > 0)
              gap = (gap == 1) ? 1 : Math.floor(gap / decreaseFactor)
          var front = 0
          var back = gap
          while (back <= arr.length - 1) {
              if (arr[front] > arr[back]) {
                  [arr[front], arr[back]] = [arr[back], arr[front]]
              }
              front += 1
              back += 1
          }
          iterations += 1
      }
      return arr
  
      function isSorted(arr) {
          var sorted = true;
          for (var i = 0; i < arr.length - 1; i++) {
              if (arr[i] > arr[i + 1]) {
                  sorted = false
                  break
              }
          }
          return sorted
      }
  }
  

• Selection Sort

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

• Bubble Sort

  function bubbleSort(arr) {
      var didSwap = false
      var end = arr.length - 1
      do {
          didSwap = false
          for (var i = 0; i < end; i++) {
              if (arr[i] > arr[i + 1]) {
                  [arr[i], arr[i + 1]] = [arr[i + 1], arr[i]]
                  didSwap = true
              }
          }
          end--
      } while (didSwap)
      return arr
  }
  

• Insertion Sort

  function insertionSort(arr) {
  
      for (var i = 1, j; i < arr.length; i++) {
          var temp = arr[i]
          for (var j = i - 1; j >= 0 && arr[j] > temp; j--) {
              arr[j + 1] = arr[j]
          }
          arr[j + 1] = temp
      }
      return arr
  }