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

下面是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 MAX_SIZE = 100;

struct SparseMatrix
{
    int row[MAX_SIZE]; // 行下标数组
    int col[MAX_SIZE]; // 列下标数组
    float val[MAX_SIZE]; // 值数组
    int m; // 矩阵行数
    int n; // 矩阵列数
    int k; // 矩阵中非零元素个数
};

void createSparseMatrix(SparseMatrix &spMat)
{
    cout << "请输入矩阵的行数、列数和非零元素个数：" << endl;
    cin >> spMat.m >> spMat.n >> spMat.k;
    cout << "请按照行优先顺序输入矩阵中每个非零元素的行、列和值：" << endl;
    for (int i = 0; i < spMat.k; i++)
    {
        cin >> spMat.row[i] >> spMat.col[i] >> spMat.val[i];
    }
}

void printSparseMatrix(SparseMatrix &spMat)
{
    cout << "稀疏矩阵的三元组顺序表存储法为：" << endl;
    cout << "行下标数组：";
    for (int i = 0; i < spMat.k; i++)
    {
        cout << spMat.row[i] << " ";
    }
    cout << endl;
    cout << "列下标数组：";
    for (int i = 0; i < spMat.k; i++)
    {
        cout << spMat.col[i] << " ";
    }
    cout << endl;
    cout << "值数组：";
    for (int i = 0; i < spMat.k; i++)
    {
        cout << spMat.val[i] << " ";
    }
    cout << endl;
}

int main()
{
    SparseMatrix spMat;
    createSparseMatrix(spMat);
    printSparseMatrix(spMat);
    return 0;
}

这段代码实现了稀疏矩阵的创建和输出功能。用户可以先输入矩阵的行数、列数和非零元素个数，然后按照行优先顺序输入每个非零元素的行、列和值。程序会将输入的数据存储到三个数组中，并输出行下标数组、列下标数组和值数组。