如何使此代码运行更快

Question

The array contains digits and it is unsorted. Its length could be as big as 100000. I need to count the smaller numbers to the right of each digit.

Example:

    100, 10, 10, 10, 10]should return 4, 0, 0, 0, 0

    1, 2, 3             should return 0, 0, 0

    1, 2, 0             should return 1, 1, 0

    1, 2, 1             should return 0, 1, 0

Task: I have 100 tests to perform and the goal is to do them all under 12ms. The following function is an AVL Tree implementation. It gets the job done but not fast enough.

It performs 48 out of 100 in 12s.

===============

function smaller(arr) {
  function TreeNode(key) {
    this.key    = key;
    this.size   = 1;
    this.height = 1;
    this.left   = null;
    this.right  = null;
    this.count  = 1;
  }
  var size        = (node) => node == null ? 0 : node.size + node.count - 1;
  var height      = (node) => node == null ? 0 : node.height;
  var getBalance  = (node) => node == null ? 0 : height(node.left) - height(node.right);

  var rotateRight = function(root) {
    var newRoot      = root.left;
    var rightSubTree = newRoot.right;
    newRoot.right    = root;
    root.left        = rightSubTree;
    root.height      = Math.max(height(root.left), height(root.right)) + 1;
    newRoot.height   = Math.max(height(newRoot.left), height(newRoot.right)) + 1;
    root.size        = size(root.left) + size(root.right) + 1;
    newRoot.size     = size(newRoot.left) + size(newRoot.right) + 1;
    return newRoot;
  }
  var rotateLeft = function(root) {
    var newRoot     = root.right;
    var leftSubTree = newRoot.left;
    newRoot.left    = root;
    root.right      = leftSubTree;
    root.height     = Math.max(height(root.left), height(root.right)) + 1;
    newRoot.height  = Math.max(height(newRoot.left), height(newRoot.right)) + 1;
    root.size       = size(root.left) + size(root.right) + 1;
    newRoot.size    = size(newRoot.left) + size(newRoot.right) + 1;
    return newRoot;
  }
  var insertIntoAVL = function(node, key, count, index) {
    if(node == null)return new TreeNode(key);
    if(key  <  node.key){node.left    = insertIntoAVL(node.left, key, count, index);}
    if(key  == node.key){count[index] = count[index] + size(node.left); node.count++; return node;}
    if(key  >  node.key){node.right   = insertIntoAVL(node.right, key, count, index); count[index] = count[index] + size(node.left) + node.count;}
    node.height = Math.max(height(node.left), height(node.right)) + 1;
    node.size   = size(node.left) + size(node.right) + 1;
    var balance = getBalance(node);
    if(balance >  1 && key < node.left.key ){return rotateRight(node);}
    if(balance < -1 && key > node.right.key){return rotateLeft(node);}
    if(balance >  1 && key > node.left.key ){node.left = rotateLeft(node.left); return rotateRight(node);}
    if(balance < -1 && key < node.right.key){node.right = rotateRight(node.right); return rotateLeft(node);}
    return node;
  }
  var countSmallerOnRight = function( arr ) {
    var result = new Array(arr.length).fill(0);
    var root   = null;
    for (var i = arr.length; i--;){root = insertIntoAVL(root, arr[i], result, i);}
    return result;
  }
  return countSmallerOnRight(arr);
  }

=================

I have a second approach which is faster but still not fast enough. It performs 84 out of 100 in 12ms;

=================

function smaller(arr) {
  function BSTNode(val, count) {
    this.dup   = 1;
    this.left  = null;
    this.right = null;
    this.val   = val;
    this.count = count;
  }
  var countSmaller = arr => {
    var result = [];
    var root   = null;
    for (var i = arr.length; i--;){root = insert(root, arr[i], result, 0, i);}
    return result;
  }
  var insert = (root, num, result, sum, i) => {
    if (root == null) {
      root = new BSTNode(num, 0);
      result[i] = sum;
      return root;
    } else if (root.val == num) {
      root.dup++;
      result[i] = sum + root.count;
      return root;
    } else if (root.val > num) {
      root.count++;
      root.left = insert(root.left, num, result, sum, i);
    } else {
      root.right = insert(root.right, num, result, sum + root.count + root.dup, i);
    }
    return root;
  }
  return countSmaller(arr);
}

=================

I would like to understand why they don't achieve the goal and how can I improve them.

Answer 1

This is decent, but I don't know what (codewars?) challenge this is for so I can't test it. Doesn't use trees.

function smaller(arr) {
    var out = [0];
    var len = arr.length;
    for (var i=len - 2; i >= 0; i--) {
      var c = 0;
      for (var j = i + 1; j < len; j++) {
        if (arr[i] == arr[j]) {
          c += out[j - i - 1];
          break;
        } else if (arr[i] > arr[j]) {
          c++;
        }
      }
      out.unshift(c);
    }
    return out;
}
var testArr = [1,5,2,7,44,878,1,22,999,222,1,1,1,1,1,1,1,1,1,1,1,1,1];
alert(smaller(testArr).join(","));

Answer 2

I can do it without a tree, just with a simple Linked List:

 function Node(value, next){ this.value = value; this.next = next; this.count = 1; } function smaller(array){ return array.reduceRight(function(root, value, i){ var count = 0; for(var prev = root, node; (node = prev.next) && node.value < value; prev = node) count += node.count; root.counts[i] = count; if(node && node.value === value){ node.count++; }else{ prev.next = new Node(value, prev.next); } return root; }, { next: null, counts: Array(array.length).fill(0) }).counts; } console.log("100, 10, 10, 10, 10 -> " + smaller([100, 10, 10, 10, 10])); console.log("1, 2, 3 -> " + smaller([1, 2, 3])); console.log("1, 2, 0 -> " + smaller([1, 2, 0])); console.log("1, 2, 1 -> " + smaller([1, 2, 1])); var sampleData = Array.from({length: 100000}, () => 0|(Math.random() * 100)); console.time("100000 items"); smaller(sampleData); console.timeEnd("100000 items"); 

Did a quick test in the console of the three four implementations with 100000 Values.

• your first code: ~700-800ms
• your second code: ~350-400ms
• my code: ~15-30ms
• James' code: ~25000ms

All implementations tested on the same pregenerated Array of 100000 Items.

Exporting the Node constructor out of smaller increases the performance so that the 2nd and 3rd test is more likely at 15ms than at 30ms. This has to do with how the JS Engine can optimize the code. Also prefilling the Array with 0 values sped up the code about tenfold.

But the differences should be smaller for short Arrays or Arrays with more than 100 different values.

Answer 3

OK, I've got your code to speed by doing some refactoring.

function BSTNode(val) {
    this.dup   = 1;
    this.left  = null;
    this.right = null;
    this.val   = val;
    this.count = 0;
}

var insert = (root, num, result, sum, i) => {
    if (root === null) {
        result[i] = sum;
        return new BSTNode(num);
    }

    if (root.val === num) {
        root.dup++;
        result[i] = sum + root.count;
    } else if (root.val > num) {
        root.count++;
        root.left = insert(root.left, num, result, sum, i);
    } else {
        root.right = insert(root.right, num, result, sum + root.count + root.dup, i);
    }
    return root;
}

function smaller(arr) {
    var result = Array(arr.length).fill(0);
    var root   = null;
    for (var i = arr.length; i--;)
        root = insert(root, arr[i], result, 0, i);
    return result;
}

I'd be curious to know that they throw at this function that it takes that long to compute. We're talking about 100 computations in 12 Seconds not 12ms. I'd guess big Arrays and lots of different values (either floats or using the whole range of ints, not just like 8 bit: 0 ... 255).

Still trying different approaches.