数据结构复习代码——矩阵的相关操作以及矩阵快速转置算法的实现以及遇到问题及解决

1、矩阵的相关操作以及矩阵快速转置算法的实现（加减乘并未实现）

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

#define ElemType int
#define MAXSIZE 100


//三元组定义
typedef struct Triple
{
    int i;
    int j;
    ElemType e;
}Triple;


//矩阵定义
typedef struct SMatrix
{
    Triple data[MAXSIZE];
    int mu;
    int nu;
    int tu;
}SMatrix;

//创建矩阵
void CreateMatrix(SMatrix *M)
{
    FILE *fp;
    fp = fopen("Matrix.txt", "r");
    if (fp == NULL)
        exit(1);
    fscanf(fp, "%d %d", &M->mu, &M->nu);
    int value;
    int k = 0;
    for (int i=0;i<M->mu;i++)
    {
        for (int j = 0; j < M->nu; j++)
        {
            fscanf(fp, "%d", &value);
            if (value != 0)
            {
                M->data[k].e = value;
                M->data[k].i = i;
                M->data[k].j = j;
                k++;
            }
        }
    }
    M->tu = k;
    fclose(fp);
}


//输出矩阵
void PrintfMatrix(SMatrix *M)
{
    printf("row=%d col=%d\n", M->mu, M->nu);
    for (int i = 0; i < M->tu; i++)
    {
        printf("(%d %d %d)\n", M->data[i].i, M->data[i].j, M->data[i].e);
    }
}

//拷贝矩阵
void CopyMatrix(SMatrix *M, SMatrix *T)
{
    T->mu = M->mu;
    T->nu = M->nu;
    T->tu = M->tu;
    for (int i = 0; i < M->tu; i++)
    {
        T->data[i].i = M->data[i].i;
        T->data[i].j = M->data[i].j;
        T->data[i].e = M->data[i].e;
    }
}
//矩阵的转置实现
void TransposeMatrix(SMatrix *M,SMatrix *T)
{
    T->mu = M->nu;
    T->nu = M->mu;
    T->tu = M->tu;
    int k = 0;
    if(M->tu != 0)
    {
        for(int col=0; col<M->nu; col++)
        {
            for(int i=0; i<M->tu; i++)
            {
                if(M->data[i].j == col)
                {
                    T->data[k].i = M->data[i].j;
                    T->data[k].j = M->data[i].i;
                    T->data[k].e = M->data[i].e;
                    k++;
                }
            }
        }
    }
}

//使用空间换取时间，矩阵快速转置算法
void FastTransposeMatrix(SMatrix *M,SMatrix *T)
{
    T->mu = M->nu;
    T->nu = M->mu;
    T->tu = M->tu;
    int *num = (int*)malloc(sizeof(int) * M->nu);
    assert(num != NULL);

    int *cpot = (int*)malloc(sizeof(int) * M->nu);
    assert(cpot != NULL);

    int col = 0;
    if(T->tu != 0)
    {
        for(col=0; col<M->tu; col++)
        {
            num[col] = 0;
        }
        for(int t=0; t<M->tu; t++)
        {
            num[M->data[t].j]++;
        }
        cpot[0] = 0;
        for(int i=1;i<M->nu;i++)
        {
            cpot[i] = cpot[i-1] + num[i-1];
        }
        int q = 0;
        for(int p=0; p<M->tu; p++)
        {
            col = M->data[p].j;
            q = cpot[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;
            cpot[col]++;
        }
    }


}

int main()
{
    SMatrix sm,sm1;
    memset(&sm, 0, sizeof(sm));
    //创建矩阵操作
    CreateMatrix(&sm);
    //拷贝矩阵
    CopyMatrix(&sm, &sm1);
    PrintfMatrix(&sm1);

    FastTransposeMatrix(&sm,&sm1);
    //输出矩阵
    PrintfMatrix(&sm1);
    return 0;
}

 2、c++   文件操作fopen、fopen_s的用法

本人操作时，VS2017中fopen_s适用，CodeBlocks中fopen适用

定义FILE *fp 之后
fopen的用法是: fp = fopen(“filename”,“r”);
对于fopen_s来说，还得定义另外一个变量 errno_t err，
然后err = fopen_s(&fp,“filename”,“r”)；
返回值：
fopen：打开文件成功的话返回文件指针（赋值给fp），打开失败则返回 NULL值；
fopen_s：打开文件成功返回0，失败返回非0。

//打开文件
        FILE *fp;
        errno_t err = fopen_s( &fp, "Matrix.txt", "r");

 　　“r” = “rt”

打开一个文本文件，文件必须存在，只允许读
“r+” = “rt+”
打开一个文本文件，文件必须存在，允许读写
“rb”
打开一个二进制文件，文件必须存在，只允许读
“rb+”
打开一个二进制文件，文件必须存在，允许读写
“w” = “wt”
新建一个文本文件，已存在的文件将内容清空，只允许写
“w+” = “wt+”
新建一个文本文件，已存在的文件将内容清空，允许读写
“wb”
新建一个二进制文件，已存在的文件将内容清空，只允许写
“wb+”
新建一个二进制文件，已存在的文件将内容清空，允许读写
“a” = “at”
打开或新建一个文本文件，只允许在文件末尾追写
“ab”
打开或新建一个二进制文件，只允许在文件末尾追写
“ab+”
打开或新建一个二进制文件，可以读，但只允许在文件末尾追写

标签：fopen,转置,tu,矩阵,++,int,数据结构,data,nu
来源： https://www.cnblogs.com/lx06/p/16440683.html