C语言制作稀疏矩阵运算器，要求不使用三重及三重以上嵌套循环，时间复杂度较低

C语言做一个稀疏矩阵运算器，要求不使用三重及三重以上嵌套循环，并且时间复杂度较低，可以实现矩阵运算器的矩阵转置，矩阵加减法，矩阵乘法，退出运算五个功能，可以适当追加赏金。

解答如下

#include<stdio.h>
void input(int n,int t[][n])
{
    for(int i=0; i<n; i++)
    {
        for(int j=0; j<n; j++)
        {
            scanf("%d",&t[i][j]);
        }
    }
}
void put(int n,int t[][n])
{
    for(int i=0; i<n; i++)
    {
        for(int j=0; j<n; j++)
        {
            printf("%d ",t[i][j]);
        }
        printf("\n");
    }
    printf("\n");
}
void swap(int *a,int *b)
{
    int c=*a;
    *a=*b;
    *b=c;
}
void trans(int n,int t[][n])
{
    for(int i=0; i<n; i++)
    {
        for(int j=i; j<n; j++)
        {
            swap(&t[i][j],&t[j][i]);
        }
    }
}
void add(int n,int t1[][n],int t2[][n])
{
    for(int i=0; i<n; i++)
    {
        for(int j=0; j<n; j++)
        {
            t1[i][j]+=t2[i][j];
        }
    }
}

void mul(int n,int t1[][n],int t2[][n])
{
    for(int i=0; i<n; i++)
    {
        for(int j=0; j<n; j++)
        {
            t1[i][j]*=t2[i][j];
        }
    }
}
int main()
{
    int n;
    printf("1,转置\n");
    printf("2,加法\n");
    printf("3,乘法\n");
    printf("other,退出\n");
    int option;
    scanf("%d",&option);
    if(option==1)
    {
        printf("输入矩阵行数：");
        scanf("%d",&n);
        printf("输入矩阵：\n");
        int t1[n][n];
        input(n,t1);
        trans(n,t1);
        printf("--------\n");
        put(n,t1);
    }
    else if(option==2)
    {
        printf("输入矩阵行数：");
        scanf("%d",&n);
        int t1[n][n];
        int t2[n][n];
        printf("输入矩阵1：\n");
        input(n,t1);
        printf("输入矩阵2：\n");
        input(n,t2);
        add(n,t1,t2);
        printf("--------\n");
        put(n,t1);
    }
    else if(option==3)
    {
        printf("输入矩阵行数：");
        scanf("%d",&n);
        int t1[n][n];
        int t2[n][n];
        printf("输入矩阵1：\n");
        input(n,t1);
        printf("输入矩阵2：\n");
        input(n,t2);
        mul(n,t1,t2);
        printf("--------\n");
        put(n,t1);
    }
    else
    {
        return 0;
    }
}

/*****************稀疏矩阵运算器 ****************/

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

#define OK    1
#define TRUE  1
#define ERROR 0
#define FALSE 0

#define MAX_SIZE 100
 

typedef struct{      //构造三元组 
    int x;
    int y; 
    int e;
}Triad;
typedef struct {
    int mrow,mcol,ms;
    Triad data[MAX_SIZE];
}Rtriad;

void Input(Rtriad &S){                                  //以三元组方式输入矩阵 
    printf("请输入行，列（row col）:");
    scanf("%d%d",&S.mrow,&S.mcol);
    printf("请以行序为主序，以三元组的方式输入矩阵元素,'-1 -1 -1'表示结束:\n"); 
    int x,y,z;
    scanf("%d%d%d",&x,&y,&z);
    S.ms=0;
    while(!(x==-1&&y==-1&&z==-1)){                 //长度为S.ms+1，从0开始到S.ms 
        S.data[S.ms].x=x;
        S.data[S.ms].y=y;
        S.data[S.ms].e=z; 
        S.ms++;   
        scanf("%d%d%d",&x,&y,&z);
    }
    S.ms--;
}

void Add(Rtriad S1,Rtriad S2,Rtriad &S3){              //矩阵相加 
    if(S1.mcol!=S2.mcol||S1.mrow!=S2.mrow){
        printf("ERROR!!!\n");
        return ;
    }
    S3.mcol=S1.mcol ;
    S3.mrow=S1.mrow ;
    S3.ms=0;
    int row,col,s,x,y,z;
    for(row=1;row<=S3.mrow;row++){
        for(col=1;col<=S3.mcol;col++){
            z=0;
            for(s=0;s<=S1.ms;s++){
                if(S1.data[s].x==row&&S1.data[s].y==col){
                    S3.data[S3.ms].x=row;
                    S3.data[S3.ms].y=col;
                    S3.data[S3.ms].e=S1.data[s].e;
                    z++;    
                }
            }
            for(s=0;s<=S2.ms;s++){
                if(S2.data[s].x==row&&S2.data[s].y==col){
                    S3.data[S3.ms].x=row;
                    S3.data[S3.ms].y=col;
                    if(z==0)
                        S3.data[S3.ms].e=S2.data[s].e;
                    else
                        S3.data[S3.ms].e+=S2.data[s].e;
                    z++;                    
                }    
            }
            if(z!=0)
                S3.ms++;
        }
    }
    
    int m=0;
    for(int t=0;t<=S3.ms;t++){
        if(S3.data[t].e==0){     //删除
        for(int i=t+1;i<S3.ms;i++){
            S3.data[i-1]=S3.data[i];
        } 
        m++;
        }
    } 
    S3.ms-=m;
}

void Printf(Rtriad S){                                 //打印矩阵 
    int a[S.mrow][S.mcol];
    for(int i=0;i<S.mrow;i++)
        for(int j=0;j<S.mcol;j++)
            a[i][j]=0;
    
    for(int k=0;k<=S.ms;k++)
        a[S.data[k].x-1][S.data[k].y-1]=S.data[k].e;   
        
    //printf("\n\n矩阵为：\n");    
    for(int i=0;i<S.mrow;i++){
        for(int j=0;j<S.mcol;j++)
            printf("%-2d ",a[i][j]);
        printf("\n");          
    }
}

void Sub(Rtriad S1,Rtriad S2,Rtriad &S3){             //矩阵相减   
    for(int i=0;i<=S2.ms;i++)
        S2.data[i].e*=-1;
    Add(S1,S2,S3);
    for(int i=0;i<=S2.ms;i++)
        S2.data[i].e*=-1;    
}

void Mult(Rtriad S1,Rtriad S2,Rtriad &S3){           //矩阵相乘
    if(S1.mcol!=S2.mrow){
        printf("ERROR!!!\n");
        return ;
    }
    
    S3.mrow=S1.mrow;
    S3.mcol=S2.mcol;
    S3.ms=0;
    
    int s1[S1.mrow][S1.mcol];
    int s2[S2.mrow][S2.mcol];
    int s3[S3.mrow][S3.mcol];
    
    for(int i=0;i<S1.mrow;i++)
        for(int j=0;j<S1.mcol;j++)
            s1[i][j]=0;     
    for(int i=0;i<S2.mrow;i++)
        for(int j=0;j<S2.mcol;j++)
            s2[i][j]=0;
    for(int i=0;i<S3.mrow;i++)
        for(int j=0;j<S3.mcol;j++)
            s3[i][j]=0;
            
            
    for(int k=0;k<=S1.ms;k++)
        s1[S1.data[k].x-1][S1.data[k].y-1]=S1.data[k].e;
    for(int k=0;k<=S2.ms;k++)
        s2[S2.data[k].x-1][S2.data[k].y-1]=S2.data[k].e;        
     
    for(int row=0;row<S3.mrow;row++){
        for(int col=0;col<S3.mcol;col++){
            for(int k=0;k<S1.mcol;k++)
                s3[row][col]+=(s1[row][k]*s2[k][col]);
                
            if(s3[row][col]!=0){
                S3.data[S3.ms].x=row+1;
                S3.data[S3.ms].y=col+1;
                S3.data[S3.ms].e=s3[row][col];
                S3.ms++;
            }    
        }
    }
}

void Tran(Rtriad &S1,Rtriad &S2){                   //矩阵的快速转置 
    
    S2.ms=S1.ms;
    S2.mcol=S1.mrow;
    S2.mrow=S1.mcol;
    int num[MAX_SIZE];      //每一列的元素个数 ,从1开始计数 
    int pos[MAX_SIZE];      
    
    for(int col=1;col<=S1.mcol;col++)   //初始化num 
        num[col]=0;
        
    for(int i=0;i<=S1.ms;i++)    //给num赋值 ,num从1开始 
        num[S1.data[i].y]++;
                
    pos[1]=1;                     //给pos赋值 ，pos从1开始 
    for(int col=2;col<=S1.mcol;col++)
        pos[col]=pos[col-1]+num[col-1];

    for(int k=0;k<=S1.ms;k++){              //S1,S2都是从data[0]开始的 
        int col=S1.data[k].y;
        int q=pos[col];
        S2.data[q-1].e=S1.data[k].e;
        S2.data[q-1].x=S1.data[k].y;
        S2.data[q-1].y=S1.data[k].x;
        
        pos[col]++;
    }    

}

int main(){
    printf("/*****************稀疏矩阵运算器 ****************/\n\n");
    printf("功能选择：\n1.矩阵相加\n2.矩阵相减\n3.矩阵相乘\n4.矩阵转置\n");
    int n;
    printf("选择功能："); 
    scanf("%d",&n);
    Rtriad S1,S2,S3;
    switch(n){
        case 1:
            printf("\n请输入矩阵1：\n");
            Input(S1);
            printf("\n请输入矩阵2：\n");
            Input(S2);
            Add(S1,S2,S3);
            printf("\n结果为：\n");
            Printf(S3); 
            break;
        case 2:
            printf("\n请输入矩阵1：\n");
            Input(S1);
            printf("\n请输入矩阵2：\n");
            Input(S2);
            Sub(S1,S2,S3);
            printf("\n结果为：\n");
            Printf(S3); 
            break;    
        case 3:
            printf("\n请输入矩阵1：\n");
            Input(S1);
            printf("\n请输入矩阵2：\n");
            Input(S2);
            Mult(S1,S2,S3);
            printf("\n结果为：\n");
            Printf(S3); 
            break;    
        case 4:
            printf("\n请输入矩阵1：\n");
            Input(S1);
            Tran(S1,S2);
            printf("\n结果为：\n");
            Printf(S3); 
            break;
    }
    return 0;
}

那就把第三层改成嵌套if，不过情况貌似不少

题目是啥呢

首先for循环建议不要超过两层，不然的话，时间复杂度会很大。然后是如何优化for循环，首先需要考虑的是从代码的思路上，也就是换一种方式解决同样的问题，但对于你这种写好的三层for循环，很明显不能进行优化。你可以把题目放出来，这样的话，换种思路去写代码，也是算一种优化！
如有帮助感谢采纳，不懂可继续交流！