【二维数组与矩阵乘法】

本篇内容主要是用来实现两个二维数组元素相乘，从而得到一个新的矩阵
创建二维数组的结构：

// 动态创建
typedef struct TwoDArray{
    int rows;
    int columns;
    // 一个*表示指向二维数组的列TwoDArry[0]的首地址，两个*表示指向二维数组TwoDarry[0][0]的首地址
    int** elements;
}TwoDArray,*TwoDArrayPtr;
// 静态创建，主要用来后面看一下地址
typedef struct TwoDStaticArray{
    int rows;
    int columns;
    int elements[ROW][COLUMNS];
}TwoDStaticArray,*TwoDStaticArrayPtr;

初始化：

/* 定义一个二维数组a[3][4]a 是二维数组名。a 数组包含 3 行，即 3 个行元素：a[0]，a[1]，a[2]。每个行元素都可以看成含有 4 个元素的一维数组。
而且 C 语言规定，a[0]、a[1]、a[2]分别是这三个一维数组的数组名 */
TwoDArrayPtr initTwoDArray(int paraRows, int paraColums){
    int i;
    // 对二维数组，先给最外层malloc
    TwoDArrayPtr resultPtr = (TwoDArrayPtr)malloc(sizeof(struct TwoDArray));
    resultPtr->rows = paraRows;
    resultPtr->columns = paraColums;
    // 把二维数组看作一个一维数组，申请空间
    resultPtr->elements = (int**)malloc(paraRows*sizeof(int*));
    int i = 0;
    // 为二维数组的每一个元素申请空间
    for(i = 0;i<paraRows;i++){
        resultPtr->elements[i] = (int*)malloc(paraColums*sizeof(int));
    }
    return resultPtr;
}

矩阵相乘（核心）：

TwoDArrayPtr matrixMultiply(TwoDArrayPtr paraPtr1 ,TwoDArrayPtr paraPtr2){
    int i,j,k,sum;
    if(paraPtr1->columns!=paraPtr2->rows){
        printf("两矩阵无法相乘\r\n");
        return NULL;
    }
    TwoDArrayPtr resultPtr = initTwoDArray(paraPtr1->rows ,paraPtr2->columns);
    // 利用三重循环让矩阵相乘，用k控制相乘的次数
    for(i = 0;i<paraPtr1->rows;i++){
        for(j = 0;j<paraPtr2->columns;j++){
            sum = 0;
            for(k = 0;k<paraPtr1->columns;k++){
                sum+=paraPtr1->elements[i][k]*paraPtr2->elements[k][j];
            }
            resultPtr->elements[i][j]=sum;
            printf("sum = %d,",sum);
        }
    }
    return resultPtr;
}

静态的初始化并打印地址：

TwoDStaticArrayPtr initTwoDStaticArray(){
	int i, j;
	TwoDStaticArrayPtr resultPtr = (TwoDStaticArrayPtr)malloc(sizeof(struct TwoDStaticArray));
	resultPtr->rows = ROW;
	resultPtr->columns = COLUMNS;
	for (i = 0; i < ROW; i ++){
		for (j = 0; j < COLUMNS; j ++) {
            // 不懂
			resultPtr->elements[i][j] = i * 10 + j;
			// 取地址
			printf("(%d, %d): %d; ", i, j, &(resultPtr->elements[i][j]));
		}
	}
	
	return resultPtr;
}

全部代码：

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

#define ROW 4
#define COLUMNS 5
// 动态创建
typedef struct TwoDArray{
    int rows;
    int columns;
    // 一个*表示指向二维数组的列TwoDArry[0]的首地址，两个*表示指向二维数组TwoDarry[0][0]的首地址
    int** elements;
}TwoDArray,*TwoDArrayPtr;
// 静态创建，主要用来后面看一下地址
typedef struct TwoDStaticArray{
    int rows;
    int columns;
    int elements[ROW][COLUMNS];
}TwoDStaticArray,*TwoDStaticArrayPtr;
// 初始化
/* 定义一个二维数组a[3][4]a 是二维数组名。a 数组包含 3 行，即 3 个行元素：a[0]，a[1]，a[2]。每个行元素都可以看成含有 4 个元素的一维数组。
而且 C 语言规定，a[0]、a[1]、a[2]分别是这三个一维数组的数组名 */
TwoDArrayPtr initTwoDArray(int paraRows, int paraColums){
    int i;
    // 对二维数组，先给最外层malloc
    TwoDArrayPtr resultPtr = (TwoDArrayPtr)malloc(sizeof(struct TwoDArray));
    resultPtr->rows = paraRows;
    resultPtr->columns = paraColums;
    // 把二维数组看作一个一维数组，申请空间
    resultPtr->elements = (int**)malloc(paraRows*sizeof(int*));
    int i = 0;
    // 为二维数组的每一个元素申请空间
    for(i = 0;i<paraRows;i++){
        resultPtr->elements[i] = (int*)malloc(paraColums*sizeof(int));
    }
    return resultPtr;
}

void randomizeTwoDArray(TwoDArrayPtr paraPtr, int paraLowerBound, int paraUpperBound){
    int i,j;
    for(i = 0;i<paraPtr->rows;i++){
        // 获得随机数
        for(j = 0;j<paraPtr->columns;j++){
            paraPtr->elements[i][j] = rand()%(paraUpperBound - paraLowerBound)+paraLowerBound;
        }
    }
}

void printTwoDArray(TwoDArrayPtr paraPtr){
	int i, j;	
	for (i = 0; i < paraPtr->rows; i ++){
		for (j = 0; j < paraPtr->columns; j ++) {
			printf("%d, ", paraPtr->elements[i][j]);
		}
		printf("\r\n");
	}
}
// 矩阵相乘
TwoDArrayPtr matrixMultiply(TwoDArrayPtr paraPtr1 ,TwoDArrayPtr paraPtr2){
    int i,j,k,sum;
    if(paraPtr1->columns!=paraPtr2->rows){
        printf("两矩阵无法相乘\r\n");
        return NULL;
    }
    TwoDArrayPtr resultPtr = initTwoDArray(paraPtr1->rows ,paraPtr2->columns);
    // 利用三重循环让矩阵相乘，用k控制相乘的次数
    for(i = 0;i<paraPtr1->rows;i++){
        for(j = 0;j<paraPtr2->columns;j++){
            sum = 0;
            for(k = 0;k<paraPtr1->columns;k++){
                sum+=paraPtr1->elements[i][k]*paraPtr2->elements[k][j];
            }
            resultPtr->elements[i][j]=sum;
            printf("sum = %d,",sum);
        }
    }
    return resultPtr;
}
// 测试
void twoDArrayTest(){
	TwoDArrayPtr tempPtr1, tempPtr2, tempPtr3;
	tempPtr1 = initTwoDArray(3, 2);
	randomizeTwoDArray(tempPtr1, 1, 5);
	printf("The first matrix:\r\n");
	printTwoDArray(tempPtr1);

	tempPtr2 = initTwoDArray(2, 4);
	randomizeTwoDArray(tempPtr2, 4, 9);
	printf("The second matrix:\r\n");
	printTwoDArray(tempPtr2);

	tempPtr3 = matrixMultiply(tempPtr1, tempPtr2);
	printf("The result:\r\n");
	printTwoDArray(tempPtr3);
}

// 静态的初始化并打印地址
TwoDStaticArrayPtr initTwoDStaticArray(){
	int i, j;
	TwoDStaticArrayPtr resultPtr = (TwoDStaticArrayPtr)malloc(sizeof(struct TwoDStaticArray));
	resultPtr->rows = ROW;
	resultPtr->columns = COLUMNS;
	for (i = 0; i < ROW; i ++){
		for (j = 0; j < COLUMNS; j ++) {
           
			resultPtr->elements[i][j] = i * 10 + j;
			// 取地址
			printf("(%d, %d): %d; ", i, j, &(resultPtr->elements[i][j]));
		}
	}
	
	return resultPtr;
}


int main(){
	twoDArrayTest();
	TwoDStaticArrayPtr tempPtr = initTwoDStaticArray();

	return 1;
}

主要还是要理解两个矩阵相乘的算法以及二维数组在内存中的存储方式