数据矩阵深度学习

转载

kcoufee 2024-10-23 12:57:41

文章标签 数据矩阵深度学习数据结构矩阵对称矩阵对角线矩阵 文章分类 深度学习人工智能

文章目录

1.矩阵
2.稀疏矩阵
3.对角线矩阵
4.三角形矩阵
5.对称矩阵
6.稀疏矩阵转换算法

1.矩阵

矩阵是科学和工程计算问题中经常运用的一种数学工具.矩阵是按行列排列的一组数据.这些数据元素称为数据元素.在计算机处理中,矩阵一般用一个二维数组表示和存储.

数据结构:

在MatrixCs.c

#define M 50
typedef struct {
    int i,j;//存储行号,列号
    int v;//存储的是矩阵元素值
}JZNODE;

typedef struct {
    int n,m,k;//分别存储稀疏矩阵的行数,列数和非0元素的个数
    JZNODE node[M];//数组,默认的存储9个
}SPMTX;

这是M默认的先赋值一个50,大点,为了是可以是其他的类型矩阵容易设置默认数据.这个可以根据实际情况来设置.

2.稀疏矩阵

稀疏矩阵是0元素较多且出现的位置无固定规律的矩阵.存储稀疏矩阵时只存储非0元素,这样可以有效的利用存储空间.因为非0元素位置不固定,可以用(行号,列号,元素值)的三元组来表示.可以使用(i,j,v)来表示.

创建并打印稀疏矩阵

在MatrixControl.h中声明方法

#include "MatrixCs.c"
/*
 打印稀疏矩阵
 */
void printSpMatrix(SPMTX sp);

/*
 创建一个稀疏矩阵
 */
SPMTX createSpMartix();

在MatrixControl.c实现方法

#include "MatrixControl.h"

/*
 判断稀疏矩阵存储的数组中是否含有指定的行号和列号的元素
 nodes:节点数组
 count:矩阵中非0元素数量
 row:行号
 col:列号
 return:如果包含则返回对应数组中的值,否则返回0
 */
int  justSpMatrixContainJznode(JZNODE nodes[],int count,int row,int col){
    for(int i=0;i<count && i<M;i++){
        JZNODE  node=nodes[i];
        if(node.i==row && node.j==col){
            return node.v;
        }
    }
       return 0;
}

SPMTX createSpMartix(){
    SPMTX  sp;
    //设置数据元素个数
    sp.k=9;
    sp.n=6;//6行
    sp.m=5;//5列
   
   
    
    JZNODE node;
    for(int i=1;i<=9;i++){
        node.i=(i%sp.n)+1;
        node.j=(i%sp.m)+1;
        node.v=i;
        sp.node[i-1]=node;
    }
    
    return sp;
}

/*
 打印稀疏矩阵
 */
void printSpMatrix(SPMTX sp){
    //1.打印第一条横线
    for(int k=0;k<sp.m;k++){
        if(k==0){
            printf(" --");
        } if(k==sp.m-1){
            printf("-");
        }else{
            printf("--");
        }
   }
    printf("\n");
    //2.打印数值
    int i,j;
    for(i=1;i<=sp.n;i++){
        if(i!=1)
          printf("\n");
         printf("|");
        for(j=1;j<=sp.m;j++){
            //判断存储的矩阵数组中是否含有当前节点
            //如果存在则打印对应的值
            //否则打印0
            int value=justSpMatrixContainJznode(sp.node,sp.k, i,j);
            printf(" %d",value);
        }
        printf(" |");
    }
    
    printf("\n");
    for(int k=0;k<sp.m;k++){
        if(k==0){
           printf(" --");
        } if(k==sp.m-1){
            printf("-");
        }else{
            printf("--");
        }
    }
    printf("\n");
}

在main.c中的main方法(int main(int argc, const char * argv[]) {})调用此方法,并且进行判断

#include "MatrixControl.h"
int main(int argc, const char * argv[]) {
    
   //创建一个稀疏矩阵
   SPMTX matrix=createSpMartix();
   //打印稀疏矩阵
    printSpMatrix(matrix);
    
    return 0;
}

打印结果:

-----------
| 0 6 0 0 0 |
| 0 1 7 0 0 |
| 0 0 2 8 0 |
| 0 0 0 3 9 |
| 0 0 0 0 4 |
| 5 0 0 0 0 |
 -----------
Program ended with exit code: 0

3.对角线矩阵

对角线矩阵是除矩阵对角线上的元素外,其余所有的值都是0的矩阵.如果用一般的二维数组存储这样的矩阵,那么只有对角线上的元素有效的,其余都是0,那么0所占的存储空间是不必要的.那么我们可以把它看成是一个一维数组,值存储对角线上的元素.

数组djx[i][i]转换成一维数组djxsz[i].从A位置开始存储,每个节点真用b个字节,计算存储地址:
< djx(i,i) > = < djxsz[i] > = A + i * b

在MatrixControl.h中声明方法

/*
 创建对角线矩阵
 */
SPMTX createDiagonalMatrix();

在MatrixControl.c中实现

SPMTX createDiagonalMatrix(){
    SPMTX  sp;
    //设置数据元素个数
    sp.k=6;//这个要计算好,6行6列的对角线矩阵的元素的个数6
    sp.n=6;//6行
    sp.m=6;//6列
    
    JZNODE node;
    int k;
    for(int i=1;i<=sp.n;i++){
        node.i=i;
        node.j=i;
        node.v=i;
        sp.node[k]=node;
        k++;
    }
    return sp;

}

在main.c中的main方法(int main(int argc, const char * argv[]) {})调用此方法,并且进行判断

#include "MatrixControl.h"
int main(int argc, const char * argv[]) {
    //创建一个对角线矩阵
    SPMTX matrix=createDiagonalMatrix();
    //对角线矩阵
    printSpMatrix(matrix);
    return 0;
}

打印结果:

-------------
| 1 0 0 0 0 0 |
| 0 2 0 0 0 0 |
| 0 0 3 0 0 0 |
| 0 0 0 4 0 0 |
| 0 0 0 0 5 0 |
| 0 0 0 0 0 6 |
 -------------
Program ended with exit code: 0

4.三角形矩阵

三角形矩阵有上三角形矩阵和下三角形矩阵之分.存储的时候,只存储上三角或者下三角就行.

设一下三角矩阵sjx为n*n阶的.存储的数据元素个数:

1+2+3+4+…+n=n(1+n)/2

计算矩阵元素sjx(i,j)存储的地址:

当i<=j时,则先计算出钱i-1行共有多少个元素k,

计算公式:k=1+2+…+(i-1)=(1+(i-1))(i-1)/2=i(i-1)/2

则k+j为矩阵元素sjx(i,j)在一维数组中的位置号,即sjx(i,j)存储为数组中的第k+j号数组元素.在一维数组中的存储地址:

< sjx(i,j) > =< sjxsz[k+j] > = A+(i(i-1)/2+j-1)b

在MatrixControl.h中声明方法

/*
 创建三角形矩阵
 */
SPMTX  createTraiangleMatrix();

在MatrixControl.c中实现

SPMTX  createTraiangleMatrix(){
    SPMTX  sp;
    //设置数据元素个数
    sp.k=21;//这个要计算好,6行6列的三角形矩阵的元素的个数1+2+3+4+5+6
    sp.n=6;//6行
    sp.m=6;//6列
    
    JZNODE node;
    int i,j,k;
    for( i=1;i<=sp.n;i++){
        for(j=1;j<=i;j++){
            node.i=i;
            node.j=j;
            if(i==j){
                node.v=9;
            }else{
                node.v=(i*j)%10;
            }
            sp.node[k]=node;
            k++;
        }
   }
    
    return sp;
}

在main.c中的main方法(int main(int argc, const char * argv[]) {})调用此方法,并且进行判断

#include "MatrixControl.h"
int main(int argc, const char * argv[]) {
   //创建一个三角形矩阵
    SPMTX matrix=createTraiangleMatrix();
    //打印三角矩阵
    printSpMatrix(matrix);
    return 0;
}

打印结果:

-------------
| 9 0 0 0 0 0 |
| 2 9 0 0 0 0 |
| 3 6 9 0 0 0 |
| 4 8 2 9 0 0 |
| 5 0 5 0 9 0 |
| 6 2 8 4 0 9 |
 -------------
Program ended with exit code: 0

5.对称矩阵

对称矩阵的特点是数据元素以主对角线为对称轴分别对应相等.设矩阵dc是一个对称矩阵,则其数据元素值有dc(i,j)=dc(j,i).因而存储一个对称矩阵时可以忽略主对角线上方的所有元素,或者忽略主对角线下方的所有数据元素.其实也相当于一个下三角形矩阵或者上三角形矩阵.因此可以采用存储三角形矩阵的方法存储对称矩阵.假设把矩阵dc变成下三角矩阵存储.若要引用矩阵元素dc(i,j)且i<j,则可以改为引用dc(j,i).因为他们有相同的值.

在MatrixControl.h中声明方法

/*
 创建对称矩阵
 */
SPMTX  createSymMatrix();

在MatrixControl.c中实现

SPMTX  createSymMatrix(){
    SPMTX  sp;
    //设置数据元素个数
    sp.k=36;//这个要计算好,6行6列的对角线矩阵的元素的个数36,因为是对称矩阵,那么值存储21个就可以,这里为了使用通用的打印,那么存储36个元素
    sp.n=6;//6行
    sp.m=6;//6列
    
    JZNODE node;
    int i,j,k;
    for( i=1;i<=sp.n;i++){
        for(j=1;j<=i;j++){
            node.i=i;
            node.j=j;
            node.v=(i*j)%10;
            sp.node[k]=node;
            k++;
            //设置对称元素
            if(i!=j){
                node.i=j;
                node.j=i;
                node.v=(i*j)%10;
                sp.node[k]=node;
                k++;

            }
            
      }
    }
    return sp;
}

在main.c中的main方法(int main(int argc, const char * argv[]) {})调用此方法,并且进行判断

#include "MatrixControl.h"
int main(int argc, const char * argv[]) {
    //创建一个对称矩阵
    SPMTX matrix=createSymMatrix();
    //打印对称矩阵
    printSpMatrix(matrix);
    return 0;
}

打印结果:

-------------
| 1 2 3 4 5 6 |
| 2 4 6 8 0 2 |
| 3 6 9 2 5 8 |
| 4 8 2 6 0 4 |
| 5 0 5 0 5 0 |
| 6 2 8 4 0 6 |
 -------------
Program ended with exit code: 0

6.稀疏矩阵转换算法

矩阵转换算法是:将矩阵的行和列交换后,生成一个新的矩阵.

在MatrixControl.h中声明方法

/*
 稀疏矩阵转置算法
 */
SPMTX transposeSpMartix(SPMTX SP);

在MatrixControl.c中实现

SPMTX transposeSpMartix(SPMTX SP){
   
    int p,q,col;
    //1.创建一个置换后的稀疏矩阵变量
     SPMTX  MT;
    MT.n=SP.m;
    MT.m=SP.n;
    MT.k=SP.k;
    //2.按照列遍历要置换矩阵,赋给新矩阵的行对应的值
    if(MT.k>0){
        q=0;
        for(col=1;col<=SP.m;col++){
            //3.查找此行中是否有非0元素
            for(p=0;p<MT.k;p++){
                //4.如果当前列中非零数值
                if(SP.node[p].j==col){
                    //4.1将行和列互换,并且把值也赋值
                    MT.node[q].i=SP.node[p].j;
                    MT.node[q].j=SP.node[p].i;
                    MT.node[q].v=SP.node[p].v;
                    //4.2新矩阵存储的数组下标++
                    q++;
                    
                }
            }
        }

    }
    printf("vvvvvvvvvv---转换成功---vvvvvvvvvv\n");
    return MT;
}

在main.c中的main方法(int main(int argc, const char * argv[]) {})调用此方法,并且进行判断

#include "MatrixControl.h"
int main(int argc, const char * argv[]) {
  //创建一个循环矩阵
   SPMTX matrix=createSpMartix();
   //打印稀疏矩阵
   printSpMatrix(matrix);
    //转换矩阵
   matrix=transposeSpMartix(matrix);
   printSpMatrix(matrix);
    return 0;
}

打印结果:

-----------
| 0 6 0 0 0 |
| 0 1 7 0 0 |
| 0 0 2 8 0 |
| 0 0 0 3 9 |
| 0 0 0 0 4 |
| 5 0 0 0 0 |
 -----------
vvvvvvvvvv---转换成功---vvvvvvvvvv
 -------------
| 0 0 0 0 0 5 |
| 6 1 0 0 0 0 |
| 0 7 2 0 0 0 |
| 0 0 8 3 0 0 |
| 0 0 0 9 4 0 |
 -------------
Program ended with exit code: 0

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。