二维数组及及矩阵的相乘

二维数组若不直接固定，则采用指针的方式来分配，这样可以根据你的需求来建立m*n的数组；在采用指针时，取用双指针来建立二维数组，如int**。根据矩阵相乘的定义，采用循环将两者相乘，具体请看代码。

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

#define ROWS 4
#define COLUMNS 5

//二维数组的第一种分配方式 
typedef struct TwoDarray{
	int rows;
	int culumns;
	int **elements;
}*TwoDarrayPtr;

//二维数组的第二种分配方式 
typedef struct TwoDStaticArray{
	int rows;
	int culumns;
	int elements[ROWS][COLUMNS];
}*TwoDStaticArrayPtr;

//创建第一种分配方式的空间 
TwoDarrayPtr initTwoDarray(int paraRows,int paraCulumns){
	TwoDarrayPtr resultPtr= (TwoDarrayPtr)malloc(sizeof(TwoDarray));
	resultPtr->culumns = paraCulumns;
	resultPtr->rows = paraRows;
	resultPtr->elements = (int **)malloc(sizeof(int*)*paraRows);
	
	for(int i = 0;i < paraRows;i++){
		resultPtr->elements[i] = (int*)malloc(sizeof(int)*paraCulumns);
	}
	
	return resultPtr;
}

//第二种分配方式的初始化 
TwoDStaticArrayPtr initTwoDStaticArray(){
	int i,j;
	TwoDStaticArrayPtr resultPtr = (TwoDStaticArrayPtr)malloc(sizeof(TwoDStaticArray));
	resultPtr->rows = ROWS;
	resultPtr->culumns =COLUMNS;
	
	for(i = 0;i < ROWS;i++){
		for(j = 0;j < COLUMNS;j++ ){
			resultPtr->elements[i][j]=i*10+j;
			//打印各数据地址 
            printf("(%d,%d):%d",i,j,&resultPtr->elements[i][j]);	
		}
		printf("\n");
	}	
	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->culumns; 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->culumns;j++){
			printf("%d ",&paraPtr->elements[i][j]);
		}
		printf("\n");
	}
}

//两矩阵相乘 
TwoDarrayPtr matrixMultiply(TwoDarrayPtr paraPtr1, TwoDarrayPtr paraPtr2){
	int i,j,k,sum = 0;
	
	//判断两矩阵能否相乘 
	if(paraPtr1->culumns == paraPtr2->rows){
		//分配存储相乘结果的空间 
		TwoDarrayPtr resultPtr = initTwoDarray(paraPtr1->rows,paraPtr2->culumns);
		//两矩阵相乘循环 
		for(i = 0;i < paraPtr1->rows;i++){
			for(j = 0;j < paraPtr2->culumns;j++){
				for(k = 0;k < paraPtr1->culumns;k++){
					sum+=paraPtr1->elements[i][k]*paraPtr2->elements[k][j];
				}
				printf("sum = %d",sum);
				resultPtr->elements[i][j] = sum;
				sum = 0;
			}
			printf("\n");
		}
		return resultPtr;
	}else{
		printf("两矩阵不能相乘\n");
		return 0;
	}
}

//打印
void printTwoDarray(TwoDarrayPtr paraPtr){
	int i,j;
	for(i = 0;i < paraPtr->rows;i++){
		for(j = 0;j < paraPtr->culumns;j++){
			printf("%d ",paraPtr->elements[i][j]);
		}
		printf("\n");
	}
}

void twoDarrayTest(){
	TwoDarrayPtr tempPtr1,tempPtr2,tempPtr3;
	tempPtr1 = initTwoDarray(3,2);
	randomizeTwoDArray(tempPtr1,1,5);
	printf("第一个矩阵是：\n");
	printTwoDarray(tempPtr1);
	
	tempPtr2 = initTwoDarray(2,4);
	randomizeTwoDArray(tempPtr2,4,9);
	printf("第二个矩阵是：\n");
	printTwoDarray(tempPtr2);
	
	tempPtr3 = matrixMultiply(tempPtr1,tempPtr2);
	printf("两个矩阵相乘得：\n");
	printTwoDarray(tempPtr3);
	printTwoDArray(tempPtr3);
	
}
int main(){
	twoDarrayTest();
	TwoDStaticArrayPtr temptr =  initTwoDStaticArray();
}

总结：实现矩阵相称的空间复杂度为O（mnk);在二维数组中直接用语法定义的数组，每个数据的地址的空间是相邻的，且是以行优先进行存储。但用指针分配的动态空间，在每一行中的数据的地址是相邻的，而每一行末尾的数据与第二行初的数据地址却不相邻，各行之间相距的地址之差相等。