数据结构(复习)--------压缩矩阵的转置和相乘

// // 关于数据结构的总结与复习  Coding
//关于压缩矩阵转置和连乘

#include <cstdio>
#include <cstdlib>
#include <cstring>
#define maxsize 100
#define error 0
#define ok 1
//#define _OJ_

typedef struct triple
{
    int e;
    int i;    int j;
} triple;                       //存储行列和值

typedef struct matrix
{
    triple data[maxsize];
    int col;    int row;    int cnt;
    int pos[100];             //存储非零元素在每一行的第一个元素
}matrix;

matrix
transpose_matrix(matrix M, matrix T)
{    int cnt1, col1;
    int q = 0;
    T.col = M.col;    T.row = M.row;    T.cnt = M.cnt;
    if(T.cnt != 0) {
      for (col1 = 0; col1 < M.col; col1++) {      //按照每一列去寻找
          for (cnt1 = 0; cnt1 < M.cnt; cnt1++) {
              if(M.data[cnt1].j == col1) {
                T.data[q].j = M.data[cnt1].i;
                T.data[q].i = M.data[cnt1].j;
                T.data[q].e = M.data[cnt1].e;    q++;
              }
           }
       }
    }
    return T;
}

// -------------------------------------------------------------------------------
matrix
get_pos(matrix M)
{
    int i2, i3, i4;
    int num[100];
     for (i2 = 1; i2 <= M.row; i2++)    num[i2] = 0;
    for (i3 = 1; i3 <= M.cnt; i3++)    ++num[M.data[i3].i];
    //求每一行的非零元素的个数
        M.pos[1] = 1;
    for (i4 = 2; i4 <= M.row; i4++)    M.pos[i4] = M.pos[i4 - 1] + num[i4 - 1];
    // printf("pos == %d ", M.pos[i4]);}
    return M;
}

matrix
Multi_Matrix(matrix M, matrix T, matrix Q)
{
    int num[T.col], i1, i2, p, q, ccol, t_row, num_next, num1_next;
    int arow;

    Q.row = M.row;        Q.col = T.col;    Q.cnt = 0;

    for (i1 = 1; i1 <= M.row; i1++) {            //对每一行进行计算

    for (i2 = 1; i2 <= Q.col; i2++)             //将计数器置零
        num[i2] = 0;

    if(i1 < M.row)  num_next = M.pos[i1 + 1];
    else
        num_next = M.cnt + 1;                //下一个非零位置
    for (p = M.pos[i1]; p < num_next; p++) {   //M第p行的所有非零元素
        t_row = M.data[p].j;

        if(t_row < T.cnt)  num1_next = T.pos[t_row + 1];
        else
            num1_next = T.cnt + 1;
        for (q = T.pos[t_row]; q < num1_next; q++) {
            ccol = T.data[q].j;               //N的第q(M.data[p].j)行所有元素
            num[ccol] += M.data[p].e * T.data[q].e;
        }
    }

        for (ccol = 1; ccol <= Q.col; ccol++) {
            if(num[ccol] != 0) {
            //因为num【】有可能为零所以需重新将其压缩成矩阵
                Q.data[++Q.cnt].i = i1;    Q.data[Q.cnt].j = ccol;
                Q.data[Q.cnt].e = num[ccol];
            }
        }
    }
    return  Q;
}

int main(int argc, char const *argv[]) {
#ifndef _OJ_ //ONLINE JUDGE
       freopen("input.txt", "r", stdin);
       //freopen("output.txt", "w", stdout);
#endif

    int i1, i2, i3, i4;
    int num[100];
    matrix M, T, Q;
    scanf("%d %d %d", &M.row, &M.col, &M.cnt);
    // printf("%d %d %d\n", M.row, M.col, M.cnt);
    for (i1 = 1; i1 <= M.cnt; i1++) {
    scanf("%d %d %d", &M.data[i1].i, &M.data[i1].j, &M.data[i1].e);
    // printf("%d %d %d\n",  M.data[i1].i,  M.data[i1].j, M.data[i1].e);
    }

    scanf("%d %d %d", &T.row, &T.col, &T.cnt);
    // printf("%d %d %d\n", T.row, T.col, T.cnt);
    for (i1 = 1; i1 <= T.cnt; i1++) {
    scanf("%d %d %d", &T.data[i1].i, &T.data[i1].j, &T.data[i1].e);
    // printf("%d %d %d\n",  T.data[i1].i, T.data[i1].j, T.data[i1].e);
    }

    M = get_pos(M);    T = get_pos(T);
    Q = Multi_Matrix(M, T, Q);
    for (i2 = 1; i2 <= Q.cnt; i2++) {
        printf("%d %d %d\n", Q.data[i2].i, Q.data[i2].j, Q.data[i2].e);
    }

    // for (i1 = 0; i1 < M.cnt; i1++) {
    //     scanf("%d %d %d", &M.data[i1].i, &M.data[i1].j, &M.data[i1].e);
    //     printf("%d %d %d\n", M.data[i1].i, M.data[i1].j, M.data[i1].e);
    // }
    // T = transpose_matrix(M,T);
    // printf("cnt == %d\n", T.cnt);

    // for (i1 = 0; i1 < T.cnt; i1++)
    //     printf("%d %d %d\n", T.data[i1].i, T.data[i1].j, T.data[i1].e);

    return 0;
}

输入:
3 4
4
1 1 3
1 4 5
2 2 -1
3 1 2
4 2
4
1 2 2
2 1 1
3 1 -2
3 2 4
输出:
1 2 6
2 1 -1
3 2 4
[Finished in 0.8s]
时间: 2024-10-22 04:13:15

数据结构(复习)--------压缩矩阵的转置和相乘的相关文章

【数据结构】稀疏结构及稀疏矩阵的压缩存储,矩阵的转置

在矩阵中,有一类很重要的矩阵,就是-----稀疏矩阵. 所谓的稀疏矩阵呢,就是指的是,在矩阵中,有效的数据个数远远小于无效的数据个数(并且这些数据排列顺序没有规律).我们下面先举个稀疏矩阵的例子: 有效数据个数仅仅6个,其余都为无效数据0. 那我们将稀疏矩阵存在压缩矩阵中,设定一个三元组,使用{row,col,value}存储每一个有效数据,三元组按原矩阵中的位置,以行优先级先后顺序依次存放. 我们建立一个结构体: struct Triple//定义一个三元组,用来存储稀疏矩阵的x,y,坐标值

矩阵的基本运算,相乘,逆,转置,伴随

1 矩阵基本操作 1.1创建向量 R里面有多种方法来创建向量(Vector),最简单的是用函数c().例如: >X=c(1,2,3,4) >X [1] 1 2 3 4 当然,还有别的方法.例如: >X=1:4 >X [1] 1 2 3 4 还有seq()函数.例如: > X=seq(1,4,length=4) > X [1] 1 2 3 4 注意一点,R中的向量默认为列向量,如果要得到行向量需要对其进行转置. 1.2创建矩阵 R中创建矩阵的方法也有很多.大致分为直接创建

数据结构进阶(二)矩阵(稀疏矩阵)的压缩存储

矩阵(稀疏矩阵)的压缩存储 注 本文转载地址: http://blog.163.com/zhoumhan_0351/blog/static/39954227201001112526244/ 为了节省存储空间并且加快处理速度,需要对这类矩阵进行压缩存储,压缩存储的原则是:不重复存储相同元素:不存储零值元素. 一.相关概念 ㈠特殊矩阵 矩阵中存在大多数值相同的元,或非0元,且在矩阵中的分布有一定规律. ⒈对称矩阵 矩阵中的元素满足 aij=aji    1≤i,j≤n ⒉三角矩阵 上(下)三角矩阵指

数据结构之---C语言实现矩阵的转置

//矩阵的转置 //我在上一篇博客中写道三元矩阵操作 //其中的转置为了加深理解,这里重新用通俗 //易懂的代码重新进行了编写,如理如下: #include <stdio.h> #include <stdlib.h> int main() { int i, j, b[3][3]; int a[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}; printf("矩阵原型:\n"); for(i = 0; i < 3; i++

数据结构 - 数组、矩阵、广义表存储

数组的定义 数组的定义 数组是下标index 和值value 组成的序对的集合. 在数组中,每个有定义的下标都与一个值对应,这个值称做数组元素. 每个序对形如: (index,value) 数组的顺序表示和实现 由于计算机的内存结构是一维的,因此用一维内存来表示多维数组,就必须按某种次序将数组元素排成一列序列,然后将这个线性序列存放在存储器中. 一般都是采用顺序存储的方法来表示数组 一维数组的顺序表示 设第一个数组元素a[0]的存储地址是loc(a[0]),若已知每个数组元素占k个存储单元,则下

稀疏矩阵-压缩存储-列转置法- 一次定位快速转置法

稀疏矩阵的压缩存储 压缩存储值存储极少数的有效数据.使用{row,col,value}三元组存储每一个有效数据,三元组按原矩阵中的位置,以行优先级先后顺序依次存放. 压缩存储:行优先一行一行扫 有效数据存入以为矩阵_arr 列转置法 : 从前向后遍历压缩矩阵,先找列号为0的存入 转置矩阵的压缩矩阵.然后从前向后找列号为1的 ...直到转置矩阵的压缩矩阵大小和 原矩阵的一样大 这时就找完了 时间复杂度为    O(原矩阵列数 * 压缩矩阵长度) 一次定位快速转置法: 设置两个辅助矩阵 RowCou

稀疏矩阵的压缩存储和转置

1.稀疏矩阵:M*N的矩阵,矩阵中有效值的个数远小于无效值的个数,且这些数据的分布没有规律. 2.稀疏矩阵的压缩存储:压缩存储值存储极少数的有效数据. 由于非零元素分布没有任何规律,所以在进行压缩存储的时侯需要存储无效值的同时还要存储有效元素在矩阵中的位置,即有效元素所在的行号和列号,也就是在存储某个元素比如aij的值的同时,还需要存储该元素所在的行号i和它的列号j,这样就构成了一个三元组(i,j,aij)的线性表. 使用{ row, col, value }三元组存储每一个有效数据,三元组按原

C++实现稀疏矩阵的压缩存储、转置、快速转置

/*稀疏矩阵的压缩存储.转置.快速转置*/ #include <iostream> using namespace std; #include <vector> //三元组 template<class T> struct Triple { size_t _row; size_t _col; T _value; Triple(size_t row = 0, size_t col = 0, const T& value = T()) :_row(row) ,_co

c++矩阵的转置和快速转置

矩阵的转置 将原矩阵的行.列对换,也就是将[i][j]和[j][i]位置上的数据对换. 程序代码: #include<vector>   //稀疏矩阵push pop operator[] 和顺序表一致   template<class T> struct Triple  //定义一个三元组 可以直接访问的定义成struct { size_t _row; size_t _col; T _value;   Triple(size_t row, size_t col, const T&