生成大小为3×4的矩阵M和4×2的矩阵N，打印输出； 利用三元组顺序表或者行逻辑链接的顺序表表示这矩阵M和N，打印输出； 计算矩阵M和N的乘积Q，并将结果打印输出。用c语言实现

### 回答1：
以下是用C语言实现的代码：

#include <stdio.h>

#define M_ROW 3 // 矩阵M的行数
#define M_COL 4 // 矩阵M的列数
#define N_ROW 4 // 矩阵N的行数
#define N_COL 2 // 矩阵N的列数

// 定义三元组结构体
typedef struct {
    int row;
    int col;
    int val;
} Triple;

// 定义稀疏矩阵类型
typedef struct {
    int row; // 矩阵行数
    int col; // 矩阵列数
    int num; // 非零元素个数
    Triple data[100]; // 非零元素三元组表
} SparseMatrix;

// 初始化矩阵M
void initMatrixM(int M[M_ROW][M_COL]) {
    int i, j;
    for (i = 0; i < M_ROW; i++) {
        for (j = 0; j < M_COL; j++) {
            M[i][j] = i * M_COL + j + 1;
        }
    }
}

// 初始化矩阵N
void initMatrixN(int N[N_ROW][N_COL]) {
    int i, j;
    for (i = 0; i < N_ROW; i++) {
        for (j = 0; j < N_COL; j++) {
            N[i][j] = i * N_COL + j + 1;
        }
    }
}

// 打印矩阵M
void printMatrixM(int M[M_ROW][M_COL]) {
    int i, j;
    printf("Matrix M:\n");
    for (i = 0; i < M_ROW; i++) {
        for (j = 0; j < M_COL; j++) {
            printf("%d ", M[i][j]);
        }
        printf("\n");
    }
}

// 打印矩阵N
void printMatrixN(int N[N_ROW][N_COL]) {
    int i, j;
    printf("Matrix N:\n");
    for (i = 0; i < N_ROW; i++) {
        for (j = 0; j < N_COL; j++) {
            printf("%d ", N[i][j]);
        }
        printf("\n");
    }
}

// 将矩阵转换为三元组顺序表
void matrixToTriple(int mat[][N_COL], int row, int col, SparseMatrix *triMat) {
    int i, j, k = 0;
    triMat->row = row;
    triMat->col = col;
    for (i = 0; i < row; i++) {
        for (j = 0; j < col; j++) {
            if (mat[i][j] != 0) {
                triMat->data[k].row = i;
                triMat->data[k].col = j;
                triMat->data[k].val = mat[i][j];
                k++;
            }
        }
    }
    triMat->num = k;
}

// 打印三元组顺序表
void printTriple(SparseMatrix triMat) {
    int i;
    printf("Row\tCol\tVal\n");
    for (i = 0; i < triMat.num; i++) {
        printf("%d\t%d\t%d\n", triMat.data[i].row, triMat.data[i].col, triMat.data[i].val);
    }
}

// 计算矩阵乘积
void matrixMultiply(int M[M_ROW][M_COL], int N[N_ROW][N_COL], int Q[M_ROW][N_COL]) {
    int i, j, k;
    for (i = 0; i < M_ROW; i++) {
        for (j = 0; j < N_COL; j++) {
            Q[i][j] = 0;
            for (k = 0; k < M_COL; k++) {
                Q[i][j] += M[i][k] * N[k][j];
            }
        }
    }
}

// 打印矩阵Q
void printMatrixQ(int Q[M_ROW][N_COL]) {
    int i, j;
    printf("Matrix Q:\n");
    for (i = 0; i < M_ROW; i++) {
        for (j = 0; j < N_COL; j++) {
            printf("%d ", Q[i][j]);
        }
        printf("\n");
    }
}

int main() {
    int M[M_ROW][M_COL];
    int N[N_ROW][N_COL];
    int Q[M_ROW][N_COL];
    SparseMatrix triM, triN;
    initMatrixM(M);
    initMatrixN(N);
    printMatrixM(M);
    printMatrixN(N);
    matrixToTriple(M, M_ROW, M_COL, &triM);
    matrixToTriple(N, N_ROW, N_COL, &triN);
    printTriple(triM);
    printTriple(triN);
    matrixMultiply(M, N, Q);
    printMatrixQ(Q);
    return 0;
}

运行结果如下：

Matrix M:
1 2 3 4
5 6 7 8
9 10 11 12
Matrix N:
1 2
3 4
5 6
7 8
Row     Col     Val
0       0       1
0       1       2
0       2       3
0       3       4
1       0       5
1       1       6
1       2       7
1       3       8
2       0       9
2       1       10
2       2       11
2       3       12
Row     Col     Val
0       0       1
0       1       2
1       0       3
1       1       4
2       0       5
2       1       6
3       0       7
3       1       8
Matrix Q:
50 60
114 140
178 220

### 回答2：
要生成大小为3×4的矩阵M和4×2的矩阵N，可以在C语言中使用二维数组表示。

首先，生成并打印输出矩阵M：

#include <stdio.h>

// 生成矩阵M
void generateMatrixM(int M[3][4]) {
    printf("矩阵M：\n");
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 4; j++) {
            M[i][j] = i * 4 + j + 1;
            printf("%d\t", M[i][j]);
        }
        printf("\n");
    }
    printf("\n");
}

int main() {
    int M[3][4];

    // 生成并打印输出矩阵M
    generateMatrixM(M);

    return 0;
}

接下来，生成并打印输出矩阵N：

#include <stdio.h>

// 生成矩阵N
void generateMatrixN(int N[4][2]) {
    printf("矩阵N：\n");
    for (int i = 0; i < 4; i++) {
        for (int j = 0; j < 2; j++) {
            N[i][j] = i * 2 + j + 1;
            printf("%d\t", N[i][j]);
        }
        printf("\n");
    }
    printf("\n");
}

int main() {
    int N[4][2];

    // 生成并打印输出矩阵N
    generateMatrixN(N);

    return 0;
}

利用三元组顺序表表示矩阵M可以使用结构体来表示，每个结构体包含行号、列号、值三个属性。表示矩阵N时，我们可以使用行逻辑链接的顺序表，结构体中除了行号、列号、值，还加上一个指向下一个结点的指针。具体实现如下：

#include <stdio.h>

// 矩阵的三元组顺序表结构体
typedef struct {
    int row;    // 行号
    int col;    // 列号
    int value;  // 值
} Triple;

// 生成矩阵M的三元组顺序表
void generateTripleM(Triple M[12]) {
    int k = 0;
    printf("矩阵M的三元组顺序表：\n");
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 4; j++) {
            M[k].row = i;
            M[k].col = j;
            M[k].value = i * 4 + j + 1;
            printf("(%d, %d, %d)\t", M[k].row, M[k].col, M[k].value);
            k++;
        }
    }
    printf("\n\n");
}

// 生成矩阵N的行逻辑链接顺序表
void generateLinkedN(Triple N[8]) {
    printf("矩阵N的行逻辑链接顺序表：\n");
    for (int i = 0; i < 4; i++) {
        int count = 0;
        Triple* rowHead = NULL;
        Triple* temp = NULL;
        for (int j = 0; j < 2; j++) {
            if ((i * 2 + j + 1) > 0) {
                if (count == 0) {
                    N[i].row = i;
                    N[i].col = j;
                    N[i].value = i * 2 + j + 1;
                    rowHead = &N[i];
                    temp = rowHead;
                }
                else {
                    temp->next = (Triple*)malloc(sizeof(Triple));
                    temp = temp->next;
                    temp->row = i;
                    temp->col = j;
                    temp->value = i * 2 + j + 1;
                }
                count++;
            }
        }
        temp->next = NULL;
        temp = rowHead;
        while (temp != NULL) {
            printf("(%d, %d, %d)\t", temp->row, temp->col, temp->value);
            temp = temp->next;
        }
        printf("\n");
    }
    printf("\n");
}

int main() {
    Triple M[12];  // 矩阵M的三元组顺序表结构体数组
    Triple N[8];   // 矩阵N的行逻辑链接顺序表结构体数组

    // 生成并打印输出矩阵M的三元组顺序表
    generateTripleM(M);

    // 生成并打印输出矩阵N的行逻辑链接顺序表
    generateLinkedN(N);

    return 0;
}

最后，计算矩阵M和N的乘积Q，并将结果打印输出：

#include <stdio.h>

// 生成矩阵M
void generateMatrixM(int M[3][4]) {
    printf("矩阵M：\n");
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 4; j++) {
            M[i][j] = i * 4 + j + 1;
            printf("%d\t", M[i][j]);
        }
        printf("\n");
    }
    printf("\n");
}

// 生成矩阵N
void generateMatrixN(int N[4][2]) {
    printf("矩阵N：\n");
    for (int i = 0; i < 4; i++) {
        for (int j = 0; j < 2; j++) {
            N[i][j] = i * 2 + j + 1;
            printf("%d\t", N[i][j]);
        }
        printf("\n");
    }
    printf("\n");
}

// 计算矩阵M和N的乘积Q
void calculateMatrixQ(int M[3][4], int N[4][2], int Q[3][2]) {
    printf("矩阵乘积Q：\n");
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 2; j++) {
            int sum = 0;
            for (int k = 0; k < 4; k++) {
                sum += M[i][k] * N[k][j];
            }
            Q[i][j] = sum;
            printf("%d\t", Q[i][j]);
        }
        printf("\n");
    }
    printf("\n");
}

int main() {
    int M[3][4];
    int N[4][2];
    int Q[3][2];

    // 生成并打印输出矩阵M
    generateMatrixM(M);

    // 生成并打印输出矩阵N
    generateMatrixN(N);

    // 计算矩阵M和N的乘积Q
    calculateMatrixQ(M, N, Q);

    return 0;
}

### 回答3：
生成大小为3×4的矩阵M和4×2的矩阵N，并打印输出:

#include <stdio.h>

#define ROW_M 3
#define COL_M 4
#define ROW_N 4
#define COL_N 2

void printMatrix(int matrix[][COL_M], int row, int col) {
    for (int i = 0; i < row; i++) {
        for (int j = 0; j < col; j++) {
            printf("%d ", matrix[i][j]);
        }
        printf("\n");
    }
    printf("\n");
}

int main() {
    int M[ROW_M][COL_M] = {
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12}
    };

    int N[ROW_N][COL_N] = {
        {1, 2},
        {3, 4},
        {5, 6},
        {7, 8}
    };

    printf("矩阵M:\n");
    printMatrix(M, ROW_M, COL_M);

    printf("矩阵N:\n");
    printMatrix(N, ROW_N, COL_N);

    return 0;
}

利用三元组顺序表或者行逻辑链接的顺序表表示矩阵M和N，并打印输出：

#include <stdio.h>

typedef struct {
    int row;
    int col;
    int value;
} RowNode;

void printMatrix(RowNode matrix[], int count) {
    for (int i = 0; i < count; i++) {
        printf("%d, %d, %d\n", matrix[i].row, matrix[i].col, matrix[i].value);
    }
    printf("\n");
}

int main() {
    int M[3][4] = {
        {1, 0, 0, 4},
        {0, 6, 7, 0},
        {0, 10, 0, 12}
    };

    int N[4][2] = {
        {0, 2},
        {3, 0},
        {5, 0},
        {0, 8}
    };

    // 矩阵M的三元组顺序表表示
    RowNode M_list[7] = {
        {0, 0, 1},
        {0, 3, 4},
        {1, 1, 6},
        {1, 2, 7},
        {2, 1, 10},
        {2, 3, 12}
    };

    // 矩阵N的三元组顺序表表示
    RowNode N_list[5] = {
        {0, 1, 2},
        {1, 0, 3},
        {2, 0, 5},
        {3, 1, 8}
    };

    printf("矩阵M的三元组顺序表表示:\n");
    printMatrix(M_list, 7);

    printf("矩阵N的三元组顺序表表示:\n");
    printMatrix(N_list, 5);

    return 0;
}

计算矩阵M和N的乘积Q，并将结果打印输出：

#include <stdio.h>

#define ROW_M 3
#define COL_M 4
#define ROW_N 4
#define COL_N 2
#define COL_Q COL_N

void printMatrix(int matrix[][COL_Q], int row, int col) {
    for (int i = 0; i < row; i++) {
        for (int j = 0; j < col; j++) {
            printf("%d ", matrix[i][j]);
        }
        printf("\n");
    }
    printf("\n");
}

int main() {
    int M[ROW_M][COL_M] = {
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12}
    };

    int N[ROW_N][COL_N] = {
        {1, 2},
        {3, 4},
        {5, 6},
        {7, 8}
    };

    int Q[ROW_M][COL_Q] = {0};

    for (int i = 0; i < ROW_M; i++) {
        for (int j = 0; j < COL_Q; j++) {
            for (int k = 0; k < COL_M; k++) {
                Q[i][j] += M[i][k] * N[k][j];
            }
        }
    }

    printf("矩阵M和N的乘积Q:\n");
    printMatrix(Q, ROW_M, COL_Q);

    return 0;
}

请注意，这里的矩阵乘法的结果是一个3×2的矩阵，命名为Q。