Nodejs Array Merge Sort mergesort(lst)

Method Source Code

// Mergesort//from w w w  .java2 s.com

var arr = [2, 4, 6, 1, 3, 5, 8, 7];

var mergesort = function (lst) {
    if (lst.length === 1) return lst;

    var L = lst.slice(0, lst.length / 2),
        R = lst.slice(lst.length / 2, lst.length);

    var left = mergesort(L),
        right = mergesort(R);

    return merge(left, right);

    function merge(left, right) {

        var res = [];

        var k = 0,
            i = 0,
            ii = 0,
            ll = left.length,
            lr = right.length;

        while (ll || lr) {

            if (ll && lr) {

                l = left[i];
                r = right[ii];


                if (l <= r) {
                    res.push(l);
                    i += 1;
                    ll -= 1;
                } else {
                    res.push(r);
                    ii += 1;
                    lr -= 1;
                }

            } else if (ll) {
                res = res.concat(left.slice(i, left.length));
                ll = 0;
            } else if (lr) {
                res = res.concat(right.slice(ii, right.length));
                lr = 0;
            }
        }
        return res;

    }


}

console.log(mergesort(arr));

Related

1. mergeSort(arr)

   var mergeSort = function (arr) {
       var n = parseInt(arr.length/2);
       if(n < 1){
           return arr;
       }else{
           var arr1 = mergeSort(arr.slice(0, n));
           var arr2 = mergeSort(arr.slice(n));
       var a = [];
   ...
   

2. mergesort (arr, lo, hi)

   'use strict';
   Array.prototype.swap = function (i, j) {
     const temp = this[i];
     this[i] = this[j];
     this[j] = temp;
   function mergesort (arr, lo, hi) {
     function partition (lo, hi) {
       if (lo >= hi) return;
   ...
   

3. mergesort(A)

   function merge(left, right) {
     var result = [];
     while(left.length > 0 || right.length > 0) {
       if(left.length > 0 && right.length > 0) {
         if(left[0] <= right[0]) {
           result.push(left.shift());
         } else {
           result.push(right.shift());
       } else if(left.length > 0) {
         result.push(left.shift());
       } else if(right.length > 0) {
         result.push(right.shift());
     return result;
   function mergesort(A) {
     if(A.length < 2) {
       return A;
     var middle = Math.ceil(A.length / 2);
     var left = A.splice(0, middle);
     var right = A;
     left = mergesort(left);
     right = mergesort(right);
     return merge(left, right);
   Array.prototype.mergeSort = function() {
     return mergesort(this);
   

4. mergeSort(array)

   function mergeSort(array) {
     var merge = function (left, right) {
       var total = []
       while (left.length && right.length)
         total.push(left[0] <= right[0] ? left.shift() : right.shift())
       return total.concat(left.concat(right));
     var length = array.length;
     if (length < 2) return array
   ...
   

5. mergeSort(array)

   function merge(left, right) {
     const merged = [];
     while (left.length > 0 && right.length > 0) {
       let nextItem = (left[0] < right[0]) ? left.shift() : right.shift();
       merged.push(nextItem);
     return merged.concat(left, right);
   function mergeSort(array) {
   ...
   

6. 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));
       if (this.length < 2) return this;
   ...
   

7. 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 = [];
   ...