稀疏矩阵的三元组顺序表存储表示

// Header.h

#ifndef HEADER_H
#define HEADER_H    1

// 预定义常量和类型
// 函数结果状态代码
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2

typedef int Status;

#endif // HEADER_H

 

/

// TSMatrix.h

#ifndef TSMATRIX_H
#define TSMATRIX_H    1

#include <iostream>
#include "Header.h"
using namespace std;

//稀疏矩阵的三元组顺序表存储表示

#define MAXSIZE 1024 // 非零元个数的最大值

typedef int ElemType;

typedef struct {
    int i, j; // 该非零元的行下标和列下标
    ElemType e;
} Triple;

typedef struct {
    Triple data[MAXSIZE + 1]; // 非零元三元组表，data[0]未用
    int mu, nu, tu; // 矩阵的行数，列数和非零元个数
} TSMatrix;

Status TransposeSMatrix(TSMatrix M, TSMatrix &T);
ostream& operator<<(ostream& os, const TSMatrix& T);
Status FastTransposeSMatrix(TSMatrix M, TSMatrix& T);

#endif // TSMATRIX_H

 

///

// TSMatrix.cpp

#include <iostream>
#include "TSMatrix.h"
using namespace std;

// 采用三元组顺序表存储表示，求稀疏矩阵M的转置矩阵T
Status TransposeSMatrix(TSMatrix M, TSMatrix &T)
{
    T.mu = M.nu;
    T.nu = M.mu;
    T.tu = M.tu;
    if (T.tu) {
        int q = 1;
        for (int col = 1; col <= M.nu; ++col)
            for (int p = 1; p <= M.tu; ++p)
                if (M.data[p].j == 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;
                    ++q;
                }
    }
   
    return OK;
} // TransposeSMatrix

// 采用三元组顺序表存储表示，求稀疏矩阵M的转置矩阵T
Status FastTransposeSMatrix(TSMatrix M, TSMatrix& T)
{
    T.mu = M.nu; T.nu = M.mu; T.tu = M.tu;
    int num[M.nu + 1];
    int cpot[M.nu + 1];
    int col, t, p, q;
    if (T.tu) {
        for (col = 1; col <= M.nu; ++col)
            num[col] = 0;
        for (t = 1; t <= M.tu; ++t)
            ++num[M.data[t].j]; // 求M中每一列含非零元个数
        cpot[1] = 1;

        // 求第col列中第一个非零元在b.data中的序号
        for (col = 2; col <= M.nu; ++col)
            cpot[col] = cpot[col - 1] + num[col - 1];

        for (p = 1; 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];
        }
    }

    return OK;
} // FastTransposeSMatrix
           

ostream& operator<<(ostream& os, const TSMatrix& T)
{
    for (int i = 1; i <= T.tu; ++i)
        os << T.data[i].i << " " << T.data[i].j << " " << T.data[i].e << endl;
    return os;
}

 

// main.cpp

#include <iostream>
#include "TSMatrix.h"

int main()
{
    TSMatrix a, b, c;
    a.mu = 7; a.nu = 7; a.tu = 8;
    a.data[1].i = 1; a.data[1].j = 2; a.data[1].e = 12;
    a.data[2].i = 1; a.data[2].j = 3; a.data[2].e = 9;
    a.data[3].i = 3; a.data[3].j = 1; a.data[3].e = -3;
    a.data[4].i = 3; a.data[4].j = 6; a.data[4].e = 14;
    a.data[5].i = 4; a.data[5].j = 3; a.data[5].e = 24;
    a.data[6].i = 5; a.data[6].j = 2; a.data[6].e = 18;
    a.data[7].i = 6; a.data[7].j = 1; a.data[7].e = 15;
    a.data[8].i = 6; a.data[8].j = 4; a.data[8].e = -7;

    TransposeSMatrix(a, b);
    FastTransposeSMatrix(a, c);
    cout << a << string(16, '*') << endl << b << string(16, '*') << endl << c;

    return 0;
}