c语言中两个矩阵相减怎么表示

两个矩阵相减，需要满足两个矩阵的维度相同，即行数和列数均相等。假设两个矩阵分别为A和B，它们的维度均为m行n列，那么它们相减的结果矩阵C的维度也为m行n列，表示为：

for(int i = 0; i < m; i++) {
    for(int j = 0; j < n; j++) {
        C[i][j] = A[i][j] - B[i][j];
    }
}

其中，i代表矩阵中的行数，j代表矩阵中的列数。通过遍历矩阵A和矩阵B的每个元素，计算它们的差值，即可得到矩阵C的每个元素的值。这段代码可以放在main函数中，也可以封装成一个函数，供需要使用的地方调用。

相关问题

用c语言角线)元素相减得到一个新的矩阵，在主函数输出计算后的矩阵。 上三角《包含对角线）元素相加及两个矩阵的下三角（不包含对 29、主函数内输入两个 5*5 矩阵，编写自定义函数同时将两个矩阵的

下三角（不包含对角线）元素相减得到一个新的矩阵，在主函数输出计算后的矩阵的C语言代码如下：

#include <stdio.h>

void sub_matrix(int matrix1[][5], int matrix2[][5]) {
  int result[5][5];
  // 计算下三角元素相减
  for (int i = 0; i < 5; i++) {
    for (int j = 0; j < 5; j++) {
      if (i > j) {
        result[i][j] = matrix1[i][j] - matrix2[i][j];
      } else {
        result[i][j] = 0;
      }
    }
  }
  // 输出计算后的矩阵
  printf("计算后的矩阵为：\n");
  for (int i = 0; i < 5; i++) {
    for (int j = 0; j < 5; j++) {
      printf("%d ", result[i][j]);
    }
    printf("\n");
  }
}

int main() {
  int matrix1[5][5], matrix2[5][5];
  // 输入两个矩阵
  printf("请输入第一个矩阵：\n");
  for (int i = 0; i < 5; i++) {
    for (int j = 0; j < 5; j++) {
      scanf("%d", &matrix1[i][j]);
    }
  }
  printf("请输入第二个矩阵：\n");
  for (int i = 0; i < 5; i++) {
    for (int j = 0; j < 5; j++) {
      scanf("%d", &matrix2[i][j]);
    }
  }
  // 调用自定义函数计算下三角元素相减得到新矩阵
  sub_matrix(matrix1, matrix2);
  return 0;
}

注意：上述代码中假设用户输入的两个矩阵都是 5x5 的，如果输入的矩阵不是这个大小，则需要做相应的修改。

使用c语言，编制一个能演示稀疏矩阵相加、相减、相乘、转置的程序。 (1)以带行逻辑链接信息的三元组顺序表表示稀疏矩阵。 (2)实现两个矩阵的相加、相减、相乘和矩阵转置。 (3)稀疏矩阵的输入形式可采用...

好的，以下是程序实现的代码：

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

#define MAXSIZE 100

typedef struct {
    int i, j;
    int e;
} Triple; // 三元组结构体

typedef struct {
    Triple data[MAXSIZE + 1]; // 三元组顺序表
    int mu, nu, tu; // 稀疏矩阵的行数、列数、非零元素个数
} TSMatrix;

// 构造稀疏矩阵
void CreateMatrix(TSMatrix *M) {
    int m, n, t;
    printf("请输入稀疏矩阵的行数、列数、非零元素个数：\n");
    scanf("%d %d %d", &m, &n, &t);
    M->mu = m;
    M->nu = n;
    M->tu = t;
    printf("请输入三元组表中每个元素的行、列、值：\n");
    for (int i = 1; i <= t; i++) {
        scanf("%d %d %d", &M->data[i].i, &M->data[i].j, &M->data[i].e);
    }
}

// 矩阵转置
void TransposeMatrix(TSMatrix M, TSMatrix *T) {
    T->mu = M.nu;
    T->nu = M.mu;
    T->tu = M.tu;
    if (T->tu) {
        int q = 1;
        for (int col = 1; col <= M.nu; col++) {
            for (int p = 1; p <= M.tu; p++) {
                if (M.data[p].j == col) {
                    T->data[q].i = M.data[p].j;
                    T->data[q].j = M.data[p].i;
                    T->data[q].e = M.data[p].e;
                    q++;
                }
            }
        }
    }
}

// 稀疏矩阵相加
void AddMatrix(TSMatrix M1, TSMatrix M2, TSMatrix *M3) {
    if (M1.mu != M2.mu || M1.nu != M2.nu) {
        printf("两个矩阵的行列数不同，无法相加！\n");
        M3->tu = 0;
        return;
    }
    int i = 1, j = 1, k = 1;
    while (i <= M1.tu && j <= M2.tu) {
        if (M1.data[i].i < M2.data[j].i || (M1.data[i].i == M2.data[j].i && M1.data[i].j < M2.data[j].j)) {
            M3->data[k++] = M1.data[i++];
        } else if (M1.data[i].i == M2.data[j].i && M1.data[i].j == M2.data[j].j) {
            int e = M1.data[i].e + M2.data[j].e;
            if (e != 0) {
                M3->data[k].i = M1.data[i].i;
                M3->data[k].j = M1.data[i].j;
                M3->data[k].e = e;
                k++;
            }
            i++;
            j++;
        } else {
            M3->data[k++] = M2.data[j++];
        }
    }
    while (i <= M1.tu) {
        M3->data[k++] = M1.data[i++];
    }
    while (j <= M2.tu) {
        M3->data[k++] = M2.data[j++];
    }
    M3->mu = M1.mu;
    M3->nu = M1.nu;
    M3->tu = k - 1;
}

// 稀疏矩阵相减
void SubMatrix(TSMatrix M1, TSMatrix M2, TSMatrix *M3) {
    if (M1.mu != M2.mu || M1.nu != M2.nu) {
        printf("两个矩阵的行列数不同，无法相减！\n");
        M3->tu = 0;
        return;
    }
    int i = 1, j = 1, k = 1;
    while (i <= M1.tu && j <= M2.tu) {
        if (M1.data[i].i < M2.data[j].i || (M1.data[i].i == M2.data[j].i && M1.data[i].j < M2.data[j].j)) {
            M3->data[k++] = M1.data[i++];
        } else if (M1.data[i].i == M2.data[j].i && M1.data[i].j == M2.data[j].j) {
            int e = M1.data[i].e - M2.data[j].e;
            if (e != 0) {
                M3->data[k].i = M1.data[i].i;
                M3->data[k].j = M1.data[i].j;
                M3->data[k].e = e;
                k++;
            }
            i++;
            j++;
        } else {
            M3->data[k++] = M2.data[j++];
        }
    }
    while (i <= M1.tu) {
        M3->data[k++] = M1.data[i++];
    }
    while (j <= M2.tu) {
        M3->data[k].i = M2.data[j].i;
        M3->data[k].j = M2.data[j].j;
        M3->data[k++].e = -M2.data[j++].e;
    }
    M3->mu = M1.mu;
    M3->nu = M1.nu;
    M3->tu = k - 1;
}

// 稀疏矩阵相乘
void MultMatrix(TSMatrix M1, TSMatrix M2, TSMatrix *M3) {
    if (M1.nu != M2.mu) {
        printf("两个矩阵无法相乘！\n");
        M3->tu = 0;
        return;
    }
    int q = 1;
    int tpot[MAXSIZE + 1] = {0}; // 存储M2矩阵中每一列的第一个非零元素在b数组中的位置
    for (int col = 1; col <= M2.nu; col++) {
        for (int p = 1; p <= M2.tu; p++) {
            if (M2.data[p].j == col) {
                tpot[col] = p;
                break;
            }
        }
    }
    for (int row = 1; row <= M1.mu; row++) {
        int c[MAXSIZE + 1] = {0}; // 存储M3矩阵中每一行的值
        for (int p = tpot[1]; p <= M2.tu; p++) {
            int col = M2.data[p].j;
            if (col > M1.nu) {
                break;
            }
            if (tpot[col] == 0) {
                continue;
            }
            int q1 = tpot[col];
            int q2 = p;
            while (q1 <= M1.tu && M1.data[q1].i == row && q2 <= M2.tu && M2.data[q2].j == col) {
                if (M1.data[q1].j < M2.data[q2].i) {
                    q1++;
                } else if (M1.data[q1].j > M2.data[q2].i) {
                    q2++;
                } else {
                    c[col] += M1.data[q1].e * M2.data[q2].e;
                    q1++;
                    q2++;
                }
            }
        }
        for (int col = 1; col <= M1.nu; col++) {
            if (c[col] != 0) {
                M3->data[q].i = row;
                M3->data[q].j = col;
                M3->data[q].e = c[col];
                q++;
            }
        }
    }
    M3->mu = M1.mu;
    M3->nu = M2.nu;
    M3->tu = q - 1;
}

// 输出稀疏矩阵
void PrintMatrix(TSMatrix M) {
    printf("稀疏矩阵的三元组表：\n");
    printf("行 列 值\n");
    for (int i = 1; i <= M.tu; i++) {
        printf("%2d %2d %2d\n", M.data[i].i, M.data[i].j, M.data[i].e);
    }
}

int main() {
    TSMatrix M1, M2, M3;
    printf("请输入第一个稀疏矩阵：\n");
    CreateMatrix(&M1);
    printf("第一个稀疏矩阵为：\n");
    PrintMatrix(M1);
    printf("请输入第二个稀疏矩阵：\n");
    CreateMatrix(&M2);
    printf("第二个稀疏矩阵为：\n");
    PrintMatrix(M2);
    printf("第一个稀疏矩阵的转置矩阵为：\n");
    TransposeMatrix(M1, &M3);
    PrintMatrix(M3);
    printf("第二个稀疏矩阵的转置矩阵为：\n");
    TransposeMatrix(M2, &M3);
    PrintMatrix(M3);
    printf("两个稀疏矩阵相加的结果为：\n");
    AddMatrix(M1, M2, &M3);
    PrintMatrix(M3);
    printf("两个稀疏矩阵相减的结果为：\n");
    SubMatrix(M1, M2, &M3);
    PrintMatrix(M3);
    printf("两个稀疏矩阵相乘的结果为：\n");
    MultMatrix(M1, M2, &M3);
    PrintMatrix(M3);
    return 0;
}

程序中使用了三元组顺序表来表示稀疏矩阵，具体实现了矩阵的转置、相加、相减、相乘等功能。在程序运行时，先输入两个稀疏矩阵的信息，然后分别输出它们的转置矩阵和相加、相减、相乘的结果。