insertion sort

a linear complexity algorithm

JavaScript

function sort() {
  var LABEL;
	var array=[];
  for (var num=0, total=10; num < total; num++) {
  	array.push(Math.floor(Math.random() * total));
		//array.push(num);   
  }
  //document.write([].concat(array));
  console.warn('Original Array ', [].concat(array));
  
	var t1, t2, count = 0;
	t1 = performance.now();
  
  //JavaScript original Sort
  /*LABEL='JAVASCRIPT ARRAY.SORT() Function';
  array.sort(function (a, b) {
  		return a -b;
  });*/
  
  // Selection Sort
  /*LABEL='SELECTION SORT';
  var minIndex, temp, swapped = false;
	for (var i=0; i < array.length; i++) {
  	minIndex = i;
  	for (var j=i+1; j < array.length; j++) {
    	count++;
    	if (array[j] < array[minIndex]) {
      	minIndex = j;
      }
    }
    temp = array[i];
    array[i] = array[minIndex];
    array[minIndex] = temp;
  }*/
  
  // Insertion Sort
  /*LABEL='INSERTION SORT';
  var value, sorted, unsorted;
  for (unsorted=1; unsorted < array.length; unsorted++) {
  	value = array[unsorted];
  	for (sorted=unsorted -1; sorted > -1 && array[sorted] > value; sorted--) {
    	array[sorted + 1] = array[sorted];
    }
    array[sorted+ 1] = value;  	
  }*/
  
  //Merge Sort
  /*function merge(left, right) {
  	var newArray = [];
  	while(left.length > 0 && right.length > 0) {
    	newArray.push(left[0] < right[0] ? left.shift() : right.shift());
    }
    return newArray.concat(left.length ? left : right);
  }
  
  function mergeSort(array) {
    LABEL='MERGE SORT';
    var midPoint, left, right;

    if (array.length < 2) {return array;}

    midPoint = Math.floor(array.length/2);
    left = array.slice(0, midPoint);
    right = array.slice(midPoint);

    return merge(mergeSort(left), mergeSort(right));
  };
  array = mergeSort(array);*/
  
  //Quick Sort
  LABEL="QUICK SORT"
  function swap(array, i, j) {
     var temp = array[i];
   	array[i] = array[j];
   	array[j] = temp;
  }
  
  function quickSort(array, left, right) {
  	var pivot = right;
  	var partitionIndex = partition(array,...