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

题目意思：给出一个数组你需要返回后面的数比数组里各自的数小的个数，组成一个count数组 ，例子上面有。

解题思路：暴力解法就是来两个for循环，第二个循环从当前下标的下一个开始与其当前比较遍历，但是这样的话，时间复杂度是O(n²)，会超时不通过leetCode；另一种想法是这样：用vector去储存一对pair<int value,int postion>,pair里左边是数组中值，第二个是值对应的下标。采用分治->合并的方法去计算每次两两合并后当前合并后数组的position位置对应比较的count是多少，接着递归到下一个归并过程中。

#include <stdio.h>

#include <vector>
class Solution {
public:
    std::vector<int> countSmaller(std::vector<int>& nums) {
        std::vector<std::pair<int, int> > vec;
        std::vector<int> count;
        for (int i = 0; i < nums.size(); i++){
            vec.push_back(std::make_pair(nums[i], i));
            count.push_back(0);
        }
        merge_sort(vec, count);
        return count;
    }
private:
    void merge_sort_two_vec(
                std::vector<std::pair<int, int> > &sub_vec1,
                std::vector<std::pair<int, int> > &sub_vec2,
                std::vector<std::pair<int, int> > &vec,
                std::vector<int> &count){
        int i = 0;
        int j = 0;
        while(i < sub_vec1.size() && j < sub_vec2.size()){
            if (sub_vec1[i].first <= sub_vec2[j].first){
                count[sub_vec1[i].second] += j;
                vec.push_back(sub_vec1[i]);
                i++;
            }
            else{
                vec.push_back(sub_vec2[j]);
                j++;
            }
        }
        for (; i < sub_vec1.size(); i++){
            count[sub_vec1[i].second] += j;
            vec.push_back(sub_vec1[i]);
        }
        for (; j < sub_vec2.size(); j++){
            vec.push_back(sub_vec2[j]);
        }
    }
    void merge_sort(std::vector<std::pair<int, int> > &vec,
                    std::vector<int> &count){
        if (vec.size() < 2){
            return;
        }
        int mid = vec.size() / 2;
        std::vector<std::pair<int, int> > sub_vec1;
        std::vector<std::pair<int, int> > sub_vec2;
        for (int i = 0; i < mid; i++){
            sub_vec1.push_back(vec[i]);
        }
        for (int i = mid; i < vec.size(); i++){
            sub_vec2.push_back(vec[i]);
        }
        merge_sort(sub_vec1, count);
        merge_sort(sub_vec2, count);
        vec.clear();
        merge_sort_two_vec(sub_vec1, sub_vec2, vec, count);
    }
};

int main(){
    int test[] = {5, -7, 9, 1, 3, 5, -2, 1};
    std::vector<int> nums;
    for (int i = 0; i < 8; i++){
        nums.push_back(test[i]);
    }
    Solution solve;
    std::vector<int> result = solve.countSmaller(nums);
    for (int i = 0; i < result.size(); i++){
        printf("[%d]", result[i]);
    }
    printf("
");
    return 0;
}

通过~

 方法二：

学习了二叉排序树的数据结构，觉得这个方法比较好想，记录一下。

#include <stdio.h>

#include <vector>
struct BSTNode {
    int val;
    int count;
    BSTNode *left;
    BSTNode *right;
    BSTNode(int x) : val(x), left(NULL), right(NULL), count(0) {}
};

void BST_insert(BSTNode *node, BSTNode *insert_node, int &count_small){
    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;
        }
    }
}

class Solution {
public:
    std::vector<int> countSmaller(std::vector<int>& nums) {
        std::vector<int> result;
        std::vector<BSTNode *> node_vec;
        std::vector<int> count;
        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;
    }
};

int main(){
    int test[] = {5, -7, 9, 1, 3, 5, -2, 1};
    std::vector<int> nums;
    for (int i = 0; i < 8; i++){
        nums.push_back(test[i]);
    }
    Solution solve;
    std::vector<int> result = solve.countSmaller(nums);
    for (int i = 0; i < result.size(); i++){
        printf("[%d]", result[i]);
    }
    printf("
");
    return 0;
}