数据结构-二维数组

#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 elements[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*));
    }
    //返回二维数组的指针
    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++)
        {
            //将每一行的每一个元素都随机生成一个在paraLowerBound到paraUpperBound之间的数
            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("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;
}
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()
{
    // 初始化指针resultPtr，并分配ROWS*COLUMNS个元素空间
    int i,j;
    TwoDStaticArrayPtr resultPtr=(TwoDStaticArrayPtr)malloc(sizeof(struct TwoDStaticArray));
    // 设置resultPtr的行数和列数
    resultPtr->rows=ROWS;
    resultPtr->columns=COLUMNS;
    // 初始化resultPtr的elements数组
    for(i=0;i<ROWS;i++)
    {
        for(j=0;j<COLUMNS;j++)
        {
            resultPtr->elements[i][j]=i*10+j;
            // 打印(i,j):resultPtr->elements[i][j]
            printf("(%d,%d):%d; ",i,j,&resultPtr->elements[i][j]);
        }
    }
    // 返回初始化好的resultPtr
    return resultPtr;
}
int main()
{
    twoDArrayTest();
    TwoDStaticArrayPtr tempPtr=initTwoDStaticArray();
    return 1;
}