4.3.2 稀疏矩阵转置(2)快速转置

SparseMatrix.h

#pragma once
#include<iostream>
using namespace std;

class Tri {
public:
    int col;
    int row;
    int value;
};

class SparseMatrix {
public:
    int term;
    Tri* elements;
    int Srow;
    int Scol;

    SparseMatrix(int t = 2, int r = 10, int c = 10) {
        term = t;
        Srow = r;
        Scol = c;
        elements = new Tri[term];
    }

    void quickTranspose(SparseMatrix& B) {
        int* rowCount;
        int* rowBegin;
        rowCount = new int[Scol];
        rowBegin = new int[Scol];
        for (int i = 0; i < Scol; i++) {
            rowCount[i] = 0;
        }
        for (int i = 0; i < term; i++) {
            rowCount[elements[i].col]++;
        }

        for (int i = 0; i < Scol; i++) {
            rowBegin[i] = 0;
        }

        for (int i = 1; i < Scol; i++) {
            rowBegin[i] = rowBegin[i - 1] + rowCount[i - 1];
        }
        cout << "RowBegin:" << endl;
        for (int i = 1; i < Scol; i++) {
            cout << i << ":" << rowBegin[i] << "  ";
        }
        cout << endl;
        //完成辅助数组

        int index_B = 0;
        for (int i = 0; i < term; i++) {
            index_B = rowBegin[elements[i].col];
            B.elements[index_B].col = elements[i].row;
            B.elements[index_B].row = elements[i].col;
            B.elements[index_B].value = elements[i].value;
            rowBegin[elements[i].col]++;
        }
    }

    void show() {
        for (int i = 0; i < term; i++) {
            cout << elements[i].row << "," << elements[i].col << "," << elements[i].value << endl;
        }
    }

};

main.cpp

#include"SparseMatrix.h"

int main() {
    SparseMatrix A, B;
    A.elements[0].col = 9;
    A.elements[0].row = 0;
    A.elements[0].value = 8;
    A.elements[1].col = 0;
    A.elements[1].row = 6;
    A.elements[1].value = 6;
    A.show();
    cout << "----------------------" << endl;
    A.quickTranspose(B);
    B.show();
    return 0;
}

原文地址:https://www.cnblogs.com/SlowIsFast/p/12689709.html

时间: 2024-07-29 15:43:59

4.3.2 稀疏矩阵转置(2)快速转置的相关文章

稀疏矩阵的普通转置与快速转置算法

稀疏矩阵的普通转置与快速转置算法 一般来说,对于系数矩阵,我们使用三元组来存储.即就是将矩阵的所有非零元素的三元组存放在一个顺序表中,如图所示: 注意一个转置的前提:该顺序表是排好序的,即行优先,列其次. 一.普通转置 这种算法比较简单,也很容易想到: 算法思想: 对M.data从头至尾扫描: ?第一次扫描时,将M.data中列号为1的三元组赋值到T.data中 ?第二次扫描时,将M.data中列号为2的三元组赋值到T.data中 ?依此类推,直至将M.data所有三元组赋值到T.data中 代

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&

【数据结构之旅】稀疏矩阵的快速转置

说明: 稀疏矩阵的快速转置算法的核心在于,用一个数组num记录原来矩阵中的每列非零元个数,用另一个数组cpos来记录原矩阵每列第一个非零元在新矩阵中的位置,以此来达到快速转置的目的. 用这样的方法,主要是希望,矩阵转置后,存储顺序依然是按照行来存储的. 1.实现及代码注释 根据上面的核心提示,可以有如下的代码,下面的代码中的注释已经非常详细,因此这里就不把每一部分实现的功能独立开来了: #include<stdio.h> #include<stdlib.h> #define OVE

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

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

稀疏矩阵的压缩存储及快速转置

当一个矩阵为稀疏矩阵时,有效数据的个数比无效数据要少得多,因此若将一个矩阵全部存储会浪费空间,可以只将有效数据存储起来,无效数据作为标记 代码如下: #include <iostream> #include <vector> using namespace std; //可用一个三元组来存储有效数据的信息 template<class T> struct Triple {  size_t _row;  size_t _col;  T _value; }; //系数矩阵类

数据结构----稀疏矩阵的快速转置

使用两种方法将稀疏矩阵快速转置 #include<iostream> #include<vector> using namespace std; template<class T> struct Triple  //三元组 { size_t row; size_t col; T _value; }; template<class T> class SparseMatrix { public: SparseMatrix(T *arr, size_t rowsi

稀疏矩阵的列序递增法和一次定位快速转置法

稀疏矩阵:矩阵中大多数元素为0的矩阵,从直观上讲,当非零元素个数低于总元素的30%时,这样的矩阵为稀疏矩阵. 如: int array [6][5] =     {{1, 0, 3, 0, 5}, {0, 0, 0, 0, 0}, {0, 0, 0, 0, 0}, {1, 0, 3, 0, 5}, {0, 0, 0, 0, 0}, {0, 0, 0, 0, 0}}; 稀疏矩阵的压缩存储:使用{row,col,value}三元组存储每一个有效数据,三元组按原矩阵中的位置,以行优先级先后顺序依次存放

稀疏矩阵三元组快速转置(转poklau123写的很清楚)

关于稀疏矩阵的快速转置法,首先得明白其是通过对三元表进行转置.如果误以为是对矩阵进行转置,毫无疑问就算你想破脑袋也想不出个所以然,别陷入死胡同了! 对于一个三元表,行为i,列为j,值为v.需将其i与j的值对调才能得到新的三元表,但是如果直接进行转换,得到的新的三元表的顺序是混乱的,不符合三元表的规则.所以,课本首先介绍了一个用扫描来转置的算法(这个算法比较容易,在这里我就不说了),但是这个转置算法的时间复杂度太高,于是就有了接下来的快速转置算法. 要你对一个三元表进行步骤最少的转置,你可能会想,

稀疏矩阵转置+快速转置

稀疏矩阵转置 Description 稀疏矩阵的存储不宜用二维数组存储每个元素,那样的话会浪费很多的存储空间.所以可以使用一个一维数组存储其中的非零元素.这个一维数组的元素类型是一个三元组,由非零元素在该稀疏矩阵中的位置(行号和列号对)以及该元组的值构成. 矩阵转置就是将矩阵行和列上的元素对换. 现在就请你对一个稀疏矩阵进行转置.以下是稀疏矩阵转置的算法描述: 图:稀疏矩阵转置的算法描述 Input 输入的第一行是两个整数r和c(r*c <= 12500),分别表示一个包含很多0的稀疏矩阵的行数