DEV Community

Cover image for Sorting Algorithms with Javascript (Part 2)
Kelvin Wangonya
Kelvin Wangonya

Posted on

Sorting Algorithms with Javascript (Part 2)

As promised, here's the second part of the post. You can read the first part here.

I'm going to show Javascript implementations of three more sorting algorithms:

  • Quick sort
  • Heap sort
  • Counting sort

Again, this is not intended to be an in-depth explanation on the ins and outs of how the algorithms work and their performance. If you'd rather read about that, here's a nice resource I found: Sorting Algorithms

To keep things simple, I'll be sorting a simple list list having only 5 elements [4, 2, 3, 1, 5].

Quick Sort

Like merge sort, this algorithm takes a divide-and-conquer approach. It works by picking a pivot and dividing the list in relation to that pivot: all elements greater than the pivot go to the right of the pivot, and all elements less than or equal to the pivot go to the left of the pivot. Elements on both sides are quick sorted, and this is repeated until the complete list is sorted.

Visual

The visual on this wasn't very clear in illustrating how the algorithm actually works so here's a video instead.

Code

function quickSort(list) {
    if (list.length <= 1) { 
        return list
    } else {
        const left = []
        const right = []
        const sorted = []
        const pivot = list.pop() // we're picking the last item to act as the pivot
        const length = list.length

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

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

const list = [4, 2, 3, 1, 5]

const sorted = quickSort(list)

console.log(sorted)
Enter fullscreen mode Exit fullscreen mode

Heap Sort

This algorithm takes advantage of a data structure known as a binary-heap. Heap sort works by creating a Max heap to sort the elements in ascending order, then swapping the root node with the last node, and deleting the sorted node from the heap every time this is done.

Visual

heap-sort

Code

// create max heap
function maxHeap(input, i) {
    const left = 2 * i + 1
    const right = 2 * i + 2
    let max = i

    if (left < arrLength && input[left] > input[max]) {
        max = left
    }

    if (right < arrLength && input[right] > input[max])     {
        max = right
    }

    if (max != i) {
        swap(input, i, max)
        maxHeap(input, max)
    }
}

function swap(input, indexA, indexB) {
    const temp = input[indexA]

    input[indexA] = input[indexB]
    input[indexB] = temp
}

function heapSort(input) {   
    arrLength = input.length

    for (let i = Math.floor(arrLength / 2); i >= 0; i -= 1)      {
        maxHeap(input, i)
      }

    for (i = input.length - 1; i > 0; i--) {
        swap(input, 0, i)
        arrLength--

        maxHeap(input, 0)
    }
    return
}

let arrLength

const list = [4, 2, 3, 1, 5]

const sorted = heapSort(list)

console.log(list)
Enter fullscreen mode Exit fullscreen mode

Counting Sort

You'll find counting sort to be rather unique compared to the algorithms we've covered so far. This is because it does not compare elements while sorting. It works based on numeric keys. It does this by creating a counting array, then using it to determine an element's correct position.

Visual

counting-sort

Code

function countingSort(list, min, max)
  {
      let i
      let z = 0
      const count = []

      for (i = min; i <= max; i++) {
          count[i] = 0
      }

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

      for (i = min; i <= max; i++) {
          while (count[i]-- > 0) {
              list[z++] = i
          }
      }
      return list
  }

const list = [4, 2, 3, 1, 5]
const min = Math.min(...list)
const max = Math.max(...list)
const sorted = countingSort(list, min, max)

console.log(sorted)
Enter fullscreen mode Exit fullscreen mode

Happy coding!

happy

Top comments (3)

Collapse
 
chenge profile image
chenge

quicksort in Ruby. Short and clear.

def qs a
  (pivot = a.pop) ? 
    qs(a.select{|i| i <= pivot}) + [pivot] + qs(a.select{|i| i > pivot}) :
    []
end

Enter fullscreen mode Exit fullscreen mode
Collapse
 
simoroshka profile image
Anna Simoroshka • Edited

I can do pretty much the same in javascript. :)

const qs = (a) => {
   const pivot = a.pop();
   return pivot != null ? [...qs(a.filter(i => i < pivot)), pivot, ...qs(a.filter(i => i >= pivot))] : [];
}
Enter fullscreen mode Exit fullscreen mode
Collapse
 
wangonya profile image
Kelvin Wangonya

Wow! I've never written a line of ruby in my life 😅 This is really clean.