Question

我有一个蚂蚁任务，要在向量数组中搜索最频繁的奇数。我想不通。

这就是我将数据写入数组的方式

#include <iostream>
#include <vector>
#include <fstream>

using namespace std;

class oddNum {
    private:
    vector <int> numbers;
    int number, n;

    public:
    void getData() {
        cin >> n;

        for (int i = 0; i < n; ++i) {
            cin >> number;
            if(number % 2 != 0) {
                numbers.push_back(number);
            }
        }
    }
};

int main() {
    oddNum n;
    n.getData();
    return 0;
}

我的电话号码

8 5 5 1 3

Answer 1

There are several ways to do it, I show you two. The first one is not intuitive and requires quite the bookmarking. However, the last solution uses the modern containers and their nature to do this in an elegant style.

First you sort the vector. This way all equal elements are next to each other. Than you iterate through this vector to look for the largest pack of elements while skipping all even numbers. Create a variable counter which resets if the elements change (this can be done by comparing the current element to the next element of the array) and a max variable that holds the largest value of said counter. Whenever this counter exceeds the value of max you have found the most common element so far which can be saved in a variable result. When you're done iterating, the variable result will contain the most frequent odd element of the vector. This implementation, in addition to <vector>, also needs the <algorithm> and <cassert> headers.

int get_most_frequent_odd(const std::vector<int>& vec) {
    assert(!vec.empty());

    std::vector<int> sorted = vec;
    std::sort(sorted.begin(), sorted.end());

    unsigned counter = 0u;
    unsigned max = 0u;
    int result;    

    for (unsigned i = 0u; i < sorted.size() - 1; ++i) {
        if (sorted[i] % 2 != 0) {
            if (sorted[i] == sorted[i + 1]) {
                ++counter;
                if (max < counter) {
                    max = counter;
                    counter = 0u;
                    result = sorted[i];
                }
            }
            else {
                counter = 0u;
            }
        }
    }
    return result;
}

The function is quite specific (only for int's and odd elements). Also your getData() function already sorts out all even numbers. So here's a more generic function get_most_frequent<T>:

template<typename T>
T get_most_frequent(const std::vector<T>& vec) {
    assert(!vec.empty());

    std::vector<T> sorted = vec;
    std::sort(sorted.begin(), sorted.end());

    unsigned counter = 0u;
    unsigned max = 0u;
    T result;


    for (unsigned i = 0u; i < sorted.size() - 1; ++i){
        if (sorted[i] == sorted[i + 1]) {
            ++counter;
            if (max < counter) {
                max = counter;
                counter = 0u;
                result = sorted[i];
            }
        }
        else {
            counter = 0u;
        }
    }
    return result;
}

Now a std::unordered_map or std::map will be superior over a std::vector for this task as they are build in a way that allows you to skip this ugly bookmarking. It's way more readable, too. But given you said you are a beginner I didn't put this at first place. The idea is to count the frequency by using a std::unordered_map. The elements are set to be the keys of the map and incrementing the values behind the keys will give you the occurrency of the elements. (Thanks @YSC) You can now use std::max_element which will return the pair with the highest saved occurrence. This implementation requires the <unordered_map>, <utility>, <algorithm> and <cassert> headers.

template<typename T>
T get_most_frequent(const std::vector<T>& vec) {
    std::unordered_map<T, int> frequency_map;
    for (auto i : vec) {
        ++frequency_map[i];
    }
    return std::max_element(frequency_map.begin(), frequency_map.end())->first;
}

example run using either of these 3 functions:

how many numbers?: 8
input number 1: 5
input number 2: 5
input number 3: 4
input number 4: 9
input number 5: 9
input number 6: 9
input number 7: 11
input number 8: 0
most common element is: 9

full code:

#include <iostream>
#include <unordered_map>
#include <vector>
#include <algorithm>
#include <cassert>

template<typename T>
T get_most_frequent(const std::vector<T>& vec) {
    std::unordered_map<T, int> frequency_map;
    for (auto i : vec) {
        ++frequency_map[i];
    }
    return std::max_element(frequency_map.begin(), frequency_map.end())->first;
}


class oddNum {
private:
    std::vector<int> numbers;
public:
    void getData() {
        std::size_t size;
        std::cout << "how many numbers?: ";
        std::cin >> size;

        int number;
        for (int i = 0; i < size; ++i) {
            std::cout << "input number " << i + 1 << ": ";
            std::cin >> number;
            if (number % 2 != 0) {
                numbers.push_back(number);
            }
        }

        std::cout << "most common element is: " << get_most_frequent(numbers) << '\n';
    }
};


int main() {
    oddNum n;
    n.getData();
}

在向量中找到最频繁的奇数？

1 个答案: