数据结构--转置压缩矩阵

压缩矩阵的转置：

上代码：

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <random>
typedef struct location_
{
	int elem;
	int order;
}Location,*location;

typedef struct Locainf_
{
	int row;
	int column;
	int elem;
}Locainf,*locainf;
typedef struct  Twodimensionalmatrix_
{
	int rows;
	int columns;
	int numberelements;
	Locainf* elements;
}Twodimensionalmatrix,*twodimensionalmatrix;

twodimensionalmatrix initwodimensionalmatrix(int row ,int column,int number ,int **paraptr){
    twodimensionalmatrix resultptr=(twodimensionalmatrix)malloc(sizeof(Twodimensionalmatrix));
    resultptr->rows = row;
	resultptr->columns = column;
	resultptr->numberelements=number;
	resultptr->elements=(locainf)malloc(sizeof(Locainf)*number);
	for (int i = 0; i < number; i ++){
		resultptr->elements[i].row=paraptr[i][0];
		resultptr->elements[i].column=paraptr[i][1];
		resultptr->elements[i].elem=paraptr[i][2];
	}
	return resultptr;
}

void printtwodimensionalmatrix(twodimensionalmatrix paraptr){
	for (int i=0;i<paraptr->numberelements;i++){
		printf("(%d,%d):%d\n",paraptr->elements[i].row,paraptr->elements[i].column,paraptr->elements[i].elem);
	}
	printf("\n");
}
twodimensionalmatrix matrixtranspose(twodimensionalmatrix paraptr){
	twodimensionalmatrix resultptr=(twodimensionalmatrix)malloc(sizeof(Twodimensionalmatrix));
	resultptr->rows=paraptr->columns;
	resultptr->columns=paraptr->rows;
	resultptr->numberelements=paraptr->numberelements;
	resultptr->elements=(locainf)malloc(sizeof(Locainf)*paraptr->numberelements);
	Location *loc = (location)malloc( sizeof(Location)*paraptr->numberelements );
    for (int i = 0; i < paraptr->numberelements; i ++){
		loc[i].elem=paraptr->elements[i].column; 
		loc[i].order=i;
	}
	Location ln;
	for (int i=0;i<paraptr->numberelements;i++){
        for (int j=0;j<paraptr->numberelements-i-1;j++){
            if (loc[j].elem>loc[j+1].elem)
			{
				ln=loc[j+1];
				loc[j+1]=loc[j];
				loc[j]=ln;
			}
		}
	}
	for(int i=0;i<paraptr->numberelements;i++){
		resultptr->elements[i].row=paraptr->elements[loc[i].order].column;
		resultptr->elements[i].column=paraptr->elements[loc[i].order].row;
		resultptr->elements[i].elem=paraptr->elements[loc[i].order].elem;
	}
	return resultptr;
}
void testsample(){
	int** tempMatrix1 = (int**)malloc(4 * sizeof(int*));
	for(int i = 0; i < 4; i ++){
		tempMatrix1[i] = (int*)malloc(3 * sizeof(int));
	}
	int tempMatrix2[4][3] = {{0, 0, 2}, {0, 2, 3}, {2, 0, 5}, {2, 1, 6}};
	for(int i = 0; i < 4; i ++){
		for(int j = 0; j < 3; j ++) {
			tempMatrix1[i][j] = tempMatrix2[i][j];
		}
	}
	twodimensionalmatrix para=initwodimensionalmatrix(2,3,4,tempMatrix1);
	printtwodimensionalmatrix(para);
	para=matrixtranspose(para);
	printtwodimensionalmatrix(para);
}
int main(){
	testsample();
	return 0;
}

运行结果：

总结：

需要有较强的理解能力和代码实践能力，写起来还是比较繁琐 ，但是认真写完还是很有收获的

需要注意的是转置时位置的交换，我这里用的是结构体冒泡排序，老师那个有点没看懂