Nodejs Array Merge Sort mergeSort()

Method Source Code

;"use strict";/*from   w w  w. j  a v a  2 s.  c o  m*/
var log=function(msg){console.log(msg);};
var alert=function(msg){log(msg);};

var arr = [3,6,7,5,3,6,2,9,1,5,33,-12,0,-122,-Infinity, 125, 33, 55, 77];

Array.prototype.mergeSort = function () {
   function _merge(arrLeft, arrRight){
       var result = [],
       leftIdx = 0,
       rightIdx = 0;

       while (leftIdx < arrLeft.length && rightIdx < arrRight.length){
           if (arrLeft[leftIdx] < arrRight[rightIdx]){
               result.push(arrLeft[leftIdx++]);
           } else {
               result.push(arrRight[rightIdx++]);
           }
       }

       return result.concat(arrLeft.slice(leftIdx)).concat(arrRight.slice(rightIdx));
   }

   function _mergeSort(arr){
       if (arr.length < 2) {
           return arr;
       }

       var middle = Math.floor(arr.length / 2),
       arrLeft    = arr.slice(0, middle),
       arrRight   = arr.slice(middle),
       params = _merge(_mergeSort(arrLeft), _mergeSort(arrRight));
       
       params.unshift(0, arr.length);
       arr.splice.apply(arr, params);

       return arr;
   }

   return _mergeSort(this);
}
console.log(arr.sort());
console.log(arr.mergeSort());

Related

1. mergeSort()

   Array.prototype.mergeSort = function(){
       var merge = function(left,right){
           var merged = [];
           while(left.length && right.length){
               merged.push(left[0] <= right[0] ? left.shift():right.shift());
           return merged.concat(left.concat(right));
       var myarray = [];
   ...
   

2. mergeSort()

   Array.prototype.mergeSort = function() {
     function merge(left, right) {
       var arr = []
       while(left.length && right.length) {
         if(left[0] < right[0]) {
           arr.push(left.shift())
         } else {
           arr.push(right.shift())
       return arr.concat(left, right)
     var len = this.length
     if(len > 1) {
       var index = Math.floor(len/2)
       var left = this.slice(0, index)
       var right = this.slice(index)
       return merge(left.mergeSort(), right.mergeSort())
     } else {
       return this
   

3. mergeSort()

   Array.prototype.mergeSort = function () {
     if (this.length <= 1) {
       return this;
     var half = parseInt(this.length / 2);
     var left = this.slice(0, half).mergeSort();
     var right = this.slice(half, this.length).mergeSort();
     var merge = function (left, right) {
     var ary = [];
   ...
   

4. mergeSort()

   Array.prototype.mergeSort = function () {  
     if (this.length <= 1)   
       return this;  
     var half = parseInt(this.length / 2);  
     var left = this.slice(0, half).mergeSort();  
     var right = this.slice(half,this.length).mergeSort();  
     var merge = function (left, right)   
   ...
   

5. mergeSort()

   Array.prototype.mergeSort = function () {
     if ( this.length < 2 ) {
       return this;
     var mid_idx = Math.floor( this.length / 2 )
     var left = this.slice(0,mid_idx).mergeSort();
     var right = this.slice(mid_idx).mergeSort();
     return merge(left, right);
   function merge(left, right) {
     var result = [];
       while (left.length > 0 && right.length > 0) {
         var nextItem = (left[0] < right[0]) ? left.shift() : right.shift();
         result.push(nextItem);
     return result.concat(left).concat(right);
   console.log();
   console.log( JSON.stringify( [].mergeSort() ) == JSON.stringify( [] )  );
   console.log( JSON.stringify( [6,5,3,1,8,7,2,4].mergeSort() ) == JSON.stringify( [1,2,3,4,5,6,7,8] ) );
   console.log();
   

6. mergeSort()

   Array.prototype.mergeSort = function() {
       function sort(array) {
           var length = array.length,
               mid    = Math.floor(length * 0.5),
               left   = array.slice(0, mid),
               right  = array.slice(mid, length);
           if(length === 1) {
             return array;
           return merge(sort(left), sort(right));
       function merge(left, right) {
           var result = []
           for (var li=0,ri=0,i=0;i<left.length+right.length;i++){
               if (li < left.length && ri < right.length) {
                   if (less(left[li], right[ri])) {
                       result[i]=left[li]
                       li++
                       continue
                   else {
                       result[i]=right[ri]
                       ri++
                       continue
               if (li===left.length) {
                   result[i]=right[ri]
                   ri++
                   continue
               else {
                   result[i]=left[li]
                   li++
                   continue
           virtualize(result, 0)
           return result
       var newArray=sort(this)
       return newArray
   

7. mergeSort()

   Array.prototype.mergeSort = function() {
       function sort(array) {
           var length = array.length,
               mid    = Math.floor(length * 0.5),
               left   = array.slice(0, mid),
               right  = array.slice(mid, length);
           if(length === 1) {
             return array;
           return merge(sort(left), sort(right));
       function merge(left, right) {
           var result = []
           for (var li=0,ri=0,i=0;i<left.length+right.length;i++){
               if (li < left.length && ri < right.length) {
                   if (less(left[li], right[ri])) {
                       result[i]=left[li]
                       li++
                       continue
                   else {
                       result[i]=right[ri]
                       ri++
                       continue
               if (li===left.length) {
                   result[i]=right[ri]
                   ri++
                   continue
               else {
                   result[i]=left[li]
                   li++
                   continue
           return result
       var newArray=sort(this)
       return newArray
   

8. mergeSort(arr2, arr3)

   Array.prototype.mergeSort = function(arr2, arr3) {
     return this.merge2way(arr2.merge2way(arr3));
   var maxNumber = process.argv[2];
   function getRandomArbitrary(min, max) {
     return Math.round(Math.random() * (max - min) + min);
   var arr1 = [getRandomArbitrary(1, 5)],
     arr2 = [getRandomArbitrary(1, 5)],
   ...
   

9. mergeSort(sortKey, direction)

   Array.prototype.mergeSort = function(sortKey, direction){
     var unsortedArray = this;
     if(unsortedArray.length < 2) return unsortedArray;
     var middle = Math.floor(unsortedArray.length/2);
     var leftSubArray = unsortedArray.slice(0,middle).mergeSort(sortKey, direction);
     var rightSubArray = unsortedArray.slice(middle).mergeSort(sortKey, direction);
     var sortedArray = merge(leftSubArray, rightSubArray);
     return sortedArray;
     function merge(left, right) {
   ...