代码实现稀疏矩阵的三元组表存储

下面是Python代码实现稀疏矩阵的三元组表存储的示例：

class SparseMatrix:
    def __init__(self, nrows, ncols, data):
        self.nrows = nrows
        self.ncols = ncols
        self.data = data  # data为一个二维列表，存储矩阵中的元素

    def to_triplet(self):
        triplet = []
        for i in range(self.nrows):
            for j in range(self.ncols):
                if self.data[i][j] != 0:
                    triplet.append((i, j, self.data[i][j]))
        return triplet

其中，`SparseMatrix`类用于表示稀疏矩阵，包含三个属性：`nrows`表示矩阵的行数，`ncols`表示矩阵的列数，`data`为一个二维列表，存储矩阵中的元素。

`to_triplet`方法用于将稀疏矩阵转化为三元组表。具体实现是遍历矩阵中的每个元素，如果该元素不为0，则将其行列坐标以及值存储到一个三元组中，最后将所有三元组存储到一个列表中并返回。

相关问题

代码实现稀疏矩阵的三元组表存储c语言

下面是C语言实现稀疏矩阵的三元组表存储的示例：

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

typedef struct {
    int row;
    int col;
    int value;
} Triplet;

typedef struct {
    int nrows;
    int ncols;
    int nelems;
    Triplet* data;
} SparseMatrix;

SparseMatrix* create_sparse(int nrows, int ncols, int* matrix) {
    SparseMatrix* sm = (SparseMatrix*)malloc(sizeof(SparseMatrix));
    sm->nrows = nrows;
    sm->ncols = ncols;
    sm->nelems = 0;
    for (int i = 0; i < nrows * ncols; i++) {
        if (matrix[i] != 0) {
            sm->nelems++;
        }
    }
    sm->data = (Triplet*)malloc(sm->nelems * sizeof(Triplet));
    int k = 0;
    for (int i = 0; i < nrows; i++) {
        for (int j = 0; j < ncols; j++) {
            if (matrix[i * ncols + j] != 0) {
                sm->data[k].row = i;
                sm->data[k].col = j;
                sm->data[k].value = matrix[i * ncols + j];
                k++;
            }
        }
    }
    return sm;
}

void print_sparse(SparseMatrix* sm) {
    printf("Sparse Matrix (%d x %d):\n", sm->nrows, sm->ncols);
    for (int i = 0; i < sm->nelems; i++) {
        printf("(%d, %d, %d)\n", sm->data[i].row, sm->data[i].col, sm->data[i].value);
    }
}

void destroy_sparse(SparseMatrix* sm) {
    free(sm->data);
    free(sm);
}

int main() {
    int matrix[3][4] = {
        {1, 0, 0, 2},
        {0, 3, 0, 0},
        {0, 0, 4, 0}
    };
    SparseMatrix* sm = create_sparse(3, 4, (int*)matrix);
    print_sparse(sm);
    destroy_sparse(sm);
    return 0;
}

其中，`SparseMatrix`结构体用于表示稀疏矩阵，包含四个属性：`nrows`表示矩阵的行数，`ncols`表示矩阵的列数，`nelems`表示矩阵中非零元素的个数，`data`为一个三元组数组，存储矩阵中的非零元素。

`create_sparse`函数用于将一个二维数组表示的稀疏矩阵转化为三元组表。具体实现是遍历矩阵中的每个元素，如果该元素不为0，则将其行列坐标以及值存储到一个三元组中，最后将所有三元组存储到一个数组中并返回。

`print_sparse`函数用于打印稀疏矩阵的三元组表。

`destroy_sparse`函数用于销毁稀疏矩阵的三元组表。

在`main`函数中，我们定义一个二维数组表示一个稀疏矩阵，然后调用`create_sparse`函数将其转化为三元组表，并调用`print_sparse`函数打印结果，最后调用`destroy_sparse`函数销毁稀疏矩阵的三元组表。

稀疏矩阵三元组顺序表存储法c++代码实现

以下是一个简单的C++代码实现稀疏矩阵三元组顺序表存储法的例子：

#include <iostream>
using namespace std;

const int MAXSIZE = 100; // 最大非零元素个数
const int ROW = 3; // 稀疏矩阵的行数
const int COL = 4; // 稀疏矩阵的列数

struct Triple {
    int row, col, val;
};

class SparseMatrix {
public:
    SparseMatrix(int mat[ROW][COL]); // 构造函数
    void display(); // 打印稀疏矩阵
private:
    Triple data[MAXSIZE]; // 三元组顺序表
    int numRow, numCol, numVal; // 稀疏矩阵的行数、列数和非零元素个数
};

SparseMatrix::SparseMatrix(int mat[ROW][COL]) {
    numRow = ROW;
    numCol = COL;
    numVal = 0;

    for (int i = 0; i < ROW; i++) {
        for (int j = 0; j < COL; j++) {
            if (mat[i][j] != 0) { // 找到一个非零元素
                data[numVal].row = i;
                data[numVal].col = j;
                data[numVal].val = mat[i][j];
                numVal++;
            }
        }
    }
}

void SparseMatrix::display() {
    int k = 0;
    for (int i = 0; i < numRow; i++) {
        for (int j = 0; j < numCol; j++) {
            if (k < numVal && data[k].row == i && data[k].col == j) {
                cout << data[k].val << " ";
                k++;
            } else {
                cout << "0 ";
            }
        }
        cout << endl;
    }
}

int main() {
    int mat[ROW][COL] = {
        {0, 0, 0, 0},
        {5, 8, 0, 0},
        {0, 0, 3, 0}
    };

    SparseMatrix sm(mat);
    sm.display();

    return 0;
}

输出结果为：

0 0 0 0
5 8 0 0
0 0 3 0