Question

我创建了一个程序，它将生成一个带随机数的低三角矩阵。现在我需要以某种方式将我的结果传递给向量，然后使用线性搜索算法。

这是我的代码的一部分。

void lower_half(int arr[8][8], int r)
{
    int i, j;
    cout << "\n";
    for (i = 0; i<r; i++)
    {
        for (j = 0; j <= i; j++)
        {
            cout << arr[i][j] << " ";

        }
        cout << "\n";

    }
}
int main()
{

    int arr[8][8], i, j;
    int r = 8;




    for (int i = 0; i < r; ++i)
    {

        {
            for (int j = 0; j < r; ++j)
            arr[i][j] = (rand() % 44) + -30;

        }
    }

    lower_half(arr,  r);
    system("pause");


    return 0;

}

Answer 1

vector<int> to_vec(int arr[8][8], int r)
{
    int i, j;
    vector<int> vec;
    for (i = 0; i<r; i++)
    {
        for (j = 0; j <= i; j++)
        {
            vec.push_back(arr[i][j]);
        }
    }
    return vec;
}

int index_of(vector<int> vec, int n)
{
    for (i = 0; i<vec.size(); i++)
        if (vec[i]==n)
            return i;
    return -1;
}

Answer 2

你真的需要首先使用int arr [8] [8]吗？ 2D [8] [8]数组与1D [8 * 8]数组相同。因此，您最初可能会使用向量：

int find(std::vector<int>& arr, int value)
{
    auto it = std::find(arr.begin(), arr.end(), value);
    return it == arr.end() ? -1 : &*it - &*arr.begin();
}


int main()
{
    std::vector<int> arr(64, 0); // new vector, 64 elements, initialized to 0

    for (int& a : arr) // populate array with random numbers
        a = (rand() % 44) - 30;

    int index = find(arr, 12);

    return 0;
}

迭代器语法非常难看，但是代码的工作原理是创建一个64元素（8 * 8）数组并用随机数填充它 - 注意for (int& a : arr)语法，其中int& a是一个引用到arr中的元素。

如果您无法使用int [8] [8]，那么您可以使用此解决方法：

int matrix[8][8];
int* arrayPtr = (int*)matrix; // like I said, int[8][8] is the same as int[64]
                              // so treat it as an array pointer int*

std::vector<int> arr(arrayPtr, arrayPtr + 64); // treat arrayPtr as int[64]

如果您以后遇到索引数组的问题，请不要担心：

for (int i = 0; i < 8; ++i)
    for (int j = 0; j < 8; ++j)
        printf("[%d][%d] = %d\n", i, j, arr[i*8 + j]);

将具有三角矩阵的数组转换为向量并实现线性搜索

2 个答案: