C语言数据结构【手抄版】第四章多维数组和广义表

数组是我们比较熟悉的一种数据类型。由于数组中各元素具有相同的数据类型，并且数组元素的下标一般具有固定的上界和下界，因此，数组的处理比其他复杂的结构较为简单。当数组维数为1时，数组是一种元素个数固定的线性表，而维数大于1时，称为多维数组，它可以看成是线性表的推广。这里仅讨论多维数组。

由于对数组一般不做插入和删除操作，因此数组一旦建立，结构中的元素个数和元素间的关系就不再发生变化。所以，一般都是采用顺序存储的方法来表示数组。由于在本书中的算法都是用C语言函数来描述的，而C语言的数组下标是从0开始的，因此二维数组A可用如图4.1所示的矩阵形式表示。

由于计算机的内存结构是一维的，所以多维数组的数据存储结构就必须按某种次序将数组元素排成一个线性序列。因此，二维数组又可以以行向量形式表示为:

Amxn=[[a00， a01， ..， a0n-1]， [a10， a11， ..， a1 n-1]， ...， [am-10， am-11， ..， am-1n-1]]

或者以列向量形式表示为:

Amxn=[[a00， a10， ..， am-10]， [a01， a11， ..， am-11]， ...， [a0n-1， a1n-1， ..， am-1n-1]]

多维数组是一种复杂的数据结构。以二维数组为例，数组元素之间的关系除了边界元素外，每个元素aij都恰好有两个直接前趋和两个直接后继:行向量上的直接前趋是aij-1和aij+1，列向量上的直接前趋是ai-1j和直接后继ai+1j。并且二维数组也只有一个开始结点a00，它没有前趋;仅有一个终端结点am-1n-1，它没有后继。此外，边界上的结点(开始结点和终端结点除外)只有一个直接前趋或者只有一个直接后继。

4.1.1.数组的顺序存储

数组在各种高级语言中通常也有两种不同的顺序存储方式，其中最典型的Pascal和C语言是按行优先顺序存储的，而Fortran语言则是按列优先顺序存储的。

1.按行优先顺序存储，即将数组元素按行向量排列，第i+1个行向量紧接在第i个行向量后面。A的m x n个元素按行优先顺序存储的线性序列为:

a00， a01， ...， a0n-1， a10， a11， ..， a1n-1， ...， am-10， am-11， ...， am-1n-1

2.按列优先顺序存储，即将数组元素按列向量排列，第j+1个列向量紧接在第j个列向量之后， A的m x n个元素按列优先顺序存储的线性序列为:

a00， a10， ...， am-10， a01， a11， ..， am-11， ...， a0n-1， a1n-1， ...， am-1n-1

如果按上述两种方式顺序存储数组，只要知道开始结点的存储地址(即基地址)，维数和每维的上、下界，以及每个元素所占用的单元数，就可以将每个数组元素的存储地址表示为其下标的线性函数。例如，二维数组Am x n按行优先顺序存储在内存中，假设每个元素占d个存储单元，数组元素aij (i=0， 1， ..， m-1; j=0， 1， ..， n-1)位于第i行、第j列，前面i行共有i x n个元素，第i行上aij;前面又有j个元素，因此它的前面一共有i x n + j个元素，所以在C语言中的数组元素aij的地址计算函数为:

LOC(aij)=LOC(a00)+(i x n + j)×d

例如，有数组A4x5， d=2， LOC (a00)=100，计算a23的存储地址。

因为i=2， j=3， n=5，根据地址计算函数得:

LOC (a23) =100+ (2×5+3) ×2=126

同理，三维数组Am×n×p按行优先顺序在内存中，计算数组元素aijk的地址计算函数为:

LOC (aijk)=LOC (a000) + (i × n × p+j × p+k) × d

疑问:这些计算公式是怎么来的？

答：它是按行优先顺序存储在内存中，所以你要计算地址值需要计算出前面所有被填满的空位。二维平面数组，三维空间数据。

4.1.2.数组运算举例

【例4.1】设计一个算法，实现矩阵Amm的转置矩阵Bnm。

分析:对于一个m × n的矩阵A，其转置矩阵是一个n × m的矩阵B，而且B[ij] =A[j][i]，0≦i≦n-1， 0≦j≦m-1。假设m=5， n-8，其实现算法如下:

void trsmat()

{ int i，j;

for(j=0;j<m;j++)

for(i=0;i<n;i++)

b[i][j]=a[j][i]

}

【例4.2】如果矩阵A中存在这样的一个元素A[i][j]，满足: A[i][j]是第i行元素中最小值，且又是第j列元素中最大值，则称此元素为该矩阵的一个马鞍点。假设以二维数组存储矩阵Am x n，试编写求出矩阵中所有马鞍点的算法。

分析：按照题意，先求出每行中的最小值元素，存入数组Min[m]之中再求出每列的最大值元素，存入数组Max[n]之中。若某元素既在Min[i]中又在Max[j]中，则该元素A[i][j]就是马鞍点，找出所有这样元素。因此，实现该题要求的算法如下：

void MaxMin(int A[4][5]，int m， int n)

{ int i，j;

int Max[5]， Min[4];

for(i=0;i<m;i++){ //计算每行的最小值元素，存入Min数组中

Min[i]=A[i][0]; //先假设第i行第一个元素最小，然后在与后面的元素比较

for(j=1;j<n;j++)

if(A[i][j]<Min[i])

Min[i]=A[i][j];

}

for(j=0;j<n;j++){ //计算每列的最大值元素，存入Max数组中

Max[j]=A[0][j]; //假设第j列第一个元素最大，然后再与后面的元素比较

for(i=1;i<M;i++)

if(A[i][j]>Max[j])

Max[j]=A[i][j];

}

for(i=0;i<m;i++) //判断是否为马鞍点

for(j=0;j<n;j++)

if(Min[i]==Max[j])

printf(“(%d，%d)”，i，j); //显示马鞍点

}

4.2.矩阵的压缩存储

在许多科学计算和工程应用中，经常要用到矩阵的概念。由于矩阵具有元素数目固定以及元素按下标关系有序排列等特点，所以在使用高级语言编程时，一般都是使用二维数组来存储矩阵，这种表示可以对其元素随机存取，方便进行矩阵的各种运算。在第4.1节的例子中已经用过数组存储矩阵进行有关的运算，但是在有些情况下，矩阵中含有许多值相同或者值为零的元素，如果还按前面的方法来存储这种矩阵，就会产生大量的空间浪费。为了节省存储空间，可以对这类矩阵采用压缩存储。

4.2.1.✮✮✮☛特殊矩阵

所谓特殊矩阵，指的是相同值的元素或者零元素在矩阵中的分布有一定规律的矩阵。下面分别讨论几种特殊矩阵的压缩存储。

1.对称矩阵

若n阶方阵A中的元素满足下述性质：

aij=aji(0≦i，j≦n-1)

则称A为n阶的对称矩阵。对称矩阵中的元素是关于主对角线对称的，所以只需要存储矩阵上三角或下三角的元素即可，让两个对称的元素共享一个存储空间。这样，就能够节省近一半的存储空间。按C语言的“按行优先”存储主对角线(包括主对角线)以下的元素，如图4.2所示。

在以上的下三角矩阵中，第i行(0≦i，j≦n-1)恰好有i+1个元素，所以元素总数为

现假设以一维数组sa[n (n+1) /2]作为n阶对称矩阵A的存储结构，那么，矩阵中元素aij和数组元素sa[k]之间存在着一一对应关系。这种对应关系分析如下:

若i≥j时，则aij在下三角矩阵中。aij之前i行(从0行到第i-1行)一共有1+2+3...+ i=i × (i+1) /2个元素，在第i行上，aij之前恰有j个元素。因此有:

k=i × (i+1)/2+j (0≤k≤n(n+1)/2)

若i<j时，则aij在上三角矩阵中。因为有aij=aji，所以只要交换i和j即可得到:

k=j × (j+1)/2+i (0≤k≤n(n+1)/2)

因此，有：

由此，aij的存储地址可用下面的公式计算:

LOC (aij)=LOC (sa[k]) =LOC (sa[0]) +k × d

有了上述的计算公式，就能够立即找到矩阵元素a在其压缩存储表示sa中的对应位置k。例如，a32和a23都存储在sa[8]中，这是因为

k=i × (i+1)/2+j=3 × (3+1)/2+2=8

对称矩阵压缩存储可以使用一维数组作为对称矩阵的存储数据的容器，创建头文件symmetricMatrix.h定义对称矩阵插入与获取数据功能。

#pragma once

#ifndef SYMMETRIC_MATRIX_H

#define SYMMETRIC_MATRIX_H

// sɪˈmetrɪk ˈmeɪtrɪks

struct SymmetricMatrix

{

struct MatrixArray* matrixArray;

// æbˈsɪsə ˈɔːdɪnət

int (*insert)(int row, int column, void* data, struct SymmetricMatrix* matrix);

void* (*get)(int row, int column, struct SymmetricMatrix* matrix);

int (*capacity)(struct SymmetricMatrix* matrix);

void (*foreach)(void (*printSymmetricMatrix)(void* data), struct SymmetricMatrix* matrix);

void* (*removeByIndex)(int row, int column, struct SymmetricMatrix* matrix);

void* (*removeByData)(void* data, int (*compare)(void* firstData, void* secondData), struct SymmetricMatrix* matrix);

void** (*clear)(struct SymmetricMatrix* matrix);

void** (*destroy)(struct SymmetricMatrix* matrix);

};

struct SymmetricMatrix* initSymmetricMatrix(int matrixSize);

#endif

创建symmetricMatrix.c文件symmetricMatrix.h实现堆成矩阵操作。

#define _CRT_SECURE_NO_WARNINGS //规避C4996告警

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include "symmetricMatrix.h"

struct MatrixArray* initMatrixArray(int matrixSize);

int insertSymmetricMatrix(int row, int column, void* data, struct SymmetricMatrix* matrix);

void* getSymmetricMatrixByIndex(int row, int column, struct SymmetricMatrix* matrix);

int capacitySymmetricMatrix(struct SymmetricMatrix* matrix);

void foreachSymmetricMatrix(void (*printSymmetricMatrix)(void* data), struct SymmetricMatrix* matrix);

void* removeMatrixByIndex(int row, int column, struct SymmetricMatrix* matrix);

void* removeMatrixByData(void* data, int (*compare)(void* firstData, void* secondData), struct SymmetricMatrix* matrix);

void** clearSymmetricMatrix(struct SymmetricMatrix* matrix);

void** destroySymmetricMatrix(struct SymmetricMatrix* matrix);

struct SymmetricMatrix* initSymmetricMatrix(int matrixSize)

{

struct SymmetricMatrix* symmetricMatrix = malloc(sizeof(struct SymmetricMatrix));

struct MatrixArray* matrix = initMatrixArray(matrixSize);

if (symmetricMatrix == NULL || matrix == NULL)

{

printf("创建对称矩阵，分配内存空间失败！\n");

return NULL;

}

symmetricMatrix->matrixArray = matrix;

symmetricMatrix->insert = insertSymmetricMatrix;

symmetricMatrix->get = getSymmetricMatrixByIndex;

symmetricMatrix->capacity = capacitySymmetricMatrix;

symmetricMatrix->foreach = foreachSymmetricMatrix;

symmetricMatrix->removeByIndex = removeMatrixByIndex;

symmetricMatrix->removeByData = removeMatrixByData;

symmetricMatrix->clear = clearSymmetricMatrix;

symmetricMatrix->destroy = destroySymmetricMatrix;

return symmetricMatrix;

}

struct MatrixArray

{

void** array;

int capacity;

};

int getMatrixArrayIndex(int row, int column)

{

if (row >= column)

{

return row * (row + 1) / 2 + column;

}

else

{

return column * (column + 1) / 2 + row;

}

struct MatrixArray* initMatrixArray(int matrixSize)

{

struct MatrixArray* matrix = malloc(sizeof(struct MatrixArray));

if (matrix == NULL)

{

return NULL;

}

matrix->capacity = getMatrixArrayIndex(matrixSize - 1, matrixSize - 1) + 1;

matrix->array = calloc(matrix->capacity, sizeof(void*));

if (matrix == NULL)

{

return NULL;

}

return matrix;

}

int insertSymmetricMatrix(int row, int column, void* data, struct SymmetricMatrix* matrix)

{

struct MatrixArray* matrixArray = matrix->matrixArray;

if (matrixArray == NULL)

{

printf("对称矩阵内存空间不存在！");

return 0;

}

if (row < 0 || column < 0)

{

printf("插入对称矩阵数据坐标不合法，坐标轴不能小于0！");

return 0;

}

if (data == NULL)

{

printf("插入对称矩阵数据不存在！");

return 0;

}

int index = getMatrixArrayIndex(row, column);

if (index >= matrixArray->capacity)

{

printf("对称矩阵行列越界异常！");

return 0;

}

matrixArray->array[index] = data;

return 1;

}

void* getSymmetricMatrixByIndex(int row, int column, struct SymmetricMatrix* matrix)

{

struct MatrixArray* matrixArray = matrix->matrixArray;

if (matrixArray == NULL)

{

printf("对称矩阵内存空间不存在！");

return NULL;

}

if (row < 0 || column < 0)

{

printf("获取对称矩阵数据坐标不合法，坐标轴不能小于0！");

return 0;

}

int index = getMatrixArrayIndex(row, column);

if (index >= matrixArray->capacity)

{

printf("对称矩阵行列越界异常！");

return 0;

}

void* result = matrixArray->array[index];

return matrixArray->array[index];

}

int capacitySymmetricMatrix(struct SymmetricMatrix* matrix)

{

struct MatrixArray* matrixArray = matrix->matrixArray;

if (matrixArray == NULL)

{

printf("对称矩阵内存空间不存在！");

return -1;

}

return matrixArray->capacity;

}

void foreachSymmetricMatrix(void (*printSymmetricMatrix)(void* data), struct SymmetricMatrix* matrix)

{

struct MatrixArray* matrixArray = matrix->matrixArray;

if (matrixArray == NULL)

{

printf("对称矩阵内存空间不存在！");

return;

}

int weight = 1;

int pedometer = weight;

printf("方阵对称矩阵：\n");

for (int i = 0; i < matrixArray->capacity; i++)

{

printSymmetricMatrix(matrixArray->array[i]);

printf("\t");

if ((i + 1) % pedometer == 0)

{

printf("\n");

pedometer = pedometer + ++weight;

}

void* removeMatrixByIndex(int row, int column, struct SymmetricMatrix* matrix)

{

struct MatrixArray* matrixArray = matrix->matrixArray;

if (matrixArray == NULL)

{

printf("对称矩阵内存空间不存在！");

return NULL;

}

int index = getMatrixArrayIndex(row, column);

if (index >= matrixArray->capacity)

{

printf("对称矩阵行列越界异常！");

return 0;

}

void* result = matrixArray->array[index];

matrixArray->array[index] = NULL;

return result;

}

void* removeMatrixByData(void* data, int (*compare)(void* firstData, void* secondData), struct SymmetricMatrix* matrix)

{

struct MatrixArray* matrixArray = matrix->matrixArray;

if (matrixArray == NULL)

{

printf("对称矩阵内存空间不存在！");

return NULL;

}

for (int i = 0; i < matrixArray->capacity; i++)

{

if (compare(data, matrixArray->array[i]))

{

void* result = matrixArray->array[i];

matrixArray->array[i] = NULL;

return result;

}

return NULL;

}

void** clearSymmetricMatrix(struct SymmetricMatrix* matrix)

{

struct MatrixArray* matrixArray = matrix->matrixArray;

if (matrixArray == NULL)

{

printf("对称矩阵内存空间不存在！");

return NULL;

}

void** result = calloc(matrixArray->capacity, sizeof(void*));

memcpy(result, matrixArray->array, sizeof(void*) * matrixArray->capacity);

memset(matrixArray->array, NULL, sizeof(void*) * matrixArray->capacity);

return result;

}

void** destroySymmetricMatrix(struct SymmetricMatrix* matrix)

{

struct MatrixArray* matrixArray = matrix->matrixArray;

if (matrixArray == NULL)

{

printf("对称矩阵内存空间不存在！");

return NULL;

}

void** result = clearSymmetricMatrix(matrix);

free(matrixArray); matrixArray = NULL;

free(matrix); matrix = NULL;

return result;

}

测试对称矩阵：

#define _CRT_SECURE_NO_WARNINGS //规避C4996告警

#include <stdio.h>

#include "symmetricMatrix.h"

void print(void* data)

{

if (data == NULL)

{

printf("NULL");

return;

}

int* num = data;

printf("%d ", num);

}

int compare(void* firstData, void* secondData)

{

return firstData == secondData;

}

int main()

{

struct SymmetricMatrix* matrixA = initSymmetricMatrix(3);

matrixA->insert(0, 0, 2, matrixA);

matrixA->insert(0, 1, 5, matrixA);

matrixA->insert(0, 2, 1, matrixA);

matrixA->insert(1, 1, 4, matrixA);

matrixA->insert(1, 2, 2, matrixA);

matrixA->insert(2, 2, 7, matrixA);

printf("容量：%d\n", matrixA->capacity(matrixA));

matrixA->foreach(print, matrixA);

matrixA->removeByData(7, compare, matrixA);

printf("删除一个值：\n");

matrixA->foreach(print, matrixA);

matrixA->destroy(matrixA);

return 0;

}

测试结果：

容量：6

方阵对称矩阵：

5 4

1 2 7

删除一个值：

方阵对称矩阵：

5 4

1 2 NULL

从测试结果可以看到矩阵元素a45与a54存储的数值相同。

【例4.3】 已知A和B是两个n × n阶的对称矩阵，因为是对称矩阵，所以仅需要输入下三角元素值存入一维数组。试写一算法，求对称矩阵A和B的乘积。

分析:如果是两个完整的矩阵相乘，其算法是比较简单的，但由于是对称矩阵，所以要清楚对称矩阵的第i行和第j列的元素数据在一维数组中的位置，其位置计算公式为：

k=i × (i+1) /2+j 当i≥j时(Aij，Bij，处在下三角中) ;

k=j × (j+1) /2+i 当i<j时(Aij，Bij，处在上三角中) ;

其中， k代表AIJ或BIJ，在其对称矩阵中的位置，而且0≤k<n (n+1)/2。因此，实现本题功能的算法如下:

#define _CRT_SECURE_NO_WARNINGS //规避C4996告警

#include <stdio.h>

#include "symmetricMatrix.h"

void print(void* data)

{

if (data == NULL)

{

printf("%d NULL", data);

return;

}

int* num = data;

printf("%d ", num);

}

void multiplication(struct SymmetricMatrix* matrixA, struct SymmetricMatrix* matrixB)

{

int num = 3;

int result[3][3] = { 0 };

for (int i = 0; i < num; i++)

{

for (int j = 0; j < num; j++)

{

int add = 0;

for (int k = 0; k < num; k++)

{

int a = matrixA->get(i, k, matrixA);

int b = matrixB->get(k, j, matrixB);

add += a * b;

}

result[i][j] = add;

}

int weight = 3;

int pedometer = weight;

printf("矩阵乘积：\n");

for (int i = 0; i < 9; i++)

{

printf("%d ", result[0][i]);

if ((i + 1) % pedometer == 0)

{

printf("\n");

pedometer = pedometer + weight;

}

int main()

{

struct SymmetricMatrix* matrixA = initSymmetricMatrix(3);

matrixA->insert(0, 0, 2, matrixA);

matrixA->insert(0, 1, 5, matrixA);

matrixA->insert(0, 2, 1, matrixA);

matrixA->insert(1, 1, 4, matrixA);

matrixA->insert(1, 2, 2, matrixA);

matrixA->insert(2, 2, 7, matrixA);

printf("容量：%d\n", matrixA->capacity(matrixA));

matrixA->foreach(print, matrixA);

struct SymmetricMatrix* matrixB = initSymmetricMatrix(3);

matrixB->insert(0, 0, 2, matrixB);

matrixB->insert(0, 1, 5, matrixB);

matrixB->insert(0, 2, 3, matrixB);

matrixB->insert(1, 1, 6, matrixB);

matrixB->insert(1, 2, 8, matrixB);

matrixB->insert(2, 2, 1, matrixB);

printf("容量：%d\n", matrixB->capacity(matrixB));

matrixB->foreach(print, matrixB);

multiplication(matrixA, matrixB);

return 0;

}

运行结果：

容量：6

方阵对称矩阵：

5 4

1 2 7

容量：6

方阵对称矩阵：

5 6

3 8 1

矩阵乘积：

32 48 47

36 65 49

33 73 26

2.三角矩阵

以主对角线划分，三角矩阵有上三角和下三角两种。下三角矩阵正好相反，它的主对角线上方均为常数c或零，如图4.3 (a)所示;上三角矩阵是指矩阵的下三角(不包括对角线)中的元素均为常数c或是零的n阶方阵，如图4.3 (b)所示。一般情况下，三角矩阵的常数c均为零。

三角矩阵(n × n阶的方阵)中的重复元素c可共享一个存储空间，其余的元素正好有n (n+1) /2个，因此，三角矩阵可压缩存储在一维数组sa[n (n+1)/2+1]中，其中c存放在数组的最后一个元素中。

在上三角矩阵中，主对角线上第m(0<m<n)行上恰好有n-m个元素，按行优先顺序存储上三角矩阵中元素aij时，aij之前有i行(0~i-1)，一共有元素个数:

而在第i行，aij之前有j-i个元素，因此sa[k]和aij存储位置的对应关系为:

创建头文件upperTriangleMatrix.h：

#pragma once

#ifndef UPPER_TRIANGLE_MATRIX_H

#define UPPER_TRIANGLE_MATRIX_H

struct UpperTriangleMatrix

{

struct UpperMatrixArray* upperMatrix;

// æbˈsɪsə ˈɔːdɪnət

int (*insert)(int row, int column, void* data, struct UpperTriangleMatrix* matrix);

void* (*get)(int row, int column, struct UpperTriangleMatrix* matrix);

int (*capacity)(struct UpperTriangleMatrix* matrix);

void (*foreach)(void (*printUpperTriangleMatrix)(void* data), struct UpperTriangleMatrix* matrix);

void* (*removeByIndex)(int row, int column, struct UpperTriangleMatrix* matrix);

void* (*removeByData)(void* data, int (*compare)(void* firstData, void* secondData), struct UpperTriangleMatrix* matrix);

void** (*clear)(struct UpperTriangleMatrix* matrix);

void** (*destroy)(struct UpperTriangleMatrix* matrix);

};

struct UpperTriangleMatrix* initUpperTriangleMatrix(int matrixSize);

#endif

实现头文件逻辑upperTriangleMatrix.c：

#define _CRT_SECURE_NO_WARNINGS //规避C4996告警

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include "upperTriangleMatrix.h"

struct UpperMatrixArray* initUpperMatrixArray(int matrixSize);

int insertUpperTriangleMatrix(int row, int column, void* data, struct UpperTriangleMatrix* matrix);

void* getUpperTriangleMatrixByIndex(int row, int column, struct UpperTriangleMatrix* matrix);

int capacityUpperTriangleMatrix(struct UpperTriangleMatrix* matrix);

void foreachUpperTriangleMatrix(void (*printUpperTriangleMatrix)(void* data), struct UpperTriangleMatrix* matrix);

void* removeUpperMatrixByIndex(int row, int column, struct UpperTriangleMatrix* matrix);

void* removeUpperMatrixByData(void* data, int (*compare)(void* firstData, void* secondData), struct UpperTriangleMatrix* matrix);

void** clearUpperTriangleMatrix(struct UpperTriangleMatrix* matrix);

void** destroyUpperTriangleMatrix(struct UpperTriangleMatrix* matrix);

struct UpperTriangleMatrix* initUpperTriangleMatrix(int matrixSize)

{

struct UpperTriangleMatrix* upperTriangleMatrix = malloc(sizeof(struct UpperTriangleMatrix));

struct UpperMatrixArray* matrix = initUpperMatrixArray(matrixSize);

if (upperTriangleMatrix == NULL || matrix == NULL)

{

printf("创建上三角矩阵，分配内存空间失败！\n");

return NULL;

}

upperTriangleMatrix->upperMatrix = matrix;

upperTriangleMatrix->insert = insertUpperTriangleMatrix;

upperTriangleMatrix->get = getUpperTriangleMatrixByIndex;

upperTriangleMatrix->capacity = capacityUpperTriangleMatrix;

upperTriangleMatrix->foreach = foreachUpperTriangleMatrix;

upperTriangleMatrix->removeByIndex = removeUpperMatrixByIndex;

upperTriangleMatrix->removeByData = removeUpperMatrixByData;

upperTriangleMatrix->clear = clearUpperTriangleMatrix;

upperTriangleMatrix->destroy = destroyUpperTriangleMatrix;

return upperTriangleMatrix;

}

struct UpperMatrixArray

{

void** array;

int capacity;

int matrixSize;

};

int getUpperMatrixArrayIndex(int row, int column, struct UpperTriangleMatrix* matrix)

{

int matrixSize = matrix->upperMatrix->matrixSize;

if (row > column)

{

return matrixSize * (matrixSize + 1) / 2;

}

else

{

return row * (2 * matrixSize - row + 1) / 2 + column - row;

}

struct UpperMatrixArray* initUpperMatrixArray(int matrixSize)

{

struct UpperMatrixArray* matrix = malloc(sizeof(struct UpperMatrixArray));

if (matrix == NULL)

{

return NULL;

}

matrix->matrixSize = matrixSize;

matrix->capacity = matrixSize * (matrixSize + 1) / 2 + 1;

matrix->array = calloc(matrix->capacity, sizeof(void*));

matrix->array[matrix->capacity - 1] = NULL;

if (matrix == NULL)

{

return NULL;

}

return matrix;

}

int insertUpperTriangleMatrix(int row, int column, void* data, struct UpperTriangleMatrix* matrix)

{

struct UpperMatrixArray* upperMatrix = matrix->upperMatrix;

if (upperMatrix == NULL)

{

printf("上三角矩阵内存空间不存在！");

return 0;

}

if (row < 0 || column < 0)

{

printf("插入上三角矩阵数据坐标不合法，坐标轴不能小于0！");

return 0;

}

if (data == NULL)

{

printf("插入上三角矩阵数据不存在！");

return 0;

}

int index = getUpperMatrixArrayIndex(row, column, matrix);

if (index >= upperMatrix->capacity)

{

printf("上三角矩阵行列越界异常！");

return 0;

}

upperMatrix->array[index] = data;

return 1;

}

void* getUpperTriangleMatrixByIndex(int row, int column, struct UpperTriangleMatrix* matrix)

{

struct UpperMatrixArray* upperMatrix = matrix->upperMatrix;

if (upperMatrix == NULL)

{

printf("上三角矩阵内存空间不存在！");

return NULL;

}

if (row < 0 || column < 0)

{

printf("获取上三角矩阵数据坐标不合法，坐标轴不能小于0！");

return 0;

}

int index = getUpperMatrixArrayIndex(row, column, matrix);

if (index >= upperMatrix->capacity)

{

printf("上三角矩阵行列越界异常！");

return 0;

}

void* result = upperMatrix->array[index];

return upperMatrix->array[index];

}

int capacityUpperTriangleMatrix(struct UpperTriangleMatrix* matrix)

{

struct UpperMatrixArray* upperMatrix = matrix->upperMatrix;

if (upperMatrix == NULL)

{

printf("上三角矩阵内存空间不存在！");

return -1;

}

return upperMatrix->capacity;

}

void foreachUpperTriangleMatrix(void (*printUpperTriangleMatrix)(void* data), struct UpperTriangleMatrix* matrix)

{

struct UpperMatrixArray* upperMatrix = matrix->upperMatrix;

if (upperMatrix == NULL)

{

printf("上三角矩阵内存空间不存在！");

return;

}

int weight = 1;

int pedometer = matrix->upperMatrix->matrixSize + 1;

printf("方阵上三角矩阵：\n");

for (int i = 0; i < upperMatrix->capacity - 1; i++)

{

if ((i + 1) % pedometer == 0)

{

printf("\n");

for (int j = 0; j < weight; j++)

{

printUpperTriangleMatrix(upperMatrix->array[upperMatrix->capacity - 1]);

printf("\t");

}

pedometer = pedometer + matrix->upperMatrix->matrixSize - weight++;

}

printUpperTriangleMatrix(upperMatrix->array[i]);

printf("\t");

}

printf("\n");

}

void* removeUpperMatrixByIndex(int row, int column, struct UpperTriangleMatrix* matrix)

{

struct UpperMatrixArray* upperMatrix = matrix->upperMatrix;

if (upperMatrix == NULL)

{

printf("上三角矩阵内存空间不存在！");

return NULL;

}

int index = getUpperMatrixArrayIndex(row, column, matrix);

if (index >= upperMatrix->capacity)

{

printf("上三角矩阵行列越界异常！");

return 0;

}

void* result = upperMatrix->array[index];

upperMatrix->array[index] = NULL;

return result;

}

void* removeUpperMatrixByData(void* data, int (*compare)(void* firstData, void* secondData), struct UpperTriangleMatrix* matrix)

{

struct UpperMatrixArray* upperMatrix = matrix->upperMatrix;

if (upperMatrix == NULL)

{

printf("上三角矩阵内存空间不存在！");

return NULL;

}

for (int i = 0; i < upperMatrix->capacity; i++)

{

if (compare(data, upperMatrix->array[i]))

{

void* result = upperMatrix->array[i];

upperMatrix->array[i] = NULL;

return result;

}

return NULL;

}

void** clearUpperTriangleMatrix(struct UpperTriangleMatrix* matrix)

{

struct UpperMatrixArray* upperMatrix = matrix->upperMatrix;

if (upperMatrix == NULL)

{

printf("上三角矩阵内存空间不存在！");

return NULL;

}

void** result = calloc(upperMatrix->capacity, sizeof(void*));

memcpy(result, upperMatrix->array, sizeof(void*) * upperMatrix->capacity);

memset(upperMatrix->array, NULL, sizeof(void*) * upperMatrix->capacity);

return result;

}

void** destroyUpperTriangleMatrix(struct UpperTriangleMatrix* matrix)

{

struct UpperMatrixArray* upperMatrix = matrix->upperMatrix;

if (upperMatrix == NULL)

{

printf("上三角矩阵内存空间不存在！");

return NULL;

}

void** result = clearUpperTriangleMatrix(matrix);

free(upperMatrix); upperMatrix = NULL;

free(matrix); matrix = NULL;

return result;

}

测试：

#define _CRT_SECURE_NO_WARNINGS //规避C4996告警

#include <stdio.h>

#include "upperTriangleMatrix.h"

void print(void* data)

{

if (data == NULL)

{

printf("null");

return;

}

int* num = data;

printf("%d ", num);

}

int compare(void* firstData, void* secondData)

{

return firstData == secondData;

}

int main()

{

struct UpperTriangleMatrix* matrixA = initUpperTriangleMatrix(4);

matrixA->insert(0, 0, 2, matrixA);

matrixA->insert(0, 1, 5, matrixA);

matrixA->insert(0, 2, 1, matrixA);

matrixA->insert(0, 3, 9, matrixA);

matrixA->insert(1, 1, 4, matrixA);

matrixA->insert(1, 2, 2, matrixA);

matrixA->insert(1, 3, 8, matrixA);

matrixA->insert(2, 2, 7, matrixA);

matrixA->insert(2, 3, 6, matrixA);

matrixA->insert(3, 3, 4, matrixA);

printf("容量：%d\n", matrixA->capacity(matrixA));

matrixA->foreach(print, matrixA);

printf("删除：%d\n", matrixA->removeByIndex(1,2, matrixA));

printf("删除：%d\n", matrixA->removeByData(9, compare, matrixA));

matrixA->foreach(print, matrixA);

matrixA->destroy(matrixA);

return 0;

}

运行结果：

容量：11

方阵上三角矩阵：

2 5 1 9

null 4 2 8

null null 7 6

null null null 4

删除：2

删除：9

方阵上三角矩阵：

2 5 1 null

null 4 null 8

null null 7 6

null null null 4

而在下三角矩阵中， sa[K]和aij存储位置对应关系与前面介绍的对称矩阵压缩存储类似，只是在当i<j时，下三角矩阵中仅有一个存储位置。因此，该对应关系为:

对于这种特殊矩阵，按上述的对应关系就可以对其元素进行随机存取。

创建头文件downTriangleMatrix.h：

#pragma once

#ifndef DOWN_TRIANGLE_MATRIX_H

#define DOWN_TRIANGLE_MATRIX_H

struct DownTriangleMatrix

{

struct DownMatrixArray* downMatrix;

// æbˈsɪsə ˈɔːdɪnət

int (*insert)(int row, int column, void* data, struct DownTriangleMatrix* matrix);

void* (*get)(int row, int column, struct DownTriangleMatrix* matrix);

int (*capacity)(struct DownTriangleMatrix* matrix);

void (*foreach)(void (*printDownTriangleMatrix)(void* data), struct DownTriangleMatrix* matrix);

void* (*removeByIndex)(int row, int column, struct DownTriangleMatrix* matrix);

void* (*removeByData)(void* data, int (*compare)(void* firstData, void* secondData), struct DownTriangleMatrix* matrix);

void** (*clear)(struct DownTriangleMatrix* matrix);

void** (*destroy)(struct DownTriangleMatrix* matrix);

};

struct DownTriangleMatrix* initDownTriangleMatrix(int matrixSize);

#endif

实现头文件逻辑downTriangleMatrix.c：

#define _CRT_SECURE_NO_WARNINGS //规避C4996告警

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include "downTriangleMatrix.h"

struct DownMatrixArray* initDownMatrixArray(int matrixSize);

int insertDownTriangleMatrix(int row, int column, void* data, struct DownTriangleMatrix* matrix);

void* getDownTriangleMatrixByIndex(int row, int column, struct DownTriangleMatrix* matrix);

int capacityDownTriangleMatrix(struct DownTriangleMatrix* matrix);

void foreachDownTriangleMatrix(void (*printDownTriangleMatrix)(void* data), struct DownTriangleMatrix* matrix);

void* removeDownMatrixByIndex(int row, int column, struct DownTriangleMatrix* matrix);

void* removeDownMatrixByData(void* data, int (*compare)(void* firstData, void* secondData), struct DownTriangleMatrix* matrix);

void** clearDownTriangleMatrix(struct DownTriangleMatrix* matrix);

void** destroyDownTriangleMatrix(struct DownTriangleMatrix* matrix);

struct DownTriangleMatrix* initDownTriangleMatrix(int matrixSize)

{

struct DownTriangleMatrix* downTriangleMatrix = malloc(sizeof(struct DownTriangleMatrix));

struct DownMatrixArray* matrix = initDownMatrixArray(matrixSize);

if (downTriangleMatrix == NULL || matrix == NULL)

{

printf("创建下三角矩阵，分配内存空间失败！\n");

return NULL;

}

downTriangleMatrix->downMatrix = matrix;

downTriangleMatrix->insert = insertDownTriangleMatrix;

downTriangleMatrix->get = getDownTriangleMatrixByIndex;

downTriangleMatrix->capacity = capacityDownTriangleMatrix;

downTriangleMatrix->foreach = foreachDownTriangleMatrix;

downTriangleMatrix->removeByIndex = removeDownMatrixByIndex;

downTriangleMatrix->removeByData = removeDownMatrixByData;

downTriangleMatrix->clear = clearDownTriangleMatrix;

downTriangleMatrix->destroy = destroyDownTriangleMatrix;

return downTriangleMatrix;

}

struct DownMatrixArray

{

void** array;

int capacity;

int matrixSize;

};

int getDownMatrixArrayIndex(int row, int column, struct DownTriangleMatrix* matrix)

{

int matrixSize = matrix->downMatrix->matrixSize;

if (row < column)

{

return matrixSize * (matrixSize + 1) / 2;

}

else

{

return row * (row + 1) / 2 + column;

}

struct DownMatrixArray* initDownMatrixArray(int matrixSize)

{

struct DownMatrixArray* matrix = malloc(sizeof(struct DownMatrixArray));

if (matrix == NULL)

{

return NULL;

}

matrix->matrixSize = matrixSize;

matrix->capacity = matrixSize * (matrixSize + 1) / 2 + 1;

matrix->array = calloc(matrix->capacity, sizeof(void*));

matrix->array[matrix->capacity - 1] = NULL;

if (matrix == NULL)

{

return NULL;

}

return matrix;

}

int insertDownTriangleMatrix(int row, int column, void* data, struct DownTriangleMatrix* matrix)

{

struct DownMatrixArray* downMatrix = matrix->downMatrix;

if (downMatrix == NULL)

{

printf("下三角矩阵内存空间不存在！");

return 0;

}

if (row < 0 || column < 0)

{

printf("插入下三角矩阵数据坐标不合法，坐标轴不能小于0！");

return 0;

}

if (data == NULL)

{

printf("插入下三角矩阵数据不存在！");

return 0;

}

int index = getDownMatrixArrayIndex(row, column, matrix);

if (index >= downMatrix->capacity)

{

printf("下三角矩阵行列越界异常！");

return 0;

}

downMatrix->array[index] = data;

return 1;

}

void* getDownTriangleMatrixByIndex(int row, int column, struct DownTriangleMatrix* matrix)

{

struct DownMatrixArray* downMatrix = matrix->downMatrix;

if (downMatrix == NULL)

{

printf("下三角矩阵内存空间不存在！");

return NULL;

}

if (row < 0 || column < 0)

{

printf("获取下三角矩阵数据坐标不合法，坐标轴不能小于0！");

return 0;

}

int index = getDownMatrixArrayIndex(row, column, matrix);

if (index >= downMatrix->capacity)

{

printf("下三角矩阵行列越界异常！");

return 0;

}

void* result = downMatrix->array[index];

return downMatrix->array[index];

}

int capacityDownTriangleMatrix(struct DownTriangleMatrix* matrix)

{

struct DownMatrixArray* downMatrix = matrix->downMatrix;

if (downMatrix == NULL)

{

printf("下三角矩阵内存空间不存在！");

return -1;

}

return downMatrix->capacity;

}

void foreachDownTriangleMatrix(void (*printDownTriangleMatrix)(void* data), struct DownTriangleMatrix* matrix)

{

struct DownMatrixArray* downMatrix = matrix->downMatrix;

if (downMatrix == NULL)

{

printf("下三角矩阵内存空间不存在！");

return;

}

int weight = 1;

int pedometer = weight;

printf("方阵下三角矩阵：\n");

for (int i = 0; i < downMatrix->capacity - 1; i++)

{

printDownTriangleMatrix(downMatrix->array[i]);

printf("\t");

if ((i + 1) % pedometer == 0)

{

for (int j = 0; j < downMatrix->matrixSize - weight; j++)

{

printDownTriangleMatrix(downMatrix->array[downMatrix->capacity - 1]);

printf("\t");

}

printf("\n");

pedometer = pedometer + ++weight;

}

void* removeDownMatrixByIndex(int row, int column, struct DownTriangleMatrix* matrix)

{

struct DownMatrixArray* downMatrix = matrix->downMatrix;

if (downMatrix == NULL)

{

printf("下三角矩阵内存空间不存在！");

return NULL;

}

int index = getDownMatrixArrayIndex(row, column, matrix);

if (index >= downMatrix->capacity)

{

printf("下三角矩阵行列越界异常！");

return 0;

}

void* result = downMatrix->array[index];

downMatrix->array[index] = NULL;

return result;

}

void* removeDownMatrixByData(void* data, int (*compare)(void* firstData, void* secondData), struct DownTriangleMatrix* matrix)

{

struct DownMatrixArray* downMatrix = matrix->downMatrix;

if (downMatrix == NULL)

{

printf("下三角矩阵内存空间不存在！");

return NULL;

}

for (int i = 0; i < downMatrix->capacity; i++)

{

if (compare(data, downMatrix->array[i]))

{

void* result = downMatrix->array[i];

downMatrix->array[i] = NULL;

return result;

}

return NULL;

}

void** clearDownTriangleMatrix(struct DownTriangleMatrix* matrix)

{

struct DownMatrixArray* downMatrix = matrix->downMatrix;

if (downMatrix == NULL)

{

printf("下三角矩阵内存空间不存在！");

return NULL;

}

void** result = calloc(downMatrix->capacity, sizeof(void*));

memcpy(result, downMatrix->array, sizeof(void*) * downMatrix->capacity);

memset(downMatrix->array, NULL, sizeof(void*) * downMatrix->capacity);

return result;

}

void** destroyDownTriangleMatrix(struct DownTriangleMatrix* matrix)

{

struct DownMatrixArray* downMatrix = matrix->downMatrix;

if (downMatrix == NULL)

{

printf("下三角矩阵内存空间不存在！");

return NULL;

}

void** result = clearDownTriangleMatrix(matrix);

free(downMatrix); downMatrix = NULL;

free(matrix); matrix = NULL;

return result;

}

测试：

#define _CRT_SECURE_NO_WARNINGS //规避C4996告警

#include <stdio.h>

#include "downTriangleMatrix.h"

void print(void* data)

{

if (data == NULL)

{

printf("null");

return;

}

int* num = data;

printf("%d ", num);

}

int compare(void* firstData, void* secondData)

{

return firstData == secondData;

}

int main()

{

struct DownTriangleMatrix* matrixA = initDownTriangleMatrix(4);

matrixA->insert(0, 0, 2, matrixA);

matrixA->insert(1, 0, 5, matrixA);

matrixA->insert(1, 1, 1, matrixA);

matrixA->insert(2, 0, 9, matrixA);

matrixA->insert(2, 1, 4, matrixA);

matrixA->insert(2, 2, 4, matrixA);

matrixA->insert(3, 0, 2, matrixA);

matrixA->insert(3, 1, 8, matrixA);

matrixA->insert(3, 2, 7, matrixA);

matrixA->insert(3, 3, 6, matrixA);

printf("容量：%d\n", matrixA->capacity(matrixA));

matrixA->foreach(print, matrixA);

printf("删除：%d\n", matrixA->removeByIndex(0, 0, matrixA));

printf("删除：%d\n", matrixA->removeByData(9, compare, matrixA));

matrixA->foreach(print, matrixA);

matrixA->destroy(matrixA);

return 0;

}

运行结果：

容量：11

方阵下三角矩阵：

2 null null null

5 1 null null

9 4 4 null

2 8 7 6

删除：2

删除：9

方阵下三角矩阵：

null null null null

5 1 null null

null 4 4 null

2 8 7 6

4.2.2.稀疏矩阵

由于特殊矩阵中非零元素的分布是有规律的，因此总可以找到矩阵元素与一维数的下标的对应关系。但还有一种矩阵，其中有s个非零元素，而s远远小于矩阵元素总数，通常把这种矩阵称为稀疏矩阵。为了节省存储单元，也可用压缩存储方法只存位非零元素。由于稀疏矩阵非零元素的分布一般是没有规律的，因此在存储非零元素时，除了存储非零元素的值之外，还必须同时存储该元素的行、列位置(即下标)，所以可用一个称为三元组(i， j， aij)来唯一确定一个非零元素。当用三元组来表示非零元素时，对稀疏矩阵进行压缩存储通常有两种方法:顺序存储和链式存储。链式存储一般采用的是十字链表法，结构比较复杂。

1.三元组表

如果将表示稀疏矩阵非零元素的三元组按行优先的顺序排列，则可得到一个其结点均为三元组的线性表，将这种线性表的顺序存储结构称为三元组表。

为了操作方便，对稀疏矩阵的总行数、总列数以及非零元素个数均作为三元组表的辅助属性加以描述。三元组表的类型定义如下：

// spɑːs ˈtʌpəl

struct SparseTupleNode

{

void* data; // 非0元素值

int row; // 行索引

int column; // 列索引

};

// spɑːs ˈmeɪtrɪks

struct SparseMatrix

{

struct ArrayList* tupleArray; // 动态数组容器

int rowAmount; // 行

int columnAmount; // 列

int elementAmount; // 元素数量

};

编写头文件sparseMatrix.h。

#pragma once

#ifndef SPARSE_MATRIX_H

#define SPARSE_MATRIX_H

#include "dynamicArray.h"

// spɑːs ˈmeɪtrɪks

struct SparseMatrix

{

struct ArrayList* tupleArray; // 动态数组容器

int rowAmount; // 行

int columnAmount; // 列

int elementAmount; // 元素数量

int (*insert)(int row, int column, void* data, struct SparseMatrix* sparseMatrix);

void* (*get)(int row, int column, struct SparseMatrix* sparseMatrix);

void (*foreach)(void (*printUpperTriangleMatrix)(void* data), struct SparseMatrix* sparseMatrix);

void (*foreachTuple)(void (*printUpperTriangleMatrix)(void* data), struct SparseMatrix* sparseMatrix);

void* (*removeByIndex)(int row, int column, struct SparseMatrix* sparseMatrix);

void* (*removeByData)(void* data, int (*compare)(void* firstData, void* secondData), struct SparseMatrix* sparseMatrix);

struct ClearArea* (*clear)(struct SparseMatrix* sparseMatrix);

struct ClearArea* (*destroy)(struct SparseMatrix* sparseMatrix);

};

// spɑːs ˈtʌpəl

struct SparseTupleNode

{

void* data; // 非0元素值

int row; // 行索引

int column; // 列索引

};

struct SparseMatrix* initSparseMatrix(int rowAmount, int columnAmount);

#endif

实现头文件定义sparseMatrix.c。

#define _CRT_SECURE_NO_WARNINGS //规避C4996告警

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include "sparseMatrix.h"

int insertSparseMatrix(int row, int column, void* data, struct SparseMatrix* sparseMatrix);

void* getSparseMatrix(int row, int column, struct SparseMatrix* sparseMatrix);

void foreachSparseMatrix(void (*printUpperTriangleMatrix)(void* data), struct SparseMatrix* sparseMatrix);

void foreachSparseTupleNode(void (*printUpperTriangleMatrix)(void* data), struct SparseMatrix* sparseMatrix);

void* removeBySparseIndex(int row, int column, struct SparseMatrix* sparseMatrix);

void* removeBySparseData(void* data, int (*compare)(void* firstData, void* secondData), struct SparseMatrix* sparseMatrix);

struct ClearArea* clearSparseMatrix(struct SparseMatrix* sparseMatrix);

struct ClearArea* destroySparseMatrix(struct SparseMatrix* sparseMatrix);

struct SparseMatrix* initSparseMatrix(int rowAmount, int columnAmount)

{

struct SparseMatrix* sparseMatrix = malloc(sizeof(struct SparseMatrix));

struct ArrayList* arrayList = initArrayList(5);

if (sparseMatrix == NULL || arrayList == NULL)

{

printf("创建稀疏矩阵，分配内存空间失败！\n");

return NULL;

}

sparseMatrix->rowAmount = rowAmount;

sparseMatrix->columnAmount = columnAmount;

sparseMatrix->tupleArray = arrayList;

sparseMatrix->insert = insertSparseMatrix;

sparseMatrix->get = getSparseMatrix;

sparseMatrix->foreach = foreachSparseMatrix;

sparseMatrix->foreachTuple = foreachSparseTupleNode;

sparseMatrix->removeByIndex = removeBySparseIndex;

sparseMatrix->removeByData = removeBySparseData;

sparseMatrix->clear = clearSparseMatrix;

sparseMatrix->destroy = destroySparseMatrix;

return sparseMatrix;

}

int insertSparseMatrix(int row, int column, void* data, struct SparseMatrix* sparseMatrix)

{

struct ArrayList* tupleArray = sparseMatrix->tupleArray;

if (tupleArray == NULL)

{

printf("稀疏矩阵存储容器不存在！\n");

return 0;

}

if (row < 0 || row > sparseMatrix->rowAmount)

{

printf("输入行号不合法或超出稀疏矩阵容量！\n");

return 0;

}

if (column < 0 || column > sparseMatrix->columnAmount)

{

printf("输入列号不合法或超出稀疏矩阵容量！\n");

return 0;

}

struct SparseTupleNode* tupleNode = malloc(sizeof(struct SparseTupleNode));

if (tupleNode == NULL)

{

printf("内存空间开辟不足，插入元素失败！\n");

return 0;

}

tupleNode->data = data;

tupleNode->row = row;

tupleNode->column = column;

if (tupleArray->size(tupleArray) <= 0)

{

tupleArray->insert(0, tupleNode, tupleArray);

sparseMatrix->elementAmount = 1;

return 1;

}

for (int i = 0; i < tupleArray->size(tupleArray); i++)

{

struct SparseTupleNode* currentNode = tupleArray->get(i, tupleArray);

if (row < currentNode->row)

{

tupleArray->insert(i, tupleNode, tupleArray);

sparseMatrix->elementAmount++;

return 1;

}

if (row == currentNode->row && column < currentNode->column)

{

tupleArray->insert(i, tupleNode, tupleArray);

sparseMatrix->elementAmount++;

return 1;

}

if (row == currentNode->row && column == currentNode->column)

{

currentNode->data = data;

return 1;

}

tupleArray->insert(tupleArray->size(tupleArray), tupleNode, tupleArray);

sparseMatrix->elementAmount++;

return 1;;

}

void* getSparseMatrix(int row, int column, struct SparseMatrix* sparseMatrix)

{

struct ArrayList* tupleArray = sparseMatrix->tupleArray;

if (tupleArray == NULL)

{

printf("稀疏矩阵存储容器不存在！\n");

return NULL;

}

if (row < 0 || row > sparseMatrix->rowAmount)

{

printf("输入行号不合法或超出稀疏矩阵容量！\n");

return NULL;

}

if (column < 0 || column > sparseMatrix->columnAmount)

{

printf("输入列号不合法或超出稀疏矩阵容量！\n");

return NULL;

}

for (int i = 0; i < tupleArray->size(tupleArray); i++)

{

struct SparseTupleNode* currentNode = tupleArray->get(i, tupleArray);

if (row == currentNode->row && column == currentNode->column)

{

return currentNode->data;

}

return NULL;

}

void foreachSparseMatrix(void (*printUpperTriangleMatrix)(void* data), struct SparseMatrix* sparseMatrix)

{

struct ArrayList* tupleArray = sparseMatrix->tupleArray;

if (tupleArray == NULL)

{

printf("稀疏矩阵存储容器不存在！\n");

return NULL;

}

int arraySize = tupleArray->size(tupleArray);

printf("稀疏矩阵共%d个非0元素！\n", arraySize);

int flag = 1;

for (int i = 0; i < sparseMatrix->rowAmount; i++)

{

for (int j = 0; j < sparseMatrix->columnAmount; j++)

{

flag = 1;

for (int k = 0; k < arraySize; k++)

{

struct SparseTupleNode* currentNode = tupleArray->get(k, tupleArray);

if (currentNode->row == i && currentNode->column == j)

{

printUpperTriangleMatrix(currentNode->data);

printf("\t");

flag = 0;

}

if (flag)

{

printf("NULL\t");

}

printf("\n");

}

void foreachSparseTupleNode(void (*printUpperTriangleMatrix)(void* data), struct SparseMatrix* sparseMatrix)

{

struct ArrayList* tupleArray = sparseMatrix->tupleArray;

if (tupleArray == NULL)

{

printf("稀疏矩阵存储容器不存在！\n");

return NULL;

}

int arraySize = tupleArray->size(tupleArray);

printf("稀疏矩阵共%d个非0元素！\n", arraySize);

for (int i = 0; i < arraySize; i++)

{

struct SparseTupleNode* currentNode = tupleArray->get(i, tupleArray);

printf("%d ", currentNode->row);

printf("%d ", currentNode->column);

printUpperTriangleMatrix(currentNode->data);

printf("\n");

}

void* removeBySparseIndex(int row, int column, struct SparseMatrix* sparseMatrix)

{

struct ArrayList* tupleArray = sparseMatrix->tupleArray;

if (tupleArray == NULL)

{

printf("稀疏矩阵存储容器不存在！\n");

return NULL;

}

for (int i = 0; i < tupleArray->size(tupleArray); i++)

{

struct SparseTupleNode* currentNode = tupleArray->get(i, tupleArray);

if (row == currentNode->row && column == currentNode->column)

{

struct SparseTupleNode* tupleNode = tupleArray->removeByIndex(i, tupleArray);

sparseMatrix->elementAmount = tupleArray->size(tupleArray);

return tupleNode->data;

}

return NULL;

}

void* removeBySparseData(void* data, int (*compare)(void* firstData, void* secondData), struct SparseMatrix* sparseMatrix)

{

struct ArrayList* tupleArray = sparseMatrix->tupleArray;

if (tupleArray == NULL)

{

printf("稀疏矩阵存储容器不存在！\n");

return NULL;

}

for (int i = 0; i < tupleArray->size(tupleArray); i++)

{

struct SparseTupleNode* currentNode = tupleArray->get(i, tupleArray);

if (compare(currentNode->data, data))

{

struct SparseTupleNode* tupleNode = tupleArray->removeByIndex(i, tupleArray);

sparseMatrix->elementAmount = tupleArray->size(tupleArray);

return tupleNode->data;

}

return NULL;

}

struct ClearArea* clearSparseMatrix(struct SparseMatrix* sparseMatrix)

{

struct ArrayList* tupleArray = sparseMatrix->tupleArray;

if (tupleArray == NULL)

{

printf("稀疏矩阵存储容器不存在！\n");

return NULL;

}

struct ClearArea* result = malloc(sizeof(struct ClearArea));

void** resultArray = malloc(sizeof(void*) * sparseMatrix->elementAmount);

if (result == NULL || resultArray == NULL)

{

printf("清空动态数组时，清空的数据没有足够的内存可以记录。\n");

return NULL;

}

struct ClearArea* clearArea = tupleArray->clear(tupleArray);

struct SparseTupleNode** tupleNode = clearArea->array;

for (int i = 0; i < sparseMatrix->elementAmount; i++)

{

resultArray[i] = tupleNode[i]->data;

free(tupleNode[i]); tupleNode[i] = NULL;

}

result->array = resultArray;

result->size = sparseMatrix->elementAmount;

sparseMatrix->elementAmount = 0;

return result;

}

struct ClearArea* destroySparseMatrix(struct SparseMatrix* sparseMatrix)

{

struct ArrayList* tupleArray = sparseMatrix->tupleArray;

if (tupleArray == NULL)

{

printf("稀疏矩阵存储容器不存在！\n");

return NULL;

}

struct ClearArea* clearArea = clearSparseMatrix(sparseMatrix);

tupleArray->destroy(tupleArray);

free(sparseMatrix); sparseMatrix = NULL;

return clearArea;

}

测试：

#define _CRT_SECURE_NO_WARNINGS //规避C4996告警

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include "sparseMatrix.h"

void print(void* data)

{

printf("%d", data);

}

int compare(void* firstData, void* secondData)

{

return firstData = secondData;

}

int main()

{

struct SparseMatrix* matrix = initSparseMatrix(5, 3);

matrix->insert(0, 2, 99, matrix);

matrix->insert(1, 1, 87, matrix);

matrix->insert(3, 2, 15, matrix);

matrix->foreachTuple(print, matrix);

matrix->foreach(print, matrix);

printf("获取数据：%d", matrix->get(0, 2, matrix));

matrix->removeByIndex(1, 1, matrix);

matrix->removeByData(15, compare, matrix);

matrix->foreach(print, matrix);

struct ClearArea* clearArea = matrix->destroy(matrix);

printf("销毁矩阵，移除数据：%d", clearArea->array[0]);

return 0;

}

运行结果：

稀疏矩阵共3个非0元素！

0 2 99

1 1 87

3 2 15

稀疏矩阵共3个非0元素！

NULL NULL 99

NULL 87 NULL

NULL NULL NULL

NULL NULL 15

NULL NULL NULL

获取数据：99稀疏矩阵共1个非0元素！

NULL NULL NULL

NULL NULL 15

NULL NULL NULL

销毁矩阵，移除数据：15

【例4.4】试写一个算法，建立顺序存储稀疏矩阵的三元组表。

分析:假设A为一个稀疏矩阵，其数据存储在二维数组matrix中，sparseMatrix为一个存放对应于A矩阵生成的三元组表。在这个算法中，要进行二重循环来判断每个矩阵元素是否为零，若不为零，则将其行、列下标及其值存入sparseMatrix中。其算法如下:

#define _CRT_SECURE_NO_WARNINGS //规避C4996告警

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include "sparseMatrix.h"

void print(void* data)

{

printf("%d", data);

}

void setVlue(int matrix[4][5], struct SparseMatrix* sparseMatrix)

{

for (int i = 0; i < 4; i++)

{

for (int j = 0; j < 5; j++)

{

if (matrix[i][j] != 0)

{

sparseMatrix->insert(i, j, matrix[i][j], sparseMatrix);

}

sparseMatrix->foreach(print, sparseMatrix);

}

int main()

{

int matrix[4][5] = { 0 };

matrix[0][1] = 99;

matrix[1][4] = 15;

matrix[3][4] = 66;

struct SparseMatrix* sparseMatrix = initSparseMatrix(4, 5);

setVlue(matrix, sparseMatrix);

return 0;

}

运行结果：

稀疏矩阵共3个非0元素！

NULL 99 NULL NULL NULL

NULL NULL NULL NULL 15

NULL NULL NULL NULL NULL

NULL NULL NULL NULL 66

【例4.5】试写一个算法，实现以三元组表结构存储的稀疏矩阵的转置运算。

分析:转置运算是一种常用的简单矩阵运算。对于一个m x n的矩阵M，它的转置矩阵T是一个n x m的矩阵，而且Mij=Tij (0<i<m，os<n)，即M的行是T的列，M的列是T的行。如图4.4所示为稀疏矩阵M和相应的转置矩阵T。

稀疏矩阵的转置方法有多种，假设有两个矩阵---稀疏矩阵M与稀疏矩阵T。从上面的分析可知，要将M转置成T，就是将M的三元组表a.data转置为T的三元组表b->data。要想得到如图4.5所示的按行优先顺序存储的b->data，就必须重新排列三元组表的顺序。由于M的行是T的列，所以按a.data的列转置，所得到的转置矩阵T的三元组表b->data一定是按行优先顺序存放的。实现这种方法的基本思想是:对M中的每一列col (0<col<a.n-1)从头至尾依次扫描三元组表，找出所有列号等于col的那些三元组，并将它们的行号和列号互换后再依次存入b->data中，这样就可得到T的按行优先的三元组表。

其具体算法如下：

#define _CRT_SECURE_NO_WARNINGS //规避C4996告警

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include "sparseMatrix.h"

// spɑːs ˈtʌpəl

struct SparseTupleNode

{

void* data; // 非0元素值

int row; // 行索引

int column; // 列索引

};

void print(void* data)

{

printf("%d", data);

}

void overturn(struct SparseMatrix* mMatrix, struct SparseMatrix* tMatrix)

{

struct ArrayList* tupleArray = mMatrix->tupleArray;

for (int col = 0; col < mMatrix->columnAmount; col++)

{

for (int element = 0; element < mMatrix->elementAmount; element++)

{

struct SparseTupleNode* tupleNode = tupleArray->get(element, tupleArray);

if (tupleNode->column == col)

{

tMatrix->insert(tupleNode->column, tupleNode->row, tupleNode->data, tMatrix);

}

printf("转置后：\n");

tMatrix->foreach(print, tMatrix);

}

int main()

{

struct SparseMatrix* mMatrix = initSparseMatrix(4, 5);

mMatrix->insert(2, 2, 36, mMatrix);

mMatrix->insert(3, 4, 66, mMatrix);

mMatrix->insert(0, 1, 99, mMatrix);

mMatrix->insert(0, 2, 38, mMatrix);

mMatrix->insert(1, 2, 17, mMatrix);

mMatrix->insert(1, 4, 15, mMatrix);

printf("转置前：\n");

mMatrix->foreach(print, mMatrix);

struct SparseMatrix* tMatrix = initSparseMatrix(5, 4);

overturn(mMatrix, tMatrix);

return 0;

}

运行结果：

转置前：

稀疏矩阵共6个非0元素！

NULL 99 38 NULL NULL

NULL NULL 17 NULL 15

NULL NULL 36 NULL NULL

NULL NULL NULL NULL 66

转置后：

稀疏矩阵共6个非0元素！

NULL NULL NULL NULL

99 NULL NULL NULL

38 17 36 NULL

NULL NULL NULL NULL

NULL 15 NULL 66

分析这个算法，它的主要运算是在col和element的两重循环中完成的，因此该算法的时间复杂度为O(col × element)，即与稀疏矩阵M的列数和非零元素个数的乘积成正比。

我们知道，一般的矩阵转置算法的时间复杂度为O(m × n)。当稀疏矩阵的非零元素个数element和m × n同数量级时，上述算法的时间复杂度就是O(m × n)了，其算法虽然节省了存储空间，但时间复杂度提高了。因此，该算法仅适用于非零元素个数element远远小于矩阵元素个数m x n的情况。

因为我们对稀疏矩阵的结构做了封装，所以上述的算法无需两重循环，只需要借助于封装的稀疏矩阵结构即可自动完成稀疏矩阵转置。

#define _CRT_SECURE_NO_WARNINGS //规避C4996告警

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include "sparseMatrix.h"

void print(void* data)

{

printf("%d", data);

}

void overturn(struct SparseMatrix* mMatrix, struct SparseMatrix* tMatrix)

{

struct ArrayList* tupleArray = mMatrix->tupleArray;

for (int element = 0; element < mMatrix->elementAmount; element++)

{

struct SparseTupleNode* tupleNode = tupleArray->get(element, tupleArray);

tMatrix->insert(tupleNode->column, tupleNode->row, tupleNode->data, tMatrix);

}

printf("转置后：\n");

tMatrix->foreach(print, tMatrix);

}

int main()

{

struct SparseMatrix* mMatrix = initSparseMatrix(4, 5);

mMatrix->insert(2, 2, 36, mMatrix);

mMatrix->insert(3, 4, 66, mMatrix);

mMatrix->insert(0, 1, 99, mMatrix);

mMatrix->insert(0, 2, 38, mMatrix);

mMatrix->insert(1, 2, 17, mMatrix);

mMatrix->insert(1, 4, 15, mMatrix);

printf("转置前：\n");

mMatrix->foreach(print, mMatrix);

struct SparseMatrix* tMatrix = initSparseMatrix(5, 4);

overturn(mMatrix, tMatrix);

return 0;

}

运行结果：

转置前：

稀疏矩阵共6个非0元素！

NULL 99 38 NULL NULL

NULL NULL 17 NULL 15

NULL NULL 36 NULL NULL

NULL NULL NULL NULL 66

转置后：

稀疏矩阵共6个非0元素！

NULL NULL NULL NULL

99 NULL NULL NULL

38 17 36 NULL

NULL NULL NULL NULL

NULL 15 NULL 66

2.带行表三元组表

为了便于随机存取任意一行的非零元素，可在按行优先存储的三元组表中，增加一个存储每一行的第一个非零元素在三元组表中位置的数组。这样就得到稀疏矩阵的另一种顺序存储结构——带行表的三元组表，又称为行逻辑链接的顺序表。其类型描述如下:

// spɑːs ˈmeɪtrɪks

struct SparseMatrix

{

struct ArrayList* tupleArray; // 动态数组容器

int* rowTable; // 行表(记录当前行之前元素个数第一行与最后一行不记录)

int rowAmount; // 行

int columnAmount; // 列

int elementAmount; // 元素数量

};

在有了行表结构定义之后，由图4.5所示的三元组表a.data，就可以得到如表4.1所示的稀疏矩阵M的行表RowPos及其相关信息。

在这个表中，可以看到对于任一给定的行号i，都能迅速地确定该行的第一个非零元素在三元组表中的存储位置RowPos[i]。同时， RowPos[i]又表示第i行之前的所有行的非零元素总数，而且可以通过RowPos[i+1]-RowPos[i]计算出第i行上的非零元素个数。

编写头文件sparseMatrix.h。

#pragma once

#ifndef SPARSE_MATRIX_H

#define SPARSE_MATRIX_H

#include "dynamicArray.h"

// spɑːs ˈmeɪtrɪks

struct SparseMatrix

{

struct ArrayList* tupleArray; // 动态数组容器

int* rowTable; // 行表(记录当前行之前元素个数第一行与最后一行不记录)

int rowAmount; // 行

int columnAmount; // 列

int elementAmount; // 元素数量

int (*insert)(int row, int column, void* data, struct SparseMatrix* sparseMatrix);

void* (*get)(int row, int column, struct SparseMatrix* sparseMatrix);

void* (*getByRow)(int row, int column, struct SparseMatrix* sparseMatrix);

void (*foreach)(void (*printUpperTriangleMatrix)(void* data), struct SparseMatrix* sparseMatrix);

void (*foreachTuple)(void (*printUpperTriangleMatrix)(void* data), struct SparseMatrix* sparseMatrix);

void* (*removeByIndex)(int row, int column, struct SparseMatrix* sparseMatrix);

void* (*removeByRow)(int row, int column, struct SparseMatrix* sparseMatrix);