帶變量的矩陣C

Question

我打算用僞代碼寫出來，使我的問題更清楚。請記住，該代碼將在C中完成。

想象一下，我有任意數量的數組。第一個數字告訴我我們正在處理的數組有多大。例如，如果我的第一個數字是3，這意味着我有兩個3x3矩陣。所以，我創建了有兩個多維數組：

matrix1[3][3] 
matrix2[3][3] 

我有一個困難時期是算術/編碼，所有的號碼分配給矩陣什麼，我有一個非常困難的時期可視化它將如何做完了。

試想一個測試數組包含[2,1,2,3,4,5,6,7,8]

我的計劃現在應該有兩個矩陣有：

1 2 5 6 
3 4 7 8 

我是否需要幾個嵌套循環？任何幫助，將不勝感激。

Answer 1

目前唯一的想法是使用兩個for loops。或者你可以創建一個函數，並在每次需要時調用它（但不要忘記使用k作爲第二個參數）。

int i, j, k; 

/* We start in the 2nd element of the array that's why k = 1. */ 
k = 1; 

/* Now we fill the array1 copying 1 by 1 the elements of the "test array" until 
    we fill it. Then we do the same with the array2. */ 
for(i = 0; i < test[ 0 ]; i++){ 
    for(j = 0; j < test[ 0 ]; j++){ 
     array1[ i ][ j ] = test[ k ] 
     k++; 
    } 
} 

for(i = 0; i < test[ 0 ]; i++){ 
    for(j = 0; j < test[ 0 ]; j++){ 
     array2[ i ][ j ] = test[ k ] 
     k++; 
    } 
} 

Answer 2

問題在C多維數組是，你需要事先知道（在編譯時）n-1個的尺寸的尺寸，它們也拖動作爲函數參數使用時。

有幾個的替代方法：

1. 創建數組的數組。即分配一組數組指針，然後將數組分配給這些指針。

   type ** array = malloc（sizeof（type *）* < firstnumread>）;
   array [0] = malloc（sizeof（type）* < firstnumread>）;
   ...

2. 分配一個尺寸爲所有乘積尺寸的單維數組。即

   type * array = malloc（sizeof（type）* < firstnumread> * < firstnumread>）;

就你而言，第二個可能更合適。喜歡的東西：

matrix1 = malloc(sizeof(type)*<firstnumread>*<firstnumread>); 
matrix2 = malloc(sizeof(type)*<firstnumread>*<firstnumread>); 

然後，你可以這樣賦值：

matrix1[column*<firstnumread> + row] = <value>; 

是，用2 for循環。

Answer 3

二維數組存儲在矩陣的連續系列中。所以你甚至不需要分配新的內存就可以使用原始數組。無論如何，你也可以創建2個新的獨立陣列。 您可以創建一個像這樣的函數，以獲取矩陣的正確數量。

int getNumber(int array[], int arraynumber, int index_x, int index_y) 
{ 
    return array[(((array[0]*index_x)+index_y)+1)+((array[0]*array[0])*arraynumber)]; 
} 

arraynynumber變量對於第一個矩陣是0，對於第二個矩陣是1。這個功能只有在所有參數都正確的情況下才有效，所以沒有錯誤檢測。
有了這個功能，您可以輕鬆地遍歷並創建兩個新的數組：

int i,k; 
for (i=0; i<array[0]; i++) 
{ 
    for (k=0; k<array[0]; k++) 
    { 
     newarray1[i][k] = getNumber(array, 0, i,k); 
     newarray2[i][k] = getNumber(array, 1, i,k); 
    } 
} 

Answer 4

這裏的東西，在一個循環工程;沒有巢穴，也沒有重複。我不知道它是否會勝過其他答案，但我只是覺得給你一個不同的答案^ _^

我還沒有測試這個代碼，但它看起來像算法的邏輯工作 - 這是關鍵，對吧？讓我知道它是否有任何錯誤....

int c=0, x=0, y=0, size=test[0], length=sizeof(test); 

for(i=1; i<length; i++) { 
    if((c-size)<0) { 
     matrix1[x][y] = test[i]; 
    } else { 
     matrix2[x][y] = test[i]; 
    } 
    ++y; 
    if(y%size == 0) { 
     ++c; 
     y = 0; 
     x = (c-size)<0 ? ++x : 0; 
    } 
} 

Answer 5

您的數據以行優先順序列出。在讀取整型數組並驗證其內容後（即dim = 4意味着32個值跟隨，dim = 2意味着8個值跟隨，等等）。我不確定爲什麼要分配或循環任何東西。

I.e. 您可以使用物理測試[]的數據作爲矩陣：

int dim = test[0]; 
int (*mat1)[dim] = (int (*)[dim])(test+1); 
int (*mat2)[dim] = (int (*)[dim])(test+1 + dim*dim); 

C99在執行層面支持可變數組聲明（即，編譯器可以支持該功能，因爲它是由標準定義的，但不有;更多信息參見C99標準的6.7.6.2）。如果您的工具鏈不支持它，則可以在編譯時定義一個預定義的宏（__STDC_NO_VLA__必須）（請參閱C99標準的第6.10.8.3-1節）。這就是說，在過去的十年中，我曾經使用過的每個符合C99標準的編譯器，加上，都支持它，所以如果你的不支持，請在下面的評論中告訴我們。

如果是這樣，那麼請注意在上面的mat1和mat2的聲明中使用'dim'）。它是C++的少數幾個特性之一，就像C++沒有的特性一樣。所以跟你帶的那個跳舞吧。

最後，假設你的編譯器是C99兼容，支持沃拉斯（__STDC_NO_VLA__沒有被定義），作爲額外的超級特別分紅，是所有，但保證是最快的算法，讓您的兩個矩陣，因爲沒有算法。您讀取一個數組元素，然後分配兩個指針。 O（3）很難被擊敗。

例

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

// main loader. 
int main(int argc, char *argv[]) 
{ 
    int test[] = {2,1,2,3,4,5,6,7,8}; 
    int dim = test[0]; 
    int (*mat1)[dim] = (int (*)[dim])(test+1); 
    int (*mat2)[dim] = (int (*)[dim])(test+1 + dim*dim); 

    // proof stuff is where it should be. 
    int i=0,j=0; 
    for (i=0;i<dim;i++) 
    { 
     for (j=0;j<dim;printf("%d ", mat1[i][j++])); 
     printf (" "); 
     for (j=0;j<dim;printf("%d ", mat2[i][j++])); 
     printf("\n"); 
    } 

    return EXIT_SUCCESS; 
} 

輸出

1 2 5 6 
3 4 7 8 

類似的測試用的3×3的數據集：

int test[] = {3,1,2,3,4,5,6,7,8,9,9,8,7,6,5,4,3,2,1}; 

輸出

1 2 3 9 8 7 
4 5 6 6 5 4 
7 8 9 3 2 1 

最後，設定一個4x4的數據：

int test[] = {4,1,2,3,4,5,6,7,8,1,2,3,4,5,6,7,8,8,7,6,5,4,3,2,1,8,7,6,5,4,3,2,1}; 

輸出

1 2 3 4 8 7 6 5 
5 6 7 8 4 3 2 1 
1 2 3 4 8 7 6 5 
5 6 7 8 4 3 2 1