数据结构课程设计：稀疏矩阵（加、减、乘、求逆矩阵）

经过一周的课设，课设终于接近尾声了，期间重写了3边，第一次是变量名太混乱，各种瞎胡搞，“ii kk”这些奇葩变量都用上了，这次是一个警钟吧，要记住。第二次重写是因为，参照学长博客，但用到了指针的东西，自己指针学的渣，怕给组员讲不懂，所以，有了这最后一个版本。自我感觉，最后一个版本写的还可以，不过还是有一个小小的bug，今天中午写说明书的时候发现的，加法（减法用加法实现，当然也有），在计算时，最后一行就没进行运算。不会改了，就这样吧。最后附上PG的BLOG，看不懂我的，可以看他的。求逆矩阵，模拟是PG写的，我学他的。然后就是期末复习了，加油~~~

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

#define MAX_SIZE 1000
int system(const char *string);// 调用系统命令

typedef struct {
    int row, col;    //三元组表存储矩阵的行列，及其具体的值
    double val;
}elem;

typedef struct {
    elem data[MAX_SIZE];//三元组表数组
    int r, c, cnt;//三元组表存储实际矩阵的行列，及其非零元素的个数
    int r_cnt, c_cnt;//非零元的行数、列数
}Matrix;

Matrix a, b, c;//全局变量 三个用于运算的三元组表记录的矩阵

void print_equal()
{
    printf("================================================================================");
}

void print_menu()//打印菜单的函数
{
    print_equal();
    printf("=                            1.矩阵A + 矩阵B                                   =");
    printf("=                            2.矩阵A - 矩阵B                                   =");
    printf("=                            3.矩阵A * 矩阵B                                   =");
    printf("=                            4.求矩阵A的逆矩阵                                 =");
    printf("=                            5.退出                                            =");
    print_equal();
}

void init(Matrix &m)//初始化三元组表里德元素
{
    int i;
    m.r = m.c = m.cnt = 0; //使三元组表里的所有元素都为0
    m.r_cnt = m.c_cnt = 0;

    for(i = 0; i < MAX_SIZE; i++)
    {
        m.data[i].row = 0;
        m.data[i].col = 0;
        m.data[i].val = 0;
    }
}

void create_matrix(Matrix &m)///通过引用改变其值，very important！通过引用，可以不用创建新的形参，而直接在实参上边更改
{
    int n1, n2, n3;
    FILE *in, *out;
    FILE *in1, *in2;
    char in_ch1, in_ch2;
    char filename[100];
    int cmd;
    int row, col;
    int r, c;
    double val;
    r = c = 0;
    row = col = 0;
    puts("==============================创建一个矩阵======================================");
    puts("                                1.手动以三元组表方式输入");
    puts("                                2.文件以矩阵的方式读入");
    print_equal();
    scanf("%d%*c", &cmd);

    if(cmd == 1)
    {
        puts("====================请输入矩阵的行数、列数、以及非零元的个数====================");
        scanf("%d %d %d", &n1, &n2, &n3);
        m.r = n1;            //下标都是从0开始的！！
        m.c = n2;
        m.cnt = n3;
        puts("                         请输入矩阵的非零行数、非零列数 ");
        scanf("%d %d", &n1, &n2);
        m.r_cnt = n1;
        m.c_cnt = n2;
        int i = 0;
        for(i = 0; i < m.cnt; i++)
        {
            printf("                   请输入第%d个元素的行 列 及其值 \n", i+1);
            scanf("%d %d %d", &n1, &n2, &n3);
            m.data[i].row = n1-1;
            m.data[i].col = n2-1;
            m.data[i].val = n3;
        }
    }
    else if(cmd == 2)
    {
        system("cls");
        puts("==============================输入要读入文件的文件名====================================");
        gets(filename);//read file's name
        if((in = fopen(filename, "r")) == NULL)
        {
            printf("打开文件出错，看文件名是否输入正确，或者文件是否存在？\n");
            printf("刚才输入的文件名为：%s\n", filename);
            system("pause");
            exit(0);
        }
        else 
            printf("文件读取正常。。。");
        in1 = fopen(filename, "r");
        while(!feof(in1))
        {
            in_ch1 = fgetc(in1);
            if(in_ch1 == '\n')
                row++;
        }
        in2 = fopen(filename, "r");
        while(!feof(in2))
        {
            in_ch2 = fgetc(in2);
            if(in_ch2 == ' ')
                col ++;
            else if(in_ch2 == '\n')
                break;
        }
        //在文件读取完成后，while都不执行，所以都要加1

        row++;
        col++;
        printf("矩阵信息读入成功，行数为： %d,列数为： %d \n具体信息为 ：", row, col);

        int i = 0;
        while(!feof(in))
        {
            fscanf(in, "%lf", &val);
            if(val != 0)
            {
                m.data[i].val = val;
                m.data[i].row = r;
                m.data[i].col = c;
                printf("行值：%d, 列值 ： %d, 数值：%0.2lf\n", r+1, c+1, val);
                i++;
                c++;
                m.cnt++;
                if(c == col)
                {
                    c = 0;
                    r ++;
                }
            }
            else if(val == 0)
            {
                c ++;
                if(c == col)
                {
                    c = 0;
                    r++;
                }
            }
        }

        m.r = row;
        m.c = col;
    }
}

void print_matrix(Matrix m)//打印矩阵的函数
{
    /*printf("%d %d %d\n", m.r, m.c, m.cnt);*/
    FILE *out;
    char filename[100];
    int row, col;
    int i = 0;
    int cmd;
    puts("是否将结果打印在屏幕上？1.直接打印，2.写入到文件里。");
    scanf("%d%*c", &cmd);

    if(cmd == 1)
    {
        for(row = 0; row < m.r; row++)
        {
            for(col = 0; col < m.c; col++)
            {
                if(m.data[i].row == row && m.data[i].col == col)//如果在三元组表里找到当前元素，就输出，找不到，就输出0
                {
                    printf("%0.2lf ", m.data[i].val);//格式控制
                    i++;
                }
                else
                {
                    printf("0.00 ");
                }
            }
            puts("");//换行
        }
    }else if(cmd == 2)
    {
        system("cls");
        printf("输入要保存的文件名：");
        scanf("%s", filename);
        if((out = fopen(filename, "w")) == NULL)
        {
            printf("写入文件失败！！");
            exit(0);
        }
        else 
            puts("写入文件正常。");

        for(row = 0; row < m.r; row++)
        {
            for(col = 0; col < m.c; col++)
            {
                if(m.data[i].row == row && m.data[i].col == col)
                {
                    fprintf(out,"%0.2lf", m.data[i].val);
                    fputc(' ', out);
                    i++;
                }
                else
                {
                    fprintf(out, "0.00");
                    fputc(' ', out);
                }
            }
            fputc(10, out);
        }
        fclose(out);
        puts("已保存！");
    }
}

void init_cmd() //初始化需要两个三元组表的矩阵
{
    init(a);
    init(b);
    init(c);
    system("pause");
    system("cls");
    create_matrix(a);
    puts("===========================输入的矩阵以行列打印为：=============================");
    print_matrix(a);
    system("pause");
    system("cls");


    create_matrix(b);
    puts("===========================输入的矩阵以行列打印为：=============================");

    print_matrix(b);
    system("pause");
    system("cls");
}

int check(int cmd, Matrix m1, Matrix m2)//对输入的矩阵进行检查，看是否能够进行计算
{
    if(cmd == 1 || cmd == 2)
    {
        if(m1.r == m2.r && m1.c == m2.c)
            return 1;
        return 0;
    }
    else if(cmd == 3)
    {
        if(m1.c == m2.r)
            return 1;
        return 0;
    }
}

void clear()//清屏，打印菜单
{
    system("pause");
    system("cls");
    print_menu();
}

//加法自己加注释
void add_matrix(Matrix m1, Matrix m2, Matrix &m3)
{
    m3.r = m1.r;
    m3.c = m2.c;
    m3.cnt = 0;

    int i, j, k;
    i = j = k = 0;
    while((i < m1.cnt) && (j < m2.cnt))
    {
        if(m1.data[i].row == m2.data[j].row)
        {
            m3.data[k].row = m1.data[i].row;
            if(m1.data[i].col < m2.data[j].col)
            {
                m3.data[k].col = m1.data[i].col;
                m3.data[k].val = m1.data[i].val;
                k++; 
                i++;
            }
            else if(m1.data[i].col == m2.data[j].col)
            {
                if(m1.data[i].val + m2.data[i].val != 0)
                {
                    m3.data[k].col = m1.data[i].col;
                    m3.data[k].val = m1.data[i].val + m2.data[i].val;
                    k++; 
                    i++; 
                    j++;
                }
                else
                {
                    i++;
                    j++;
                }

            }
            else if(m1.data[i].col > m2.data[j].col)
            {
                m3.data[k].col = m2.data[j].col;
                m3.data[k].val = m2.data[j].val;
                k++;
                j++;
            }
        }
        else if(m1.data[i].row < m2.data[j].row)
        {
            m3.data[k].row = m1.data[i].row;
            m3.data[k].col = m1.data[i].col;
            m3.data[k].val = m1.data[i].val;
            k++;
            i++;
        }
        else if(m1.data[i].row > m2.data[j].row)
        {
            m3.data[k].row = m2.data[j].row;
            m3.data[k].col = m2.data[j].col;
            m3.data[k].val = m2.data[j].val;
            k++;
            j++;
        }
    }

    while(i < m1.cnt)
    {
        m3.data[k].row = m1.data[i].row;
        m3.data[k].col = m1.data[i].col;
        m3.data[k].val = m1.data[i].val;
        k++;
        i++;
    }
    while(j < m2.cnt)
    {
        m3.data[k].row = m2.data[j].row;
        m3.data[k].col = m2.data[j].col;
        m3.data[k].val = m2.data[j].val;
        k++;
        j++;
    }
    
    m3.cnt = k-1;
    
}

//乘法，自己加注释
void minus_matrix(Matrix m1, Matrix &m2, Matrix &m3)
{
    int i = 0;
    for(i = 0; i < m2.cnt; i++)
        m2.data[i].val = -m2.data[i].val;
    add_matrix(m1, m2, m3);
}

double value(Matrix m, int row, int col)
{
    int i = 0;
    while(i < m.cnt && m.data[i].row <= row)
    {
        if(m.data[i].row == row && m.data[i].col == col)
            return m.data[i].val;
        i++;
    }
    return 0.0;
}

void mul_matrix(Matrix m1, Matrix m2, Matrix &m3)
{
    int i, j, k, tag;
    double sum = 0;
    m3.r = m1.r;
    m3.c = m2.c;
    m3.cnt = 0;

    if(m1.cnt * m2.cnt != 0)
    {
        tag = 0;
        for(i = 0; i < m1.r; i++)
        {
            for(j = 0; j < m2.c; j++)
            {
                sum = 0;
                for(k = 0; k < m1.c; k++)
                {
                    sum += value(m1, i, k) * value(m2, k, j);
                }
                //printf("%lf\n ", sum);
                if(sum != 0)
                {
                    /*printf("%lf\n", sum);*/
                    m3.data[tag].row = i;
                    m3.data[tag].col = j;
                    m3.data[tag].val = sum;
                    tag++;
                }
            }
        }
        m3.cnt = tag;
    }
}

//思路就是通过初等变换求逆矩阵
int inversion(Matrix m1, Matrix m2, Matrix &m3)
{
    int i, j, k;
    /* 初始化构建的矩阵的三元组表*/
    m2.r = m1.r;
    m2.c = m1.c*2;
    m2.cnt = m2.r * m2.c;

    int row, col;
    row = col = 0;
    //初始化三元组表里每个元素的行列值
    for(i = 0; i < m2.cnt; i++)
    {
        m2.data[i].val = 0;
        m2.data[i].row = row;
        m2.data[i].col = col;

        col++;
        if(col == m2.c)
        {
            col = 0;
            row++;
        }
    }
    //初始化非零元素的具体值
    for(i = 0; i < m1.cnt; i++)
    {
        for(j = 0; j < m2.cnt; j++)
        {
            if(m2.data[j].row == m1.data[i].row && m2.data[j].col == m1.data[i].col)
            {
                m2.data[j].val = m1.data[i].val;
            }
        }
    }

    //运用公式，初始化单位矩阵
    j = 0;
    double n1, n2, n3, t, x ;
    n1 = n2 = 1.0;
    for(i = 0; i < m1.r; i++)
    {
        m2.data[j*m2.c+i+m2.r].val = 1;
        j++;
    }

    int row1;
    //print_matrix(m2);
    for(col = 0; col < m2.r; col++){
        for(row = 0; row < m2.r; row++){
            if(row != col){
                for(i = 0; i < m2.cnt; i++){
                    if(m2.data[i].row == row && m2.data[i].col == col){
                        n1 = m2.data[i].val;
                        break;
                    }
                }

                //取对角线上的值
                for(i = 0; i < m2.cnt; i++){
                    if(m2.data[i].row == col && m2.data[i].col == col){
                        n2 = m2.data[i].val;
                        break;
                    }
                }

                t = n1 / n2;
                //通过两重循环将每个值取出，然后乘以倍数，减去得到相应的值
                for(i = 0; i < 2*m2.r; i++)
                {
                    for(j = 0; j < m2.cnt; j++){
                        if(m2.data[j].row == col && m2.data[j].col == i){
                            n3 = m2.data[j].val;
                            break;
                        }
                    }

                    x = n3 * t;
                    for(k = 0; k < m2.cnt; k++)
                    {
                        if(m2.data[k].row == row && m2.data[k].col == i){
                            m2.data[k].val -= x;
                            break;
                        }
                    }
                }

                int tag = 0;
                //鉴别能否求逆
                for(row1 = 0; row1 < m2.r; row1++) {
                    tag = 0;
                    for(i = 0; i < m2.cnt; i++) {
                        if(m2.data[i].row == row1 ) {
                            if(m2.data[i].val == 0)
                                tag++;
                            if(tag == m1.c)
                            {
                                return 0 ;
                            }
                        }    
                    }
                }
            }
        }
    } 
    row = col = 0;
    i = j = k = 0;
    n1 = n2 = n3 = 0;
    //将主对角线上的元素单位话
    for(row = 0; row < m2.r; row++){
        for(i = 0; i < m2.cnt; i++){
            if(m2.data[i].row == row && m2.data[i].col == row){
                n1 = m2.data[i].val;
                break;
            }
        }
        //同除以一个数，使前一个矩阵变为单位矩阵
        for(col = 0; col < m2.c; col++) {
            for(i = 0; i < m2.cnt; i++) {
                if(m2.data[i].row == row && m2.data[i].col == col) {
                    m2.data[i].val /= n1;
                    break;
                }
            }
        }
    }

    row = col;

    int r, c;
    r = c = 0;

    m3.cnt = m2.cnt / 2;
    m3.r = m2.r;
    m3.c = m2.r;
    for(i = 0; i < m3.cnt; i++){
        m3.data[i].val = m2.data[i + (r+1)*m2.r].val;
        m3.data[i].row = m2.data[i + (r+1)*m2.r].row;
        m3.data[i].col = m2.data[i + (r+1)*m2.r].col - m2.r;
        c++;
        if(c == m3.r) {
            c = 0;
            r++;

        }
    }
    return 1;
}

int main()
{
    //freopen("in.txt", "r", stdin);
    //freopen("out.txt", "w", stdout);
    int cmd;
    int tag = 0;
    print_menu();
    //switch case 语句
    while(scanf("%d", &cmd) != EOF){
        switch(cmd){
        case 1:{
            init_cmd();
            if(check(cmd, a, b) == 1){
                //加法
                add_matrix(a, b, c);
                puts("=========================加法求得的矩阵以行列打印为：===========================");
                print_matrix(c);
            }
            else 
                puts("输入的两个矩阵不能进行加法计算！");
            clear();
            break;
               }
        case 2: {
            init_cmd();
            if(check(cmd, a, b) == 1){
                //减法
                minus_matrix(a, b, c);
                puts("=========================减法求得的矩阵以行列打印为：===========================");
                print_matrix(c);
            }
            else 
                puts("输入的两个矩阵不能进行减法计算！");
            clear();
            break;
                }

        case 3:{
            init_cmd();
            if(check(cmd, a, b) == 1){
                //乘法
                mul_matrix(a, b, c);
                puts("=========================乘法求得的矩阵以行列打印为：===========================");
                print_matrix(c);
            }
            else 
                puts("输入的两个矩阵不能进行乘法计算！");
            clear();
            break;
               }
        case 4:{
            //求逆
            system("pause");
            system("cls");
            init(a);
            create_matrix(a);
            init(b);
            init(c);
            if(a.r == a.c){
                tag = inversion(a, b, c);
                if(tag == 0)
                    puts("===========================输入的矩阵无逆矩阵！==============================");
                else{
                    puts("=========================原矩阵的逆矩阵以行列打印为：===========================");
                    print_matrix(c);
                }
            }
            else
                puts("===========================输入的矩阵无逆矩阵！==============================");
            clear();
            break;
               }
        case 5:
            return 0;
            break;
        }
    }

    return 0;
}