Count of Smaller Numbers After Self

You are given an integer array nums and you have to return a new counts array.The counts array has the property where counts[i] is the number of smaller elements to the right ofnums[i].

Example:

Given nums = [5, 2, 6, 1]

To the right of 5 there are 2 smaller elements (2 and 1).
To the right of 2 there is only 1 smaller element (1).
To the right of 6 there is 1 smaller element (1).
To the right of 1 there is 0 smaller element.

Return the array [2, 1, 1, 0].

class Solution {
struct node{
    int val,copy,leftCnt;
    node *left,*right;
    node(int x){val=x;copy=1;leftCnt=0;left=NULL;right=NULL;}
};


public:
    vector<int> countSmaller(vector<int>& nums) {
        int curSum;
        int sz = nums.size();
        vector<int> r(sz,0);
        if(sz <= 1) return r; 
        node *root = new node(nums[sz-1]);
        node *t;
        node *pos;
        int v;
        for (int i=sz-2;i>=0;i--){
            curSum = 0;
            t = root;
            v = nums[i];
            
            while(t){
                pos = t;
                if(v < t->val){
                    t->leftCnt++;
                    t = t->left;
                } 
                else if(v == t->val){
                    t->copy++;
                    curSum += t->leftCnt;
                    break;
                }
                else {
                    curSum += (t->leftCnt + t->copy);
                    t = t->right;
                }
            }
            
            if(v < pos->val){
                pos->left = new node(v);
            }
            else if(v > pos->val){
                pos->right = new node(v);
            }
            
            r[i] = curSum;
        }
        return r;
    }
};

没有释放内存