LeetCode #315. Count of Smaller Numbers After Self

最新推荐文章于 2024-11-30 15:12:41 发布

原创最新推荐文章于 2024-11-30 15:12:41 发布 · 123 阅读

0 ·

CC 4.0 BY-SA版权

LeetCode 专栏收录该内容

625 篇文章

订阅专栏

本文介绍了一种算法，用于解决给定整数数组中，每个元素右侧有多少个比它小的元素的问题。通过构建一棵二叉搜索树，每次插入元素时统计小于当前元素的节点数量，从而得到最终的计数数组。

题目描述：

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 of nums[i].

Example:

Input: [5,2,6,1]
Output: [2,1,1,0] 
Explanation:

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.

class Node {
public:    
    int val;
    int count; // 数组可能存在相同数值，用count记录插入个数
    int left_size; // 左子树节点个数
    Node* left;
    Node* right;
    Node(int x, int y)
    {
        val=x;
        count=y;
        left_size=0;
        left=NULL;
        right=NULL;
    }
};

class Solution {
public:
    vector<int> countSmaller(vector<int>& nums) {
        if(nums.size()==0) return {};
        vector<int> result(nums.size());
        Node* root=new Node(nums.back(),1);
        result.back()=0;
        for(int i=nums.size()-2;i>=0;i--)
            result[i]=insert(root,nums[i]);
        return result;
    }
    
    // 将值为val的节点插入树中，返回树中小于val的节点数，并更新left_size和count
    int insert(Node* root, int val)
    {
        if(root->val>val)
        {
            root->left_size++;
            if(root->left==NULL)
            {
                root->left=new Node(val,1);
                return 0;
            }
            else return insert(root->left,val);
        }
        else if(root->val<val)
        {
            if(root->right==NULL)
            {
                root->right=new Node(val,1);
                return root->left_size+root->count;
            }
            else return root->left_size+root->count+insert(root->right,val);
        }
        else
        {
            root->count++;
            return root->left_size;
        }
    }
    
private:
    Node* root;
};