C语言实现一个简单的矩阵运算器

最新推荐文章于 2025-05-26 10:41:14 发布
原创 最新推荐文章于 2025-05-26 10:41:14 发布 · 2.6k 阅读 · 61 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
收录于
C语言

当前文章被收录于：

C语言
6 篇文章 0 人学习

~~~

订阅专栏 查看详情
这个博客介绍了一个使用C++编写的矩阵运算程序，包括矩阵的加减、乘法、转置、求逆和行列式的计算。程序通过用户输入选择操作，并提供了友好的交互界面。文章还展示了加法操作的示例，并鼓励读者尝试其他功能。

源代码：

正文开始@Assassin

目录：

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

void Menu(void);  //菜单
int Input(void);    //输入
void Judge(void); //退出/循环判定

void Add(void);             //加减
void Multiply(void);             //乘法
void Transpose(void);            //转置
void Inverse(void);               //求逆
void Determinant(void);       //求行列式
int Recursion(int** a, int n); //行列式递归

//主函数
int main(void)
{
    //菜单
    Menu();
    //检测输入
    switch (Input())
    {
    case 1:
        Add();
        break; //加减
    case 2:
        Multiply();
        break; //乘法
    case 3:
        Transpose();
        break; //转置
    case 4:
        Inverse();
        break; //求逆
    case 5:
        Determinant();
        break; //求行列式
    default:
        printf("错误 自动退出");
        return 0;
        break;
    }
    //退出/循环判定
    Judge();

    return 0;
}

//菜单
void Menu(void)
{
    printf("\n\t欢迎使用本矩阵运算程序\n");
    printf("\n\t输入 1 进行矩阵加减");
    printf("\n\t输入 2 进行矩阵乘法");
    printf("\n\t输入 3 进行矩阵转置");
    printf("\n\t输入 4 进行矩阵求逆");
    printf("\n\t输入 5 求矩阵的行列式\n");
    printf("\n\t请输入想进行的操作编号\n\t");
}

//输入
int Input(void)
{
    int input = NULL;
    scanf("%d", &input); //接收input
    switch (input)
    { //清空缓存区
    case 1:
        fflush(stdin);
        return 1;
        break; //清空缓冲区并返回
    case 2:
        fflush(stdin);
        return 2;
        break;
    case 3:
        fflush(stdin);
        return 3;
        break;
    case 4:
        fflush(stdin);
        return 4;
        break;
    case 5:
        fflush(stdin);
        return 5;
        break;
    default:
        fflush(stdin);
        printf("\n\t请输入正确的编号\n\t");
        Input();
        break; //输入1到5 正常进行 否则重新输入
    }
    return -1;
}

//退出/循环判定
void Judge(void)
{
    int input = NULL;
    printf("\n\t输入1回到初始菜单 输入其他退出程序\n\t");
    scanf("%d", &input);
    if (input == 1)
    {
        system("cls"); //清屏
        main();
    }
    else
    {
        exit(0); //退出
    }
}

//加减///////////////////////////////////////////////////////////////////////////
void Add(void)
{
    int hang = 0, lie = 0, flag = -1, input = NULL; //行和列 和符号
    //输入行列
    printf("\n\t请输入矩阵的行\n\t");
    scanf("%d", &hang);
    getchar(); //清空缓存区

    printf("\t请输入矩阵的列\n\t");
    scanf("%d", &lie);
    getchar();

    //建立 hang*lie 大小的两个二维数组
    int **Matrix1 = (int **)malloc(hang * sizeof(int *)); //Matrix1[hang][lie];申请动态分配内存
    int **Matrix2 = (int **)malloc(hang * sizeof(int *)); //jvzhen2[hang][lie];
    for (int a = 0; a < hang; a++)
    {
        Matrix1[a] = (int *)malloc(lie * sizeof(int));
        Matrix2[a] = (int *)malloc(lie * sizeof(int));
    }
    //输入1
    printf("\n\t请输入第一个矩阵(请按行规范输入)\n\t");
    for (int a = 0; a < hang; a++)
    {
        for (int b = 0; b < lie; b++)
        {
            scanf("%d", &Matrix1[a][b]);
        }
        printf("\t");
    }
    //输入2
    printf("请输入第二个矩阵(请按行规范输入)\n\t");
    for (int a = 0; a < hang; a++)
    {
        for (int b = 0; b < lie; b++)
        {
            scanf("%d", &Matrix2[a][b]);
        }
        printf("\t");
    }
    //判断加减
    printf("输入1进行矩阵加法 输入其他进行减法\n\t");
    scanf("%d", &input);
    if (input == 1)
    {
        flag = 1; //符号变正
    }
    else
    {
        flag = -1;
    }
    //运算
    for (int a = 0; a < hang; a++)
    {
        for (int b = 0; b < lie; b++)
        {
            Matrix1[a][b] += (flag * Matrix2[a][b]);
        }
    }
    //输出结果
    printf("\t结果为\n\n\t");
    for (int a = 0; a < hang; a++)
    {
        for (int b = 0; b < lie; b++)
        {
            printf("%-5d ", Matrix1[a][b]);
        }
        printf("\n\n\t");
    }
    //free数组 jvzhen[hang][lie]
    for (int a = 0; a < hang; a++) //释放动态空间
    {
        free(Matrix1[a]); //释放lie
        free(Matrix2[a]); //hang次
    }
    free(Matrix1); //释放hang
    free(Matrix2);
}

//乘法///////////////////////////////////////////////////////////////////////////
void Multiply(void)
{
    int hang = 0, lie = 0, lie2 = 0, temp = 0; //行和列
    //输入行列
    printf("\n\t请输入左边矩阵的行\n\t");
    scanf("%d", &hang);
    getchar(); //清空缓存区
    printf("\t请输入左边矩阵的列\n\t");
    scanf("%d", &lie);
    getchar();
    printf("\t请输入右边矩阵的列\n\t");
    scanf("%d", &lie2);
    getchar();
    //建立三个二维数组
    int **Matrix1 = (int **)malloc(hang * sizeof(int *));
    int **Matrix2 = (int **)malloc(lie * sizeof(int *));
    int **jvzhen3 = (int **)malloc(hang * sizeof(int *));
    for (int a = 0; a < hang; a++)
    {
        Matrix1[a] = (int *)malloc(lie * sizeof(int));  //hang * lie
        jvzhen3[a] = (int *)malloc(lie2 * sizeof(int)); //hang * lie2
    }
    for (int a = 0; a < lie; a++)
    {
        Matrix2[a] = (int *)malloc(lie2 * sizeof(int)); //lie * lie2
    }
    //输入1
    printf("\n\t请输入第一个矩阵(请按行规范输入)\n\t");
    for (int a = 0; a < hang; a++)
    {
        for (int b = 0; b < lie; b++)
        {
            scanf("%d", &Matrix1[a][b]);
        }
        printf("\t");
    }
    //输入2
    printf("请输入第二个矩阵(请按行规范输入)\n\t");
    for (int a = 0; a < lie; a++)
    {
        for (int b = 0; b < lie2; b++)
        {
            scanf("%d", &Matrix2[a][b]);
        }
        printf("\t");
    }
    //运算
    for (int a = 0; a < hang; a++)
    {
        for (int b = 0; b < lie2; b++)
        {
            temp = 0;
            for (int c = 0; c < lie; c++)
            {
                temp += (Matrix1[a][c] * Matrix2[c][b]);
            }
            jvzhen3[a][b] = temp;
        }
    }
    //输出结果
    printf("结果为\n\n\t");
    for (int a = 0; a < hang; a++)
    {
        for (int b = 0; b < lie2; b++)
        {
            printf("%-5d ", jvzhen3[a][b]);
        }
        printf("\n\n\t");
    }
    //free数组
    for (int a = 0; a < hang; a++)
    {
        free(Matrix1[a]);
        free(jvzhen3[a]);
    }
    for (int a = 0; a < lie; a++)
    {
        free(Matrix2[a]);
    }
    free(Matrix1);
    free(Matrix2);
    free(jvzhen3);
}

//转置///////////////////////////////////////////////////////////////////////////
void Transpose(void)
{
    int hang = 0, lie = 0; //行和列
    //输入行列
    printf("\n\t请输入矩阵的行\n\t");
    scanf("%d", &hang);
    getchar(); //清空缓存区
    printf("\t请输入矩阵的列\n\t");
    scanf("%d", &lie);
    getchar();
    //建立两个二维数组
    int **Matrix1 = (int **)malloc(hang * sizeof(int *)); //hang*lie
    int **Matrix2 = (int **)malloc(lie * sizeof(int *));  //lie*hang
    for (int a = 0; a < hang; a++)
    {
        Matrix1[a] = (int *)malloc(lie * sizeof(int));
    }
    for (int a = 0; a < lie; a++)
    {
        Matrix2[a] = (int *)malloc(hang * sizeof(int));
    }
    //输入1
    printf("\n\t请输入矩阵(请按行规范输入)\n\t");
    for (int a = 0; a < hang; a++)
    {
        for (int b = 0; b < lie; b++)
        {
            scanf("%d", &Matrix1[a][b]);
        }
        printf("\t");
    }
    //运算
    for (int a = 0; a < lie; a++)
    {
        for (int b = 0; b < hang; b++)
        {
            Matrix2[a][b] = Matrix1[b][a];
        }
    }
    //输出结果
    printf("结果为\n\n\t");
    for (int a = 0; a < lie; a++)
    {
        for (int b = 0; b < hang; b++)
        {
            printf("%-5d ", Matrix2[a][b]);
        }
        printf("\n\n\t");
    }
    //free数组
    for (int a = 0; a < hang; a++)
    {
        free(Matrix1[a]);
    }
    for (int a = 0; a < lie; a++)
    {
        free(Matrix2[a]);
    }
    free(Matrix1);
    free(Matrix2);
}

//求逆///////////////////////////////////////////////////////////////////////////
/*算法参考  https://www.cnblogs.com/rollenholt/articles/2050662.html*/
void Inverse(void)
{
    //输入
    int jie, jie2, i, j, k;
    printf("\n\t请输入矩阵的阶数\n\t");
    scanf("%d", &jie);
    jie2 = jie * 2;
    //新建3个矩阵  2个 jie*jie   1个 jie*(2*jie)
    double **Matrix1 = (double **)malloc(jie * sizeof(double *)); //输入  jie*jie
    double **Matrix2 = (double **)malloc(jie * sizeof(double *)); //结果  jie*jie
    double **jvzhen3 = (double **)malloc(jie * sizeof(double *)); //扩展
    for (int a = 0; a < jie; a++)
    {
        Matrix1[a] = (double *)malloc(jie * sizeof(double)); //
        Matrix2[a] = (double *)malloc(jie * sizeof(double));
        jvzhen3[a] = (double *)malloc(2 * jie * sizeof(double));
    }
    //输入矩阵
    printf("\n\t请输入矩阵(请按行规范输入)\n\t");
    for (i = 0; i < jie; i++)
    {
        for (j = 0; j < jie; j++)
        {
            scanf("%lf", &Matrix1[i][j]);
            jvzhen3[i][j] = Matrix1[i][j]; //继承
        }
        printf("\t");
    }
    /*****************扩展矩阵***********************/
    for (i = 0; i < jie; i++)
    {
        for (j = jie; j < jie2; j++)
        {
            if (i == (j - jie))
            {
                jvzhen3[i][j] = 1;
            }
            else
            {
                jvzhen3[i][j] = 0;
            }
        }
    }
    /*****************扩展矩阵***********************/

    /*****************求逆模块***********************/
    for (i = 0; i < jie; i++)
    {
        if (jvzhen3[i][i] == 0)
        {
            for (k = i; k < jie; k++)
            {
                if (jvzhen3[k][i] != 0)
                {
                    for (int j = 0; j < jie2; j++)
                    {
                        double temp;
                        temp = jvzhen3[i][j];
                        jvzhen3[i][j] = jvzhen3[k][j];
                        jvzhen3[k][j] = temp;
                    }
                    break;
                }
            }
            if (k == jie)
            {
                printf("该矩阵不可逆");
                Judge(); //判定
                break;
            }
        }
        for (j = jie2 - 1; j >= i; j--)
        {
            jvzhen3[i][j] /= jvzhen3[i][i];
        }
        for (k = 0; k < jie; k++)
        {
            if (k != i)
            {
                double temp = jvzhen3[k][i];
                for (j = 0; j < jie2; j++)
                {
                    jvzhen3[k][j] -= temp * jvzhen3[i][j];
                }
            }
        }
    }
    /*****************求逆模块***********************/

    /*****************导出结果***********************/
    for (i = 0; i < jie; i++)
    {
        for (j = jie; j < jie2; j++)
        {
            Matrix2[i][j - jie] = jvzhen3[i][j];
        }
    }
    /*****************导出结果***********************/
    printf("结果为\n\n\t");
    for (i = 0; i < jie; i++)
    {
        for (j = 0; j < jie; j++)
        {
            printf("%-6.2lf ", Matrix2[i][j]);
        }
        printf("\n\t");
    }
    //free数组
    for (int a = 0; a < jie; a++)
    {
        free(Matrix1[a]);
        free(Matrix2[a]); //释放动态内存
        free(jvzhen3[a]);
    }
    free(Matrix1);
    free(Matrix2);
    free(jvzhen3);
}

//求行列式 //////////////////////////////////////////////////////////////////////
void Determinant(void)
{
    int jie = 0; //阶数
    //输入行列
    printf("\n\t请输入矩阵的阶数\n\t");
    scanf("%d", &jie);
    getchar(); //清空缓存区
    //建立一个二维数组
    int **Matrix1 = (int **)malloc(jie * sizeof(int *)); //输入
    for (int a = 0; a < jie; a++)
    {
        Matrix1[a] = (int *)malloc(jie * sizeof(int));
    }
    //输入1
    printf("\n\t请输入矩阵(请按行规范输入)\n\t");
    for (int a = 0; a < jie; a++)
    {
        for (int b = 0; b < jie; b++)
        {
            scanf("%d", &Matrix1[a][b]);
        }
        printf("\t");
    }
    //输出结果
    printf("结果为\n\n\t");
    printf("%d\n", Recursion(Matrix1, jie));
    printf("\n\n\t");

    //free数组
    for (int a = 0; a < jie; a++)
    {
        free(Matrix1[a]);
    }
    free(Matrix1);
}

//行列式递归
int Recursion(int **a, int n)
{
    int i, j, k;
    int len; //子行列式的阶
    int s = 0;
    len = n - 1;
    //按照定义，初始化一个子行列式数组的空间
    int **p = (int **)malloc(sizeof(int *) * len);
    for (i = 0; i < len; i++)
    {
        p[i] = (int *)malloc(sizeof(int) * len);
    }
    //阶为1，按照定义计算
    if (n == 1)
    {
        return a[0][0];
    }
    for (k = 0; k < n; k++)
    {
        for (i = 0; i < len; i++)
        {
            for (j = 0; j < len; j++)
            {
                if (i < k)
                {
                    p[i][j] = a[i][j + 1]; //初始化子行列式的值
                }
                if (i >= k)
                {
                    p[i][j] = a[i + 1][j + 1];
                }
            }
        }
        s += (int)pow(-1, k) * a[k][0] * Recursion(p, len); //递归计算
    }
    for (i = 0; i < len; i++)
    {
        free(p[i]);
    }
    free(p);
    return s;
}

运行结果：

这里只演示加法：
在这里插入图片描述
以上是g++的命令行编译-----
在这里插入图片描述
如图~~

其他功能请自己尝试，都可以实现~

see you next blog~~

标签
#c语言 #矩阵
单片机C语言实例-矩阵键盘简易计算器.zip
12-14
单片机C语言实例-矩阵键盘简易计算器.zip
有关矩阵的计算
m0_47055280的博客
06-16 788
有关矩阵的计算 #include<iostream> #include<math.h> #include<iomanip> using namespace std; int used[10]={0}; int tmp_array[10]; int tmp_coffeicient[10]={0}; int result=0; class MATRIX{ private: int matrix[10][10]={{0}}; int tmp_mat
编程训练-求矩阵乘积
yangjingdong2008的博客
09-05 463
编一程序，求两个矩阵的乘积 #include <iostream> #include <math.h> using namespace std; int matrixPro(int (*matrix1)[3]) { //cout << sizeof(matrix1)/sizeof(matrix1[0]) << endl; return 0; } int main() { int matrixA[2][2] = {{1,2},{4,5}};
C语言实现矩阵运算
YOLO_CODE的博客
08-12 1341
通过以上的C语言代码，我们可以实现矩阵的加法、减法、乘法和转置等基本运算。在C语言中，我们可以使用二维数组来表示一个矩阵。假设我们有两个矩阵A和B，它们分别为m行n列和n行p列的矩阵。矩阵的加法是指将两个同型矩阵对应位置的元素相加得到一个新的矩阵。假设我们有两个矩阵A和B，它们的行数和列数均相等。矩阵的减法与加法类似，只是将对应位置的元素相减得到一个新的矩阵。矩阵的转置是指将矩阵的行和列进行互换得到一个新的矩阵。矩阵的乘法是指将一个m行n列的矩阵A和一个n行p列的矩阵B相乘得到一个m行p列的矩阵C。
c语言——矩阵运算器
qq_62136607的博客
01-27 1909
话不多说，上代码！! #include<stdio.h> #include<stdlib.h> int n,m; float **a;//运用二重指针，避免二维数组做函数参数时长度未定情况 ;但是要先申请空间 void input() { int i,j; printf("请输入行数："); scanf("%d",&n); printf("请输入列数："); scanf("%d",&m); printf("请输入元素：\n"); a=(float *
课程设计：用C语言编写的稀疏矩阵运算器（加、减、乘、求逆）
木质的旋律
09-25 8156
课程设计：用C语言编写的稀疏矩阵运算器，可对超过1000行的大矩阵执行加、减、乘、求逆运算。
稀疏矩阵的运算C语言——课程设计实习
m0_46404001的博客
01-08 5963
稀疏矩阵是指那些多数元素为零的矩阵。利用“稀疏”特点进行存储和计算可以大大节省存储空间，提高计算准备效率。实现一个能进行稀疏矩阵基本运算的运算器，具体功能有：以“带行逻辑链接信息”的三元组顺序表示稀疏矩阵，实现两个稀疏矩阵相加、相减、相乘的功能。稀疏矩阵的输入形式采用三元组表示，而运算结果的矩阵则以通常的阵列形式列出。疏矩阵采用带行逻辑链接信息的三元组顺序存储。
c语言稀疏矩阵运算器,数据结构：稀疏矩阵运算器
weixin_35574537的博客
05-19 3358
题目：设计一个程序，实现一个能进行稀疏矩阵基本运算的计算器。按照教科书《数据结构(C语言版)》(严蔚敏等)5.3.2节中描述的方法，以十字链表表示稀疏矩阵。一、需求分析稀疏矩阵是指那些多数元素为零的矩阵。利用“稀疏”特点进修学校储存和计算可以大大节省储存空间，提高计算效率。实现一个能进行稀疏矩阵基本运算的计算器。以“带行逻辑链接信息”的三元组顺序表表示稀疏矩阵，实现两个矩阵相加、相减和相乘的运算。...
数据结构课程设计：稀疏矩阵运算器
weixin_63113396的博客
02-20 2672
1、功能要求 基本功能： （1）稀疏矩阵相乘 （2）稀疏矩阵相加 （3）稀疏矩阵相减 （4）退出稀疏矩阵运算器 （5）对用户输入的矩阵进行判别是否符合矩阵运算的要求。 （6）运算结果的矩阵则以通常的阵列形式列出。 规定：输入的稀疏矩阵的非零元素以三元组的形式输入（即输入非零元素的行标、列标和值），无需输入值为零的元素。 输出形式：有中文提示，清晰易懂。 界面要求：有合理的提示，每个功能可以设立菜单，根据提示，可以完成相关的功能要求。
数据结构——稀疏矩阵运算器（C语言）
一个巨大的博客
10-30 6368
数据结构——稀疏矩阵运算器（C语言） /*****************稀疏矩阵运算器 ****************/ #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #define OK 1 #define TRUE 1 #define ERROR 0 #define FALSE 0 #define MAX_SIZE 100 ...
C语言矩阵运算器，实现矩阵加法、减法、乘法、转置和退出。
逆风笑的博客
06-08 385
C语言矩阵运算器，实现矩阵加法、减法、乘法、转置和退出。 C语言矩阵运算器，实现矩阵加法、减法、乘法、转置和退出。-C文档类资源-CSDN下载C语言矩阵运算器，实现矩阵加法、减法、乘法、转置和退出。更多下载资源、学习资料请访问CSDN下载频道.https://download.csdn.net/download/qq_42145681/85585047...
c语言 算矩阵乘法代码,C语言实现的矩阵乘法运算器
weixin_39918084的博客
05-19 705
需求编写程序模拟矩阵乘法，一个m*n的矩阵，乘以一个 n*m 的矩阵，并且输出结果。STEP 1 矩阵乘法的计算一个m行n列的矩阵与一个n行p列的矩阵可以相乘，得到的结果是一个m行p列的矩阵。其中乘积矩阵的第i行第j列位置上的数，为第一个矩阵第i行上的n个数与第二个矩阵第j列上的n个数对应相乘后所得的n个乘积之和。STEP 2 编程思路(1)需申请动态二维数组存储两个参与运算的矩阵以及一个结果...
数据结构课程设计《稀疏矩阵运算器》
weixin_30725467的博客
01-04 1551
最近正在弄数据结构课程设计内容，说实话，感觉自己数据结构学的就是渣，好多东西都不会。还是要多学点东西啊。现在暂且贴点之前写完的东西吧，到时候也好有个总结。 1 诸论 1.1 问题描述 稀疏矩阵是指那些多数元素为零的矩阵。利用“稀疏”特点进行存储和计算可以大大节省存储空间，提高计算准备效率。实现一个能进行稀疏矩阵基本运算的运算器。 1.2 基本要求 以“带...
稀疏矩阵运算器 c语言,数据结构——稀疏矩阵运算器（C语言）
weixin_42356282的博客
05-20 848
/*****************稀疏矩阵运算器 ****************/#include#include#define OK 1#define TRUE 1#define ERROR 0#define FALSE 0#define MAX_SIZE 100typedef struct{ //构造三元组int x;int y;int e;}Triad;typedef ...
用c语言设计一个矩阵运算器的课程设计报告的设计和调试分析,课程设计：用C语言编纂的稀疏矩阵运算器（加、减、乘、求逆）...
weixin_35797090的博客
05-18 438
课程设计：用C语言编写的稀疏矩阵运算器(加、减、乘、求逆)#include#includeint system(const char *string);#define maxsize 2000typedef struct{int row;int col;int data;}triple;typedef struct{triple data[maxsize];int m,n,len;}matrix;...
CQT矩阵运算器：轻松实现矩阵运算，提高计算效率
最新发布
gitblog_06774的博客
05-26 1190
CQT矩阵运算器：轻松实现矩阵运算，提高计算效率 去发现同类优质开源项目:https://gitcode.com/ 项目介绍 在科学计算和工程领域，矩阵运算是一项基础而重要的任务。CQT矩阵运算器，一个基于C++和QT框架开发的矩阵计算工具，为用户提供了高效、便捷的矩阵操作体验。本项目支持矩阵的加法、减法、乘法以及转置操作，是科研人员、学生以及开发者的得力助手。 项目技术分析 CQT矩阵运算器采用...
C语言实现一个矩阵乘法计算器
Walker
01-15 1956
C语言实现一个矩阵乘法计算器 代码如下 虽然还有很多可以改进的地方，比如把输入矩阵做成函数以简化代码，不过本人初学能力有限，只想实现这样一个简单的小功能。 #include <stdio.h> int main(void) { int m,n; //输入第一个矩阵的规格 printf("请输入第一个矩阵的行数和列数:\n"); scanf("%d %d",&m,&n); if(m<=0|
（数据结构课程设计）稀疏矩阵运算器
青春
05-24 7817
1．设计内容  稀疏矩阵是指那些多数元素为零的矩阵。利用“稀疏”特点进行存储和计算可以大大节省存储空间，提高计算准备效率。实现一个能进行稀疏矩阵基本运算的运算器。    具体功能有：（1）以“带行逻辑链接信息”的三元组顺序表示稀疏矩阵，实现两个稀疏矩阵相加、相减、相乘和求逆的运算。（2）稀疏矩阵的输入形式采用三元组表示，而运算结果的矩阵则以通常的阵列形式列出。2. 本设计所采用的数据结构稀疏矩阵采
稀疏矩阵运算器
fengzhongzhui_feng的博客
07-19 976
// 稀疏矩阵计算器.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #define MAXSIZE 12500 #define OK 1 typedef int ElemType; typedef int Status; typedef struct{ int i,j; ElemType e; }Triple; typedef
评论 12
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

宁海没有七号公园

谢谢你%%%

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值