C++在顺序的复数向量中，实现区间查找算法，查找出模介于[m1,m2) 的所有元素，按序存于一个子向量中作为返回值。

假设顺序的复数向量为vector<complex<double>>，可以使用STL中的copy_if函数，结合lambda表达式，实现区间查找算法。具体实现如下：

vector<complex<double>> find_complex(const vector<complex<double>>& v, double m1, double m2) {
vector<complex<double>> res;
copy_if(v.begin(), v.end(), back_inserter(res), [m1, m2](const complex<double>& c) {
double mod = abs(c);
return mod >= m1 && mod < m2;
});
return res;
}

其中，lambda表达式的[=](const complex<double>& c) {}部分为判断条件，mod = abs(c)为计算复数c的模，判断是否满足模介于[m1,m2)的条件，如果满足则返回true，将该元素复制到结果子向量中。最后返回结果子向量res。

相关问题

C++（3）在顺序的复数向量中，实现区间查找算法，查找出模介于[m1,m2) 的所有元素，按序存于一个子向量中作为返回值。

以下是C语言代码实现：

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

typedef struct {
    double real;  // 实部
    double imag;  // 虚部
} complex;

void find_interval(complex *vec, int size, double m1, double m2, complex **result, int *result_size) {
    *result_size = 0;
    *result = (complex *)malloc(size * sizeof(complex));  // 分配足够大的空间
    for (int i = 0; i < size; i++) {
        double mod = sqrt(vec[i].real * vec[i].real + vec[i].imag * vec[i].imag);  // 计算模
        if (mod >= m1 && mod < m2) {  // 满足条件，加入结果中
            (*result)[*result_size].real = vec[i].real;
            (*result)[*result_size].imag = vec[i].imag;
            (*result_size)++;
        }
    }
}

int main() {
    complex vec[] = {{1, 2}, {3, 4}, {5, 6}, {7, 8}, {9, 10}};
    int size = sizeof(vec) / sizeof(vec[0]);
    double m1 = 3, m2 = 9;
    complex *result;
    int result_size;
    find_interval(vec, size, m1, m2, &result, &result_size);
    printf("Elements in the interval [%g, %g):\n", m1, m2);
    for (int i = 0; i < result_size; i++) {
        printf("%g + %gi\n", result[i].real, result[i].imag);
    }
    free(result);
    return 0;
}

运行结果如下：

Elements in the interval [3, 9):
3 + 4i
5 + 6i
7 + 8i

C++定义一个复数类，随机生成一个无序的复数向量（有重复项在顺序的复数向量中，实现区间查找算法，查找出模介于[m1,m2) 的所有元素，按序存于一个子向量中作为返回值。

复数类的定义：

#include <iostream>
#include <vector>
#include <cstdlib>
#include <ctime>
#include <algorithm>
using namespace std;

class Complex {
private:
    double real;
    double imag;
public:
    Complex(double r = 0, double i = 0):real(r), imag(i){}
    double getReal() const { return real; }
    double getImag() const { return imag; }
    double getModule() const { return sqrt(real*real + imag*imag); }
    bool operator<(const Complex& c) const { return getModule() < c.getModule(); }
    bool operator>=(const Complex& c) const { return getModule() >= c.getModule(); }
    friend ostream& operator<<(ostream& os, const Complex& c) {
        os << "(" << c.real << ", " << c.imag << ")";
        return os;
    }
};

随机生成一个无序的复数向量：

vector<Complex> generateRandomComplexVector(int n) {
    vector<Complex> vec;
    srand(time(nullptr));
    for (int i = 0; i < n; i++) {
        double real = (double)(rand() % 100) - 50;
        double imag = (double)(rand() % 100) - 50;
        vec.push_back(Complex(real, imag));
    }
    return vec;
}

区间查找算法：

vector<Complex> findComplexModuleInRange(const vector<Complex>& vec, double m1, double m2) {
    vector<Complex> subVec;
    for (auto it = vec.begin(); it != vec.end(); it++) {
        if (*it >= Complex(m1) && *it < Complex(m2)) {
            subVec.push_back(*it);
        }
    }
    return subVec;
}

完整代码：

#include <iostream>
#include <vector>
#include <cstdlib>
#include <ctime>
#include <algorithm>
using namespace std;

class Complex {
private:
    double real;
    double imag;
public:
    Complex(double r = 0, double i = 0):real(r), imag(i){}
    double getReal() const { return real; }
    double getImag() const { return imag; }
    double getModule() const { return sqrt(real*real + imag*imag); }
    bool operator<(const Complex& c) const { return getModule() < c.getModule(); }
    bool operator>=(const Complex& c) const { return getModule() >= c.getModule(); }
    friend ostream& operator<<(ostream& os, const Complex& c) {
        os << "(" << c.real << ", " << c.imag << ")";
        return os;
    }
};

vector<Complex> generateRandomComplexVector(int n) {
    vector<Complex> vec;
    srand(time(nullptr));
    for (int i = 0; i < n; i++) {
        double real = (double)(rand() % 100) - 50;
        double imag = (double)(rand() % 100) - 50;
        vec.push_back(Complex(real, imag));
    }
    return vec;
}

vector<Complex> findComplexModuleInRange(const vector<Complex>& vec, double m1, double m2) {
    vector<Complex> subVec;
    for (auto it = vec.begin(); it != vec.end(); it++) {
        if (*it >= Complex(m1) && *it < Complex(m2)) {
            subVec.push_back(*it);
        }
    }
    return subVec;
}

int main() {
    vector<Complex> vec = generateRandomComplexVector(10);
    cout << "Original Vector: ";
    for (auto i : vec) {
        cout << i << " ";
    }
    cout << endl;

    double m1 = 10, m2 = 20;
    vector<Complex> subVec = findComplexModuleInRange(vec, m1, m2);
    cout << "Sub Vector with Module in [" << m1 << ", " << m2 << "): ";
    for (auto i : subVec) {
        cout << i << " ";
    }
    cout << endl;
    return 0;
}