二维数组与矩阵乘法及压缩矩阵的转置

二维数组本质上是以数组作为数组元素的数组，即“数组的数组”，类型说明符 数组名[常量表达式][常量表达式]。二维数组又称为矩阵，行列数相等的矩阵称为方阵。

一、二维数组与矩阵乘法

1、创建矩阵

typedef struct TwoDArray{
	int rows;
	int columns;
	int**elements;
}TwoDArray,*TwoDArrayPtr;

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

2、初始化

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));
	} 
	return resultPtr;
}

3、随机赋值

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;
		}
	}
}

4、打印矩阵

void printfTwoDArray(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");
	}
}

5、矩阵相乘

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;
	}
	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];
			}
			resultPtr->elements[i][j] = sum;
			printf("sum = %d,",sum);
		}
	}
	return  resultPtr; 
}

测试结果

 二、压缩矩阵的转置

矩阵的转置也就是转置矩阵，将矩阵的行列互换得到的新矩阵称为转置矩阵，转置矩阵的行列式不变

1、创建矩阵

typedef struct Triple{
    int i;
    int j;
    elem e;
} Triple, *TriplePtr;

2、初始化

typedef struct CompressedMatrix{
    int rows,columns,numElements;
    Triple* elements;
} CompressedMatrix, *CompressedMatrixPtr;

3、压缩矩阵

CompressedMatrixPtr initCompressedMatrix(int paraRows, int paraColumns, int paraElements, int** paraData){
	int i;
	CompressedMatrixPtr resultPtr = (CompressedMatrixPtr)malloc(sizeof(struct CompressedMatrix));
	resultPtr->rows = paraRows;
	resultPtr->columns = paraColumns;
	resultPtr->numElements = paraElements;
	resultPtr->elements = (TriplePtr)malloc(paraElements * sizeof(struct Triple));

	for(i = 0; i < paraElements; i ++){
		resultPtr->elements[i].i = paraData[i][0];
		resultPtr->elements[i].j = paraData[i][1];
		resultPtr->elements[i].e = paraData[i][2];
	}

	return resultPtr;
}

4、打印矩阵

​

void printCompressedMatrix(CompressedMatrixPtr paraPtr){
	int i;
	for(i = 0; i < paraPtr->numElements; i ++){
		printf("(%d, %d): %d\r\n", paraPtr->elements[i].i, paraPtr->elements[i].j, paraPtr->elements[i].e);
	}
}
​

5、转置

CompressedMatrixPtr transposeCompressedMatrix(CompressedMatrixPtr paraPtr){

	int i, tempColumn, tempPosition;
	int *tempColumnCounts = (int*)malloc(paraPtr->columns * sizeof(int));
	int *tempOffsets = (int*)malloc(paraPtr->columns * sizeof(int));
	for(i = 0; i < paraPtr->columns; i ++){
		tempColumnCounts[i] = 0;
	}

	CompressedMatrixPtr resultPtr = (CompressedMatrixPtr)malloc(sizeof(struct CompressedMatrix));
	resultPtr->rows = paraPtr->columns;
	resultPtr->columns = paraPtr->rows;
	resultPtr->numElements = paraPtr->numElements;

	resultPtr->elements = (TriplePtr)malloc(paraPtr->numElements * sizeof(struct Triple));
	
	
	for(i = 0; i < paraPtr->numElements; i ++) {
		tempColumnCounts[paraPtr->elements[i].j] ++;
	}
	tempOffsets[0] = 0;
	for(i = 1; i < paraPtr->columns; i ++){
		tempOffsets[i] = tempOffsets[i - 1] + tempColumnCounts[i - 1];
		printf("tempOffsets[%d] = %d \r\n", i, tempOffsets[i]);
	}
	for(i = 0; i < paraPtr->numElements; i ++) {
		tempColumn = paraPtr->elements[i].j;
		tempPosition = tempOffsets[tempColumn];
		resultPtr->elements[tempPosition].i = paraPtr->elements[i].j;
		resultPtr->elements[tempPosition].j = paraPtr->elements[i].i;
		resultPtr->elements[tempPosition].e = paraPtr->elements[i].e;

		tempOffsets[tempColumn]++;
	}

	return resultPtr;
}

测试结果