Count smaller elements on right side in an array.

Count smaller elements on right side in an array.

eg : [4,12,5,6,1,34,3,2]
o/p: [3,5,3,3,0,2,1,0]

A1: 设原数组为a[i]，output 的数组为b[i]

1. 从右开始向左扫描

2. 假设已经扫描到i，则遍历从a[i+1] 开始，到结束的所有数，找到j，使得 a[i] > a[j], 并且 a[j] 值最大，则b[i] = b[j] + 1; 如果没有找到这样的数，即后面所有的数a[i] < a[j]，则b[i] = 0;

该方向时间复杂度为O(n^2)

下面的方法是O(nlog2n)的方法

A2: 

1. 建立一个BST，该BST能够提供比当前数要小的数的数目。

2. 从右向左扫描，每扫描一个数，将之添加到BST中，然后通过BST返回比当前添加数小的数的数目

代码如下：

struct BST {
    Node* root;
    
    BST()
        : root(0)
    {
    }
    
    int insert_element(int value);
};

int BST::insert_element(int value)
{
    if (0 == root) {
        root = new Node(value);
        return 0;
    }
    int result = 0;
    Node* runner = root;
    while (0 != runner) {
        if (runner->value < value) {
            ++result;
            result += runner->num_of_lefts; // 因为在root->right的所有结点的num_of_lefts==0,所以，这里++result;result+=runner->num_of_lefts;能够正常运算
            if (0 == runner->right) {
                runner->right = new Node(value);
                return result;
            } else {
                runner = runner->right;
            }
        } else {
            ++runner->num_of_lefts; //左侧的结点，num_of_lefts需要校正值，所以 ++runner->num_of_lefts
            if (0 == runner->left) {
                runner->left = new Node(value);
                return result;
            } else {
                runner = runner->left;
            }
        }
    }
    return 0;
}