矩阵在数据结构与算法的课程中也是非常重要的一章。矩阵也是一种存储数据的方式，所以本人通过这一章来对矩阵进行一下讲解以及说明。

首先，我来提出一个很常见的面试题：

请编写一个通用的二维数组（用c实现）：

这个问题相对而言比较简单，一个二维数组重要的只有三点，即：横下标、纵下标、值，所以我们来构建如下结构体：

typedef struct MATRIX {
    USER_TYPE *data;            //这里的USER_TYPE类型是用户自己定义的类型，而我们用它的指针作为结构体的成员，这样使得所有存储在二维数组中的数据都能够通过这个成员被访问
    int maxRow;                 //这个成员用于存储最大行数
    int maxCol;                 //这个成员用于存储最大列数
}MATRIX;

在这里，我们发现，其实传过来的USER_TYPE *类型其实表示的是一维数组，但是我们需要表示二维数组，所以我还要提到一个当初我们学习数组时的知识点，那就是所有的数组在内存中的存储方式都和一维数组一样，所以，所有维的数组都可以通过一维数组改变而成，现在我来给出一个公式：

arr[i][j] == arr[i*maxCol+j]    //这里的==是等价于的意思

那么，为什么我要讲到这个面试题呢？其实细心的同学可能已经发现了，矩阵其实就是一个二维数组

现在有了之前的铺垫，我们就开始实现一下矩阵吧。
首先，还是编写"mec.h"头文件：

#ifndef _MEC_H_
#define _MEC_H_

typedef unsigned char boolean;
typedef boolean u8;

#define TRUE        1
#define FALSE       0

#define SET(v, i) (v |= (1 << ((i) ^ 7)))
#define CLR(v, i) (v &= ~(1 << ((i) ^ 7)))
#define GET(v, i) (((v) & (1 << ((i) ^ 7))) != 0)

#endif

结构体我们在上面已经构建过了，那么，我们就来实行处理矩阵数据的操作吧：
由我们对于矩阵的了解，对于矩阵内的数据的操作，其实也就是取数据和存数据，那么，就得先有一个矩阵，所以，要先初始化一个矩阵，那么，我们现在先编写初始化矩阵的函数：
至于返回值，因为可能会初始化失败，所以肯定是boolean型（这个类型的定义在我们自己编写的"mec.h"头文件中），而参数，就是矩阵和最多行数和最多列数

boolean initMatrix(MATRIX **matrix, int maxRow, int maxCol) {
    if (NULL == matrix || NULL != *matrix 
            || maxRow <= 0 || maxCol <= 0 || maxRow * maxCol > MAX_ROOM) {
        return FALSE;
    }

    *matrix = (MATRIX *) calloc(sizeof(MATRIX), 1);
    (*matrix)->data = (USER_TYPE *) calloc(sizeof(USER_TYPE), maxRow * maxCol);
    (*matrix)->maxRow = maxRow;
    (*matrix)->maxCol = maxCol;

    return TRUE;
}

有了初始化，就要想到销毁，所以，现在我们来编写销毁函数：

void destoryMatrix(MATRIX **matrix) {
    if (NULL == matrix || NULL == *matrix) {
        return;
    }

    free((*matrix)->data);
    free(*matrix);
    *matrix = NULL;
}

接下来就是存数据的操作了，但是，存的数据不能超出矩阵的范围，所以，我们来编写判最大行数和判最大列数的函数：

int getMaxRow(const MATRIX *matrix) {
    return NULL == matrix ? -1 : matrix->maxRow;
}

int getMaxCol(const MATRIX *matrix) {
    return NULL == matrix ? -1 : matrix->maxCol;
}

万事俱备，我们来编写存数据的函数：

boolean setElementAt(const MATRIX *matrix, int row, int col, const USER_TYPE value) {
    if (NULL == matrix 
            || row < 0 || row > matrix->maxRow
            || col < 0 || col > matrix->maxCol) {
        return FALSE;
    }

    matrix->data[row * matrix->maxCol + col] = value;

    return TRUE;
}

最后就是取数据函数：
关于参数得说明一点，因为返回值为boolean 型（判断操作是否正确），所以要用一个USER_TYPE *类型的参数将最终取出的值“返回”到主函数中

boolean getElementAt(const MATRIX *matrix, int row, int col, USER_TYPE *value) {
    if (NULL == matrix 
            || row < 0 || row > matrix->maxRow
            || col < 0 || col > matrix->maxCol) {
        return FALSE;
    }

    *value = matrix->data[row * matrix->maxCol + col];

    return TRUE;
}

那么现在来总结下：
mec.h:

#ifndef _MEC_H_
#define _MEC_H_

typedef unsigned char boolean;

#define TRUE        1
#define FALSE       0

#define SET(v, i) (v |= (1 << ((i) ^ 7)))
#define CLR(v, i) (v &= ~(1 << ((i) ^ 7)))
#define GET(v, i) (((v) & (1 << ((i) ^ 7))) != 0)

#endif

matrix.h:

#ifndef _MEC_MATRIX_H_
#define _MEC_MATRIX_H_

#include "mec.h"

typedef int USER_TYPE;             // 若需要其他类型，可更改用户类型。

typedef struct MATRIX {
    USER_TYPE *data;
    int maxRow;
    int maxCol;
}MATRIX;

#define MAX_ROOM 100000

boolean initMatrix(MATRIX **matrix, int maxRow, int maxCol);
void destoryMatrix(MATRIX **matrix);
int getMaxRow(const MATRIX *matrix);
int getMaxCol(const MATRIX *matrix);
boolean getElementAt(const MATRIX *matrix, int row, int col, USER_TYPE *value);
boolean setElementAt(const MATRIX *matrix, int row, int col, const USER_TYPE value);

#endif

matrix.c:

#include <stdio.h>
#include <malloc.h>

#include "mec.h"

boolean initMatrix(MATRIX **matrix, int maxRow, int maxCol) {
    if (NULL == matrix || NULL != *matrix 
            || maxRow <= 0 || maxCol <= 0 || maxRow * maxCol > MAX_ROOM) {
        return FALSE;
    }

    *matrix = (MATRIX *) calloc(sizeof(MATRIX), 1);
    (*matrix)->data = (USER_TYPE *) calloc(sizeof(USER_TYPE), maxRow * maxCol);
    (*matrix)->maxRow = maxRow;
    (*matrix)->maxCol = maxCol;

    return TRUE;
}

void destoryMatrix(MATRIX **matrix) {
    if (NULL == matrix || NULL == *matrix) {
        return;
    }

    free((*matrix)->data);
    free(*matrix);
    *matrix = NULL;
}

int getMaxRow(const MATRIX *matrix) {
    return NULL == matrix ? -1 : matrix->maxRow;
}

int getMaxCol(const MATRIX *matrix) {
    return NULL == matrix ? -1 : matrix->maxCol;
}

boolean getElementAt(const MATRIX *matrix, int row, int col, USER_TYPE *value) {
    if (NULL == matrix 
            || row < 0 || row > matrix->maxRow
            || col < 0 || col > matrix->maxCol) {
        return FALSE;
    }

    *value = matrix->data[row * matrix->maxCol + col];

    return TRUE;
}

boolean setElementAt(const MATRIX *matrix, int row, int col, const USER_TYPE value) {
    if (NULL == matrix 
            || row < 0 || row > matrix->maxRow
            || col < 0 || col > matrix->maxCol) {
        return FALSE;
    }

    matrix->data[row * matrix->maxCol + col] = value;

    return TRUE;
}

那么，矩阵的基本操作完成了，我现在来介绍矩阵中一种很常用的类型———稀疏矩阵
稀疏矩阵：

满足这样条件的矩阵，被称为是“稀疏矩阵”
稀疏矩阵的存储方式有两种：十字交叉链表，三元组存储方式
这篇博文主要来介绍三元组存储方式稀疏矩阵的部分数据处理方式。

首先，构建结构体：

typedef struct TRIPLE {              //这个结构体用于存储矩阵内一个元素的所有信息
    int row;             //存储行数
    int col;             //存储列数
    int value;           //存储矩阵指定位置的值
}TRIPLE;

typedef struct SPARSE_MATRIX {       //这个结构体用于存储矩阵内所有信息
    TRIPLE *triple;
    int maxRow;
    int maxCol;
    int valueCount;       //这个成员用于存储有效元素个数
}SPARSE_MATRIX;

那么，和上面的操作类似，我们先编写初始化稀疏矩阵的函数：

SPARSE_MATRIX *createSparseMatrix() {
    SPARSE_MATRIX *sm = NULL;
    int maxRow;
    int maxCol;
    int valueCount;
    int index;

    int row;
    int col;
    int value;

    sm = (SPARSE_MATRIX *) calloc(sizeof(SPARSE_MATRIX), 1);
    printf("请输入稀疏矩阵的行阶、列阶和有效元素个数:");
    scanf("%d %d %d", &maxRow, &maxCol, &valueCount);

    sm->maxRow = maxRow;
    sm->maxCol = maxCol;
    sm->valueCount = valueCount;
    sm->triple = (TRIPLE *) calloc(sizeof(TRIPLE), valueCount);

    printf("下面输入%d个有效元素的三元组数值(行下标 列下标 值):\n", valueCount);
    for (index = 0; index < valueCount; index++) {
        scanf("%d %d %d", &row, &col, &value);
        sm->triple[index].row = row;
        sm->triple[index].col = col;
        sm->triple[index].value = value;
    }

    return sm;
}

再来编写销毁矩阵的函数：

void destorySparseMatrix(SPARSE_MATRIX **sm) {
    free((*sm)->triple);
    free(*sm);
    *sm = NULL;
}

在这里我们就不进行取数和存储的操作了，我们来编写一个新函数——矩阵转置函数：
因为这个函数是本篇博文中最具技巧性的函数，所以，在编写这个函数前，本人先来讲述下这个功能函数的基本实现步骤：
我们先根据原矩阵的信息，得到一个“下标”数组——这个数组存储的是转置后的矩阵的每一个元素的所在数组空间的下标。
那么，我们如何得到这个数组呢？
我们先通过遍历原矩阵，找到转置后矩阵的每行(原矩阵每列)元素的个数，通过这些个数，将新矩阵每行第一个元素所在数组中的下标记录在我们申请的下标数组中；
然后从原矩阵数组的第一个元素开始，按顺序将每个元素写入新矩阵的数组中，并且每放置一个数，就要将它在下标数组对应的下标加一，以便本行之后的数通过下标数组存入新矩阵数组中。

SPARSE_MATRIX *revangeMatrix(const SPARSE_MATRIX *sm) {
    int *index;
    int i;
    SPARSE_MATRIX *result = NULL;
    int tempIndex;

    result = (SPARSE_MATRIX *) calloc(sizeof(SPARSE_MATRIX), 1);
    result->triple = (TRIPLE *) calloc(sizeof(TRIPLE), sm->valueCount);

    result->maxRow = sm->maxCol;
    result->maxCol = sm->maxRow;
    result->valueCount = sm->valueCount;

    index = (int *) calloc(sizeof(int), sm->maxCol + 1);
    
    //根据原矩阵的信息，得到下标数组
    for (i = 0; i < sm->valueCount; i++) {
        index[sm->triple[i].col + 1]++;
    }
    for (i = 1; i < sm->maxCol + 1; i++) {
        index[i] += index[i-1];
    }

    //将各元素放入新矩阵数组中
    for (i = 0; i < sm->valueCount; i++) {
        tempIndex = sm->triple[i].col;
        result->triple[index[tempIndex]].row = sm->triple[i].col;
        result->triple[index[tempIndex]].col = sm->triple[i].row;
        result->triple[index[tempIndex]].value = sm->triple[i].value;
        index[tempIndex]++;
    }

    free(index);

    return result;
}

接下来，我们来编写展示矩阵的函数：

void showMatrix(const SPARSE_MATRIX *sm) {
    int row;
    int col;
    int index = 0;

    for (row = 0; row < sm->maxRow; row++) {
        for (col = 0; col < sm->maxCol; col++) {
            printf("%4d ", sm->triple[index].row == row && sm->triple[index].col == col 
                ? sm->triple[index++].value : 0);
        }
        printf("\n");
    }

}

现在我们来总结一下：
sparseMatrix.h:

#ifndef _MEC_SPARSE_MATRIX_H_
#define _MEC_SPARSE_MATRIX_H_

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

typedef struct SPARSE_MATRIX {
    TRIPLE *triple;
    int maxRow;
    int maxCol;
    int valueCount;
}SPARSE_MATRIX;

SPARSE_MATRIX *createSparseMatrix();
void destorySparseMatrix(SPARSE_MATRIX **sm);
void showMatrix(const SPARSE_MATRIX *sm);
SPARSE_MATRIX *revangeMatrix(const SPARSE_MATRIX *sm);

#endif

sparseMatrix.c:

#include <stdio.h>
#include <malloc.h>

#include "sparseMatrix.h"

SPARSE_MATRIX *createSparseMatrix() {
    SPARSE_MATRIX *sm = NULL;
    int maxRow;
    int maxCol;
    int valueCount;
    int index;

    int row;
    int col;
    int value;

    sm = (SPARSE_MATRIX *) calloc(sizeof(SPARSE_MATRIX), 1);
    printf("请输入稀疏矩阵的行阶、列阶和有效元素个数:");
    scanf("%d %d %d", &maxRow, &maxCol, &valueCount);

    sm->maxRow = maxRow;
    sm->maxCol = maxCol;
    sm->valueCount = valueCount;
    sm->triple = (TRIPLE *) calloc(sizeof(TRIPLE), valueCount);

    printf("下面输入%d个有效元素的三元组数值(行下标 列下标 值):\n", valueCount);
    for (index = 0; index < valueCount; index++) {
        scanf("%d %d %d", &row, &col, &value);
        sm->triple[index].row = row;
        sm->triple[index].col = col;
        sm->triple[index].value = value;
    }

    return sm;
}

void destorySparseMatrix(SPARSE_MATRIX **sm) {
    free((*sm)->triple);
    free(*sm);
    *sm = NULL;
}

void showMatrix(const SPARSE_MATRIX *sm) {
    int row;
    int col;
    int index = 0;

    for (row = 0; row < sm->maxRow; row++) {
        for (col = 0; col < sm->maxCol; col++) {
            printf("%4d ", sm->triple[index].row == row && sm->triple[index].col == col 
                ? sm->triple[index++].value : 0);
        }
        printf("\n");
    }

}

SPARSE_MATRIX *revangeMatrix(const SPARSE_MATRIX *sm) {
    int *index;
    int i;
    SPARSE_MATRIX *result = NULL;
    int tempIndex;

    result = (SPARSE_MATRIX *) calloc(sizeof(SPARSE_MATRIX), 1);
    result->triple = (TRIPLE *) calloc(sizeof(TRIPLE), sm->valueCount);

    result->maxRow = sm->maxCol;
    result->maxCol = sm->maxRow;
    result->valueCount = sm->valueCount;

    index = (int *) calloc(sizeof(int), sm->maxCol + 1);

    for (i = 0; i < sm->valueCount; i++) {
        index[sm->triple[i].col + 1]++;
    }
    for (i = 1; i < sm->maxCol + 1; i++) {
        index[i] += index[i-1];
    }

    for (i = 0; i < sm->valueCount; i++) {
        tempIndex = sm->triple[i].col;
        result->triple[index[tempIndex]].row = sm->triple[i].col;
        result->triple[index[tempIndex]].col = sm->triple[i].row;
        result->triple[index[tempIndex]].value = sm->triple[i].value;
        index[tempIndex]++;
    }

    free(index);

    return result;
}

本人这篇博文编写的所有函数都是工具函数，属于最常用的几种处理操作。
希望正在学习矩阵的同学看到这篇博文能够有所收获。