我面临着一个问题，两个二维数组需要根据给定的条件进行合并，其中的 n=5 和 k=3.
第1阵列>
1 2
3 4
5 6
7 8
9 10
第2个数组->
11 12 13
14 15 16
17 18 19
20 21 22
23 24 25
结果数组->。
1 2 11 12 13
3 4 14 15 16
5 6 17 18 19
7 8 20 21 22
9 10 23 24 25
我对这个问题的处理方法是，首先取一个空的二维数组，上面有两个数组维度，然后将两个数组元素放入到 ans 数组的索引。我可以把第一个数组放到 ans 数组，但未能将第2个数组放入结果数组中。在插入第2个数组时显示运行时错误。我需要帮助。
#include <iostream>
using namespace std;
int main()
{
int n, k;
cin >> n >> k;
int p = n - k + 1, q = n - k;
int a[n + 1][q + 1], b[n + 1][p + 1], ans[n + 1][n + 1];
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= q; ++j)
a[i][j] = 0;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= p; ++j)
b[i][j] = 0;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
ans[i][j] = 0;
int x = 1;
for (int i = 1; i <= n; ++i)
{
for (int j = 1; j <= q; ++j)
a[i][j] = x++;
}
for (int i = 1; i <= n; ++i)
{
for (int j = 1; j <= p; ++j)
b[i][j] = x++;
}
for (int i = 1; i <= n; ++i)
{
for (int j = 1; j <= q; ++j)
ans[i][j] = a[i][j];
}
int I = 1, J = 0;
for (int i = 1; i <= n; ++i)
{
I += 2, J++;
for (int j = 1; j <= p; ++j)
{
ans[I][J] = b[i][j];
I++;
}
}
for (int i = 1; i <= n; ++i)
{
for (int j = 1; j <= q; ++j)
cout << a[i][j] << " ";
cout << endl;
}
for (int i = 1; i <= n; ++i)
{
for (int j = 1; j <= p; ++j)
cout << b[i][j] << " ";
cout << endl;
}
for (int i = 1; i <= n; ++i)
{
for (int j = 1; j <= n; ++j)
cout << ans[i][j] << " ";
cout << endl;
}
return 0;
}
在发布的代码中，主要有三个问题
a, b 和 ans 声明为可变长度的数组(编译时不知道它们的大小)，一个 非标准 扩展，由一些编译器提供。OP可以使用一个标准的容器，比如 std::vector 或用户定义的类。
所有的循环都从1开始，而在C++中数组的索引是基于0的。这段代码的作者似乎知道这个事实，但出于某种原因，他更愿意在所有的数组中分配额外的(未使用的)空间，并相应地满足术语条件。
嵌套循环试图将数组中的值从 b 到 ans 是完全错误的，会导致多次访问出界。
int I = 1, J = 0; // ---> I = 0, keeping OP's convention
for (int i = 1; i <= n; ++i)
{
I += 2, J++; // ---> ++I, J = q
for (int j = 1; j <= p; ++j)
{
ans[I][J] = b[i][j];
I++; // ---> ++J
}
}
在下面的代码段中，显示了一个替代的实现，其中矩阵使用一个类和 merge 函数执行想要的操作。
#include <algorithm>
#include <iomanip>
#include <iostream>
#include <numeric>
#include <stdexcept>
#include <vector>
template <class T>
class Matrix
{
size_t rows_{};
size_t cols_{};
std::vector<T> m_;
public:
Matrix() = default;
Matrix(size_t r, size_t c)
: rows_{r}, cols_{c}, m_(r * c)
{}
auto rows() const noexcept {
return rows_;
}
auto columns() const noexcept {
return cols_;
}
auto operator[] (size_t i) noexcept {
return m_.begin() + cols_ * i;
}
auto operator[] (size_t i) const noexcept {
return m_.cbegin() + cols_ * i;
}
auto begin() noexcept {
return m_.begin();
}
auto end() noexcept {
return m_.end();
}
};
template <class T>
std::ostream& operator<< (std::ostream& os, Matrix<T> const& m)
{
for (size_t i{}; i < m.rows(); ++i)
{
for (size_t j{}; j < m.columns(); ++j)
os << m[i][j] << ' ';
os << '\n';
}
return os;
}
template<class T>
auto merge(Matrix<T> const& a, Matrix<T> const& b)
{
if (a.rows() != b.rows())
throw std::runtime_error{"Number of rows mismatch"};
Matrix<T> result(a.rows(), a.columns() + b.columns());
for (size_t i{}; i < a.rows(); ++i)
{
auto it = std::copy(a[i], a[i] + a.columns(), result[i]);
std::copy(b[i], b[i] + b.columns(), it);
}
return result;
}
int main()
{
int n, k;
std::cin >> n >> k;
int p = n - k + 1, q = n - k;
Matrix<int> a(n, q);
std::iota(a.begin(), a.end(), 1);
std::cout << a << '\n';
Matrix<int> b(n, p);
std::iota(b.begin(), b.end(), n * q + 1);
std::cout << b << '\n';
auto c = merge(a, b);
std::cout << c << '\n';
}
所以你有3个矩阵，每个矩阵都有 n 行。
第一个矩阵有 m=2 列。
第二个矩阵有 k=3 列。
第三个矩阵（合并后的矩阵）有 m+k 列。
你的代码应该是这样的。
#include <iostream>
using namespace std;
int main()
{
const int k=3;
const int m=2;
const int n=5;
int arr1[n][m];
int arr2[n][k];
int arr3[n][m+k];
for(int i=0; i<n; i++)
for (int j=0; j<m; j++)
arr1[i][j]=1+2*i+j;
for(int i=0; i<n; i++)
for (int j=0; j<k; j++)
arr2[i][j]=11+3*i+j;
for(int i=0; i<n; i++)
for (int j=0; j<n; j++){
if(j<m)
arr3[i][j]=arr1[i][j];
else
arr3[i][j]=arr2[i][j-m];
}
for(int i=0; i<n; i++){
for (int j=0; j<n; j++)
cout<< arr3[i][j]<<" ";
cout<<endl;
}
}
这是一个方法... ... 我已经把它做得足够通用，它可以处理行数不相等的数组。 未填充的点被初始化为零。
MATRIX.h -- MATRIX'对象'的头文件。
#ifndef _MATRIX_H_
#define _MATRIX_H_
typedef struct matrix {
int rows;
int cols;
int elemSize;
void *data;
} *MATRIX;
int MATRIX_Create( MATRIX *handlePtr, int initElemSize,
int initRows, int initCols );
int MATRIX_Close( MATRIX *handlePtr );
int MATRIX_Set( MATRIX handle, int row, int col, void *data );
void *MATRIX_GetAddr( MATRIX handle, int row, int col );
int MATRIX_Get( MATRIX handle, int row, int col, void *retData );
int MATRIX_Merge( MATRIX *newHandlePtr, MATRIX leftHandle, MATRIX rightHandle );
#endif
MATRIX.c -- MATRIX "对象 "的源文件；
#include <stdio.h>
#include <malloc.h>
#include <memory.h>
#include "MATRIX.h"
#define MAX(x,y) ((x > y) ? x : y)
int MATRIX_Create( MATRIX *handlePtr, int initElemSize, int initRows, int initCols )
{
MATRIX handle;
if (handlePtr == NULL)
return (-1);
handle = calloc(sizeof(struct matrix), 1);
if (handle == NULL)
return (-2);
handle->data = calloc(initElemSize, initRows * initCols);
if (handle->data == NULL) {
printf("ERROR -- Could not create MATRIX data area\n");
free(handle);
return (-3);
}
handle->rows = initRows;
handle->cols = initCols;
handle->elemSize = initElemSize;
*handlePtr = handle;
return (0);
}
int MATRIX_Close( MATRIX *handlePtr )
{
if (handlePtr == NULL)
return (-1);
free(*handlePtr);
*handlePtr = NULL;
return (0);
}
int MATRIX_Set( MATRIX handle, int row, int col, void *data )
{
unsigned char *addr;
int addrOffset;
if ((handle == NULL) || (data == NULL))
return (-1);
addr = handle->data;
addrOffset = row * handle->cols * handle->elemSize + (col * handle->elemSize);
addr += addrOffset;
memcpy(addr, data, handle->elemSize);
return (0);
}
void *MATRIX_GetAddr( MATRIX handle, int row, int col )
{
unsigned char *addr;
int addrOffset;
if (handle == NULL)
return (NULL);
addr = handle->data;
addrOffset = row * handle->cols * handle->elemSize + (col * handle->elemSize);
addr += addrOffset;
return (addr);
}
int MATRIX_Get( MATRIX handle, int row, int col, void *retData )
{
unsigned char *addr;
int addrOffset;
if ((handle == NULL) || (retData == NULL))
return (-1);
addr = MATRIX_GetAddr(handle, row, col);
memcpy(retData, addr, handle->elemSize);
return (0);
}
int MATRIX_Merge( MATRIX *newHandlePtr, MATRIX leftHandle, MATRIX rightHandle )
{
int i;
int j;
MATRIX retHandle;
int retCols;
int retRows;
int result;
if ((newHandlePtr == NULL) || (leftHandle == NULL) || (rightHandle == NULL))
return (-1);
/* Ensure that the element sizes for the two matrices to be merged are the same */
if (leftHandle->elemSize != rightHandle->elemSize)
return (-2);
retCols = leftHandle->cols + rightHandle->cols;
retRows = MAX(leftHandle->rows, rightHandle->rows);
result = MATRIX_Create(&retHandle, leftHandle->elemSize, retRows, retCols);
if (result != 0)
return (-3);
/* First copy the left matrix into the merged array */
for (i = 0; i < leftHandle->rows; i++) {
for (j = 0; j < leftHandle->cols; j++) {
result = MATRIX_Set(retHandle, i, j, MATRIX_GetAddr(leftHandle, i, j));
if (result != 0) {
printf("ERROR -- MATRIX_Set() returned %d\n", result);
free(retHandle->data);
free(retHandle);
return (result);
}
}
}
/* And then copy the right matrix into the merged array */
for (i = 0; i < rightHandle->rows; i++) {
for (j = 0; j < rightHandle->cols; j++) {
result = MATRIX_Set(retHandle, i, j+leftHandle->cols, MATRIX_GetAddr(rightHandle, i, j));
if (result != 0) {
printf("ERROR -- MATRIX_Set() returned %d\n", result);
free(retHandle->data);
free(retHandle);
return (result);
}
}
}
*newHandlePtr = retHandle;
return (0);
}
矩阵测试.c -- 测试代码的主程序文件
#include <stdio.h>
#include <malloc.h>
#include <memory.h>
#define MAX(x,y) ((x > y) ? x : y)
int MergeArray2D( int **retArrayPtr, int *retRowsPtr, int *retColsPtr,
int *leftArray, int leftRows, int leftCols,
int *rightArray, int rightRows, int rightCols )
{
int *retArray;
int i;
int j;
int retCols;
int retRows;
if ((retArrayPtr == NULL) || (retColsPtr == NULL) || (retRowsPtr == NULL) || (leftArray == NULL))
return (-1);
retCols = leftCols + rightCols;
retRows = MAX(leftRows, rightRows);
retArray = calloc(sizeof(int), retRows * retCols);
if (retArray == NULL)
return (-2);
/* First copy the left array into the merged array */
for (i = 0; i < leftRows; i++) {
for (j = 0; j < leftCols; j++) {
retArray[i * retCols + j] = leftArray[i * leftCols + j];
}
}
/* And then copy the right array into the merged array */
for (i = 0; i < rightRows; i++) {
for (j = 0; j < rightCols; j++) {
retArray[i*retCols + j + leftCols] = rightArray[i * rightCols + j];
}
}
*retArrayPtr = retArray;
*retColsPtr = retCols;
*retRowsPtr = retRows;
return (0);
}
void PrintArray2D( int *array, int numRows, int numCols )
{
int i;
int j;
for (i = 0; i < numRows; i++) {
for (j = 0; j < numCols; j++) {
printf(" %5d", array[i * numCols + j]);
}
printf("\n");
}
}
int main( int argc, char **argv )
{
int leftRows = 5;
int leftCols = 2;
int leftArray[5][2];
int rightRows = 6;
int rightCols = 3;
int rightArray[6][3];
int i;
int j;
int count;
int result;
int *newArray;
int newRows;
int newCols;
MATRIX leftMatrix;
MATRIX rightMatrix;
MATRIX newMatrix;
printf("sizeof(void *) = %d\n", sizeof(void *));
printf("sizeof(int) = %d\n\n", sizeof(int));
count = 0;
/* Initialize the left array */
for (i = 0; i < leftRows; i++) {
for (j = 0; j < leftCols; j++) {
count++;
leftArray[i][j] = count;
}
}
/* Initialize the right array */
for (i = 0; i < rightRows; i++) {
for (j = 0; j < rightCols; j++) {
count++;
rightArray[i][j] = count;
}
}
/* Print out the left array */
printf("Left Array:\n");
PrintArray2D((int *) leftArray, leftRows, leftCols);
/* Print out the right array */
printf("\nRight Array:\n");
PrintArray2D((int *) rightArray, rightRows, rightCols);
/* Merge the two arrays */
result = MergeArray2D(&newArray, &newRows, &newCols, (int *) leftArray, leftRows, leftCols, (int *) rightArray, rightRows, rightCols);
if (result != 0) {
printf("ERROR -- MergeArrays2D() returned %d\n", result);
}
/* Print out the merged array */
printf("\nMerged Array:\n");
PrintArray2D(newArray, newRows, newCols);
/* Clean up the allocated merged array when through using it */
free(newArray);
/* And now for a way of doing the same thing with the MATRIX object */
printf("\n\nTrying same thing using MATRIX object\n\n");
result = MATRIX_Create(&leftMatrix, sizeof(int), leftRows, leftCols);
if (result != 0) {
printf("ERROR -- MATRIX_Create(leftMatrix) returned %d\n", result);
return (result);
}
result = MATRIX_Create(&rightMatrix, sizeof(int), rightRows, rightCols);
if (result != 0) {
printf("ERROR -- MATRIX_Create(rightMatrix) returned %d\n", result);
return (result);
}
/* Initialize the left matrix */
count = 0;
for (i = 0; i < leftMatrix->rows; i++) {
for (j = 0; j < leftMatrix->cols; j++) {
count++;
result = MATRIX_Set(leftMatrix, i, j, &count);
if (result != 0)
printf("ERROR -- Could not set element %d,%d\n", i, j);
}
}
/* Print out the left matrix */
printf("\nLeft Matrix[rows=%d,cols=%d,elemSize=%d]:\n", leftMatrix->rows, leftMatrix->cols, leftMatrix->elemSize);
PrintArray2D(leftMatrix->data, leftMatrix->rows, leftMatrix->cols);
/* Initialize the right matrix */
for (i = 0; i < rightMatrix->rows; i++) {
for (j = 0; j < rightMatrix->cols; j++) {
count++;
result = MATRIX_Set(rightMatrix, i, j, &count);
}
}
/* Print out the right matrix */
printf("\nRight Matrix[rows=%d,cols=%d,elemSize=%d]:\n", rightMatrix->rows, rightMatrix->cols, rightMatrix->elemSize);
PrintArray2D(rightMatrix->data, rightMatrix->rows, rightMatrix->cols);
/* Merge the two matrices */
result = MATRIX_Merge(&newMatrix, leftMatrix, rightMatrix);
if (result != 0) {
printf("ERROR -- MATRIX_Merge() returned %d\n", result);
return (result);
}
/* Print out the new matrix */
printf("\nMerged Matrix[rows=%d,cols=%d,elemSize=%d]:\n", newMatrix->rows, newMatrix->cols, newMatrix->elemSize);
PrintArray2D(newMatrix->data, newMatrix->rows, newMatrix->cols);
/* Cleanup the newMatrix when finished */
result = MATRIX_Close(&newMatrix);
}
测试程序的输出。
sizeof(void *) = 4
sizeof(int) = 4
Left Array:
1 2
3 4
5 6
7 8
9 10
Right Array:
11 12 13
14 15 16
17 18 19
20 21 22
23 24 25
26 27 28
Merged Array:
1 2 11 12 13
3 4 14 15 16
5 6 17 18 19
7 8 20 21 22
9 10 23 24 25
0 0 26 27 28
Trying same thing using MATRIX object
Left Matrix[rows=5,cols=2,elemSize=4]:
1 2
3 4
5 6
7 8
9 10
Right Matrix[rows=6,cols=3,elemSize=4]:
11 12 13
14 15 16
17 18 19
20 21 22
23 24 25
26 27 28
Merged Matrix[rows=6,cols=5,elemSize=4]:
1 2 11 12 13
3 4 14 15 16
5 6 17 18 19
7 8 20 21 22
9 10 23 24 25
0 0 26 27 28
为了使这是一个通用的解决方案，我把2D数组看作是一个1D数组，因为它们在内存中就是这样排列的。 如果你不想要一个通用的解决方案，你应该很容易修改代码，你不会有那么多的参数需要传递到MergeArray2D函数中。
EDITED:我已经添加了一个更通用的解决方案，通过创建一个MATRIX'对象'的'C'版本，就像我在休斯顿的一个航空航天承包商为NASA工作时，我们用来实现'对象'一样。 我还将'对象'的头文件和源文件分割成独立的代码窗口，以便于阅读。 对于任何一个C++的人来说，将其转换为C++类可能是一件小事，但我认为从教学的角度来看，直接用 "C "更好。 这个'对象'允许用不同的基本元素数据大小来'实例化'，而不是第一个例子中使用的'int'。 我在电脑上用gcc测试了这段代码，它确实能正确编译和运行。 希望这能帮到你...