leetcode 315. 计算右侧小于当前元素的个数

leetcode 315. 计算右侧小于当前元素的个数

题目详情

题目链接
给定一个整数数组 nums，按要求返回一个新数组 counts。数组 counts 有该性质： counts[i] 的值是 nums[i] 右侧小于 nums[i] 的元素的数量。

• 示例:
  输入: [5,2,6,1]
  输出: [2,1,1,0]
  解释:
  5 的右侧有 2 个更小的元素 (2 和 1).
  2 的右侧仅有 1 个更小的元素 (1).
  6 的右侧有 1 个更小的元素 (1).
  1 的右侧有 0 个更小的元素.

我的代码

class Solution {
public:
    vector<int> countSmaller(vector<int>& nums) {
        int n = nums.size();
        vector<int> counts(n, 0);
        if (n < 2) {
            return counts;
        }
        list<int> sortNums;
        sortNums.push_back(nums[n - 1]);
        for (int i = n - 2; i >= 0; --i) {
            if (nums[i] <= *sortNums.begin()) {
                counts[i] = 0;
                sortNums.push_front(nums[i]);
                continue;
            }
            if (nums[i] > *(--sortNums.end())) {
                counts[i] = sortNums.size();
                sortNums.push_back(nums[i]);
                continue;
            }
            if (nums[i] <= ((*sortNums.begin() + *(--sortNums.end())) / 2)) {
                int count = 0;
                auto loc = sortNums.begin();
                while (loc != sortNums.end()) {
                    if (*loc >= nums[i]) {
                        break;
                    }
                    ++count, ++loc;
                }
                counts[i] = count;
                sortNums.insert(loc, nums[i]);
            } else {
                int count = sortNums.size();
                auto loc = --sortNums.end();
                while (loc != sortNums.begin()) {
                    if (*loc < nums[i]) {
                        ++loc;
                        break;
                    }
                    --count, --loc;
                }
                counts[i] = count;
                sortNums.insert(loc, nums[i]);
            }
        }
        return counts;
    }
};

我的成绩

执行结果：超出时间限制
16 / 16 个通过测试用例

一些想法

吐血，做了一个小时的优化，只是通过了第十五个测试用例，还差最后一个测试用例。

执行用时为 8 ms 的范例

struct BSTNode {
    int val;
    int count;//节点左子树的节点个数
    BSTNode *left;
    BSTNode *right;
    BSTNode (int x) : val(x), left(NULL), right(NULL), count(0) {}
};

class Solution {
public:
    vector<int> countSmaller(vector<int>& nums) {
        std::vector<int> result; //最终逆序数组
        std::vector<BSTNode *> node_vec;//二叉查找树的节点池
        std::vector<int> count;//从后向前插入过程中，比当前节点值小的count_small数组
        for (int i = nums.size() - 1; i >= 0; i--) {
            node_vec.push_back(new BSTNode(nums[i]));
        }
        count.push_back(0);

        for (int i = 1; i < node_vec.size(); i++) {
            int count_small = 0;
            BST_insert(node_vec[0], node_vec[i], count_small);
            count.push_back(count_small);
        }
        for (int i = node_vec.size() - 1;i >= 0; i--) {
            delete node_vec[i];
            result.push_back(count[i]);
        }
        return result;
    }

private:
    void BST_insert(BSTNode *node, BSTNode *insert_node, int &count_small) {  //node根节点，insert_node插入节点，
        if(insert_node->val <= node->val) {
            node->count++;
            if (node->left) {
                BST_insert(node->left, insert_node, count_small);
            } else {
                node -> left = insert_node;
            }
        } else {
            count_small += node->count + 1;
            if (node->right) {
                BST_insert(node->right, insert_node, count_small);
            } else {
                node->right = insert_node;
            }
        }
    }
};

思考

参见官方解答