数据结构5.1--二维数组与矩阵乘法

一、代码

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

#define ROWS 4
#define COLUMNS 5

/**
 * 二维矩阵
 */
typedef struct TwoDArray {
	int rows;
	int columns;
	int** elements;
} TwoDArray, *TwoDArrayPtr;

typedef struct TwoDStaticArray{
	int rows; 
	int columns;
	int elemnts[ROWS][COLUMNS];
}TwoDStaticArray, *TwoDStaticArrayPtr;

/**
 * 初始化二维数组
 */
TwoDArrayPtr initTwoDArray(int paraRows, int paraColumns){
	int i;
	TwoDArrayPtr resultPtr = (TwoDArrayPtr)malloc(sizeof(struct TwoDArray));
	resultPtr->rows = paraRows;
	resultPtr->columns = paraColumns;
	resultPtr->elements = (int **)malloc(paraRows * sizeof(int*));
	for(i = 0; i < paraRows; i ++){
		resultPtr->elements[i] = (int*)malloc(paraColumns * sizeof(int));
	}// of for i
	
	return resultPtr;
} // of initTwoDArray

/**
 * 随机化数组的数据
 */
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; 
		}//of for j
	}//of for i
} //of randomizeTwoDarray

/**
 * 输出数组
 */
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]);
		}//of for j
		printf("\r\n");
	}//of for i
} //of printTwoDArray

/**
 * 矩阵相乘
 */
TwoDArrayPtr matrixMultiply(TwoDArrayPtr paraPtr1, TwoDArrayPtr paraPtr2){
	int i, j, k, sum;
	if(paraPtr1->columns != paraPtr2->rows){
		printf("Matrices cannot be multiplied.\r\n");
		return NULL;
	}//of if
	
	TwoDArrayPtr resultPtr = initTwoDArray(paraPtr1->rows, paraPtr2->columns);
	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];
			}//of for k
			resultPtr->elements[i][j] = sum;
			printf("sum = %d, ",sum);
		}//of for j
	}//of for i
	
	return resultPtr;
} //of matrixMultiply

/**
 * 测试
 */
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);	 
} // of twoDArrayTest

/**
 * 初始化
 */
TwoDStaticArrayPtr initTwoDStaticArray(){
	int i, j;
	TwoDStaticArrayPtr resultPtr = (TwoDStaticArrayPtr)malloc(sizeof(struct TwoDStaticArray));
	resultPtr->rows = ROWS;
	resultPtr->columns = COLUMNS;
	for(i = 0; i < ROWS; i ++){
		for(j = 0; j < COLUMNS; j ++){
			resultPtr->elemnts[i][j] = i * 10 + j;
			//输出地址
			printf("(%d, %d): %p; ", i, j, &(resultPtr->elemnts[i][j])); 
		} //of for j
	}//of for i
	
	return resultPtr;
} //of initTwoDstaticArray

/**
 * the entrance
 */
int main(){
	twoDArrayTest();
	TwoDStaticArrayPtr tempPtr = initTwoDStaticArray();
	
	return 0;
}// of main

二、运行结果

三、代码说明

以上代码定义了两种二维数组的数据结构，一种是可以动态分配的，一种是静态的。动态分配的相对来说更加灵活，但是运用到的是指针的指针，即第一个指针代表储存的地址，第二个指针代表该地址下储存的数据。静态的则只有一次动态分配，并且会分配好该数组的大小，所以在编写代码的过程中要避免出现越界的问题。