假设稀疏矩阵a和b均以三元组顺序表作为存储结构。试写出矩阵相加的算法，另设三元组表c存放结果矩阵。

### 回答1：
矩阵相加的算法如下：

1. 初始化三元组表c，使其行数和列数与a、b相同。

2. 从a和b的第一个非零元素开始遍历，如果它们的行列坐标相同，则将它们的值相加，并将结果存入c中对应的位置。

3. 如果a或b中还有未遍历的元素，则继续遍历。

4. 返回结果矩阵c。

具体实现可以参考以下伪代码：

function matrixAdd(a, b):
c = new SparseMatrix(a.rows, a.cols)
i = j = k = 1
while i <= a.numNonZero and j <= b.numNonZero:
if a.row[i] < b.row[j]:
c.add(a.row[i], a.col[i], a.val[i])
i++
else if a.row[i] > b.row[j]:
c.add(b.row[j], b.col[j], b.val[j])
j++
else if a.col[i] < b.col[j]:
c.add(a.row[i], a.col[i], a.val[i])
i++
else if a.col[i] > b.col[j]:
c.add(b.row[j], b.col[j], b.val[j])
j++
else:
c.add(a.row[i], a.col[i], a.val[i] + b.val[j])
i++
j++
k++
while i <= a.numNonZero:
c.add(a.row[i], a.col[i], a.val[i])
i++
k++
while j <= b.numNonZero:
c.add(b.row[j], b.col[j], b.val[j])
j++
k++
return c

### 回答2：
稀疏矩阵是指矩阵中大部分元素为0的矩阵。对于稀疏矩阵，我们采用三元组顺序表作为存储结构，一般用3个一维数组来表示三元组：

1. data数组存储矩阵的非零元素。
2. row数组存储每个非零元素所在的行数。
3. col数组存储每个非零元素所在的列数。

矩阵相加也可以采用三元组顺序表来实现。假设待相加的稀疏矩阵a和b的三元组分别为tripleta和tripletb，结果矩阵c的三元组为tripletc，则矩阵相加的算法如下：

1. 初始化矩阵c的三元组：每个tripletc的值都为0，其行、列坐标分别与矩阵a、b相同。
2. 分别遍历tripleta和tripletb：
1. 若tripleta和tripletb指向同一行且同一列，则将它们对应的值相加写入tripletc。
2. 若tripleta所指向的行、列小于tripletb所指向的行、列，则将tripleta的值复制到tripletc。
3. 若tripletb所指向的行、列小于tripleta所指向的行、列，则将tripletb的值复制到tripletc。
3. 若遍历完tripleta后，tripletb还有剩余元素，则将它们复制到tripletc。
4. 若遍历完tripletb后，tripleta还有剩余元素，则将它们复制到tripletc。

矩阵相加的时间复杂度主要取决于非零元素的个数，即tripleta和tripletb中非零元素的个数。若n1,n2,n3分别表示矩阵a,b,c的非零元素个数，则时间复杂度为O(n1+n2+n3)。因此，当稀疏矩阵的非零元素较少时，三元组顺序表的存储结构和矩阵相加算法能够很好地节省存储空间和提高运算效率。

### 回答3：
稀疏矩阵是指大部分元素为零的矩阵。对于稀疏矩阵a和b，我们可以采用三元组顺序表作为存储结构，将矩阵的非零元素存储这些元素的值、所在行和所在列，其余位置则默认为零。

矩阵相加的算法如下：

1. 判断a和b是否满足相加条件，即两个矩阵的行数和列数是否相同，如果不相同则无法相加，否则进行下一步；

2. 定义三元组表c存放结果矩阵，初始化为空；

3. 遍历a和b的三元组顺序表，分别获取每个非零元素的值、所在行和所在列；

4. 对于相同的行和列，将a和b对应三元组中的值相加，得到结果矩阵c中该位置的值，并将该值、行、列添加到c的三元组中；

5. 若a或b的三元组中某个位置已经遍历完，则直接将另一个矩阵的剩余三元组添加到结果矩阵c中；

6. 返回结果矩阵c。

以下是伪代码实现：

algorithm matrix_add(a, b):
  if a的行数 != b的行数 或 a的列数 != b的列数:
    return "矩阵不可相加"
  rows = a的行数
  cols = a的列数
  c = []
  p, q = 0, 0
  while p < len(a) and q < len(b):
    if a[p].row < b[q].row or (a[p].row == b[q].row and a[p].col < b[q].col):
      c.append(a[p])
      p += 1
    elif a[p].row > b[q].row or (a[p].row == b[q].row and a[p].col > b[q].col):
      c.append(b[q])
      q += 1
    else:
      v = a[p].value + b[q].value
      if v != 0:
        c.append(Triplet(a[p].row, a[p].col, v))
      p += 1
      q += 1
  while p < len(a):
    c.append(a[p])
    p += 1
  while q < len(b):
    c.append(b[q])
    q += 1
  return c