稀疏矩阵的创建，销毁，输出，求和，行列求差，乘积，转置

稀疏矩阵在实际应用中可以有效减少存储空间和计算时间，以下是稀疏矩阵的创建、销毁、输出、求和、行列求差、乘积、转置的基本操作：

## 创建稀疏矩阵

稀疏矩阵可以用三元组（行号、列号、非零元素）的形式来存储，也可以用链表等方式来存储。下面给出三元组存储方式的创建方法：

#include <iostream>
using namespace std;

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

struct SparseMatrix {
    int row, col, num;
    Triple *data;
};

SparseMatrix* createSparseMatrix(int row, int col, int num) {
    SparseMatrix *matrix = new SparseMatrix;
    matrix->row = row;
    matrix->col = col;
    matrix->num = num;
    matrix->data = new Triple[num];
    return matrix;
}

## 销毁稀疏矩阵

void destroySparseMatrix(SparseMatrix *matrix) {
    delete[] matrix->data;
    delete matrix;
}

## 输出稀疏矩阵

void printSparseMatrix(SparseMatrix *matrix) {
    for (int i = 0; i < matrix->num; i++) {
        cout << matrix->data[i].row << " "
             << matrix->data[i].col << " "
             << matrix->data[i].val << endl;
    }
}

## 求稀疏矩阵元素和

int sumSparseMatrix(SparseMatrix *matrix) {
    int sum = 0;
    for (int i = 0; i < matrix->num; i++) {
        sum += matrix->data[i].val;
    }
    return sum;
}

## 求稀疏矩阵行列求差

SparseMatrix* subtractSparseMatrix(SparseMatrix *matrix1, SparseMatrix *matrix2) {
    if (matrix1->row != matrix2->row || matrix1->col != matrix2->col) {
        return NULL;
    }
    SparseMatrix *matrix = createSparseMatrix(matrix1->row, matrix1->col, 0);
    int i = 0, j = 0, k = 0;
    while (i < matrix1->num && j < matrix2->num) {
        if (matrix1->data[i].row < matrix2->data[j].row || 
                (matrix1->data[i].row == matrix2->data[j].row && 
                matrix1->data[i].col < matrix2->data[j].col)) {
            matrix->data[k++] = matrix1->data[i++];
        } else if (matrix1->data[i].row > matrix2->data[j].row ||
                (matrix1->data[i].row == matrix2->data[j].row &&
                matrix1->data[i].col > matrix2->data[j].col)) {
            matrix->data[k].row = matrix2->data[j].row;
            matrix->data[k].col = matrix2->data[j].col;
            matrix->data[k++].val = -matrix2->data[j++].val;
        } else {
            int val = matrix1->data[i++].val - matrix2->data[j++].val;
            if (val != 0) {
                matrix->data[k].row = matrix1->data[i-1].row;
                matrix->data[k].col = matrix1->data[i-1].col;
                matrix->data[k++].val = val;
            }
        }
    }
    while (i < matrix1->num) {
        matrix->data[k++] = matrix1->data[i++];
    }
    while (j < matrix2->num) {
        matrix->data[k].row = matrix2->data[j].row;
        matrix->data[k].col = matrix2->data[j].col;
        matrix->data[k++].val = -matrix2->data[j++].val;
    }
    matrix->num = k;
    return matrix;
}

## 求稀疏矩阵乘积

SparseMatrix* multiplySparseMatrix(SparseMatrix *matrix1, SparseMatrix *matrix2) {
    if (matrix1->col != matrix2->row) {
        return NULL;
    }
    SparseMatrix *matrix = createSparseMatrix(matrix1->row, matrix2->col, 0);
    int *flag = new int[matrix2->col];
    memset(flag, -1, sizeof(int) * matrix2->col);
    for (int i = 0; i < matrix1->num; i++) {
        int r = matrix1->data[i].row;
        for (int j = 0; j < matrix2->col; j++) {
            int sum = 0;
            for (int k = 0; k < matrix2->num; k++) {
                if (matrix2->data[k].row == matrix1->data[i].col && matrix2->data[k].col == j) {
                    sum += matrix1->data[i].val * matrix2->data[k].val;
                    break;
                }
            }
            if (sum != 0) {
                if (flag[j] == -1) {
                    flag[j] = matrix->num;
                    matrix->data[matrix->num].row = r;
                    matrix->data[matrix->num].col = j;
                    matrix->data[matrix->num++].val = sum;
                } else {
                    matrix->data[flag[j]].val += sum;
                }
            }
        }
    }
    delete[] flag;
    return matrix;
}

## 求稀疏矩阵转置

SparseMatrix* transposeSparseMatrix(SparseMatrix *matrix) {
    SparseMatrix *t = createSparseMatrix(matrix->col, matrix->row, matrix->num);
    int *num = new int[matrix->col];
    memset(num, 0, sizeof(int) * matrix->col);
    for (int i = 0; i < matrix->num; i++) {
        num[matrix->data[i].col]++;
    }
    int *cpot = new int[matrix->col];
    cpot[0] = 0;
    for (int i = 1; i < matrix->col; i++) {
        cpot[i] = cpot[i-1] + num[i-1];
    }
    for (int i = 0; i < matrix->num; i++) {
        int col = matrix->data[i].col;
        int pos = cpot[col];
        t->data[pos].row = matrix->data[i].col;
        t->data[pos].col = matrix->data[i].row;
        t->data[pos].val = matrix->data[i].val;
        cpot[col]++;
    }
    delete[] num;
    delete[] cpot;
    return t;
}