C++编写矩阵的相关算法

---

前言

矩阵类和矩阵的相关操作类。
语言：C++

---

代码

#include <iostream>
#include <iomanip>
#include <vector>
#include <math.h>
using namespace std;
using std::vector;
/*矩阵类*/
class Matrix
{
public:
    //构造函数
    Matrix()
    {
        cout << "矩阵类创建成功！" << endl;
    }
    //创建矩阵
    float **createMatrix(int N, float arr[])
    {
        float **newMatrix = new float *[N];
        for (int i = 0; i < N; i++)
        {
            newMatrix[i] = new float[N];
        }
        for (int i = 0; i < N; i++)
        {
            for (int j = 0; j < N; j++)
            {
                newMatrix[i][j] = arr[N * i + j];
            }
        }
        return newMatrix;
    }
};
/*矩阵操作类*/
class MatrixOperator
{
public:
    //构造函数
    MatrixOperator()
    {
        cout << "矩阵操作类创建成功！" << endl;
    }
    //打印矩阵
    void printMatrix(float **matrix, int N)
    {
        for (int i = 0; i < N; i++)
        {
            for (int j = 0; j < N; j++)
            {
                cout << setw(10) << matrix[i][j];
            }
            cout << endl;
        }
    }
    //求某个元素的代数余子式矩阵
    float **yuzishi(float **matrix, int N, int row, int col)
    {
        float **res = new float *[N - 1];
        for (int i = 0; i < N - 1; i++)
        {
            res[i] = new float[N - 1];
        }
        //定义一个存余项的向量
        vector<int> ivec;
        for (int i = 0; i < N; i++)
        {
            for (int j = 0; j < N; j++)
            {
                if (i != row && j != col)
                {
                    ivec.push_back(matrix[i][j]);
                }
            }
        }
        float indexOfIvec = 0.0;
        for (int i = 0; i < N - 1; i++)
        {
            for (int j = 0; j < N - 1; j++)
            {
                res[i][j] = ivec[indexOfIvec];
                indexOfIvec++;
            }
        }
        return res;
    }
    //计算矩阵对应的行列式的值，代数余子式法
    float matrixValue(float **matrix, int N)
    {
        if (N == 0)
        {
            return -1;
        }
        if (N == 1)
        {
            return matrix[0][0];
        }
        if (N == 2)
        {
            return matrix[0][0] * matrix[1][1] - matrix[1][0] * matrix[0][1];
        }
        //当N（阶数）>2时，可以用行列式第一行每个数乘以（-1）^（行数+列数）乘以余子式的值,再加起来即为最终的值
        float res = 0;
        for (int j = 0; j < N; j++)
        {
            res = res + matrix[0][j] * pow(-1, 0 + j) * matrixValue(yuzishi(matrix, N, 0, j), N - 1);
        }
        return res;
    }
    //求一个矩阵的逆矩阵
    float **matrixInverse(float **matrixInput, int N)
    {
        //若矩阵对应行列式的值为0，则该矩阵没有逆矩阵
        if (matrixValue(matrixInput, N) == 0)
        {
            cout << "该矩阵不存在逆矩阵！" << endl;
        }
        //创建一个新矩阵接收输入的矩阵，以免后续操作改变原输入的矩阵
        float **matrix = new float *[N];
        for (int i = 0; i < N; i++)
        {
            matrix[i] = new float[N];
        }
        for (int i = 0; i < N; i++)
        {
            for (int j = 0; j < N; j++)
            {
                matrix[i][j] = matrixInput[i][j];
            }
        }
        for (int i = 0; i < N; i++)
        {
            for (int j = 0; j < N; j++)
            {
                if ((i == j && matrix[i][j] == 1.0) && (i != j && matrix[i][j] == 0.0))
                {
                    return matrix;
                }
            }
        }

        //后接相同大小的单位矩阵
        float **res = new float *[N];
        for (int i = 0; i < N; i++)
        {
            res[i] = new float[N];
        }
        for (int i = 0; i < N; i++)
        {
            for (int j = 0; j < N; j++)
            {
                res[i][j] = (i == j) ? (float)1 : 0;
            }
        }
        //处理首元素
        if (matrix[0][0] == 0.0)
        {
            for (int i = 0; i < N; i++)
            {
                if (matrix[i][0] != 0.0)
                {
                    //交换
                    for (int j = 0; j < N; j++)
                    {
                        float temp = matrix[0][j];
                        matrix[0][j] = matrix[i][j];
                        matrix[i][j] = temp;

                        float temp2 = res[0][j];
                        res[0][j] = res[i][j];
                        res[i][j] = temp2;
                    }
                    break;
                }
            }
        }

        //化成上三角行列式
        for (int k = 0; k < N - 1; k++)
        {
            for (int i = k + 1; i < N; i++)
            {
                for (int j = 0; j < N; j++)
                {
                    if (j == k)
                    {
                        continue;
                    }
                    else
                    {
                        res[i][j] = res[i][j] + (-1 * (matrix[i][k] / matrix[k][k]) * res[k][j]);
                        matrix[i][j] = matrix[i][j] + (-1 * (matrix[i][k] / matrix[k][k]) * matrix[k][j]);
                    }
                }
                res[i][k] = res[i][k] + (-1 * (matrix[i][k] / matrix[k][k]) * res[k][k]);
                matrix[i][k] = matrix[i][k] + (-1 * (matrix[i][k] / matrix[k][k]) * matrix[k][k]);
            }
        }

        //除了主元外，其余项也化为0
        for (int k = 0; k < N - 1; k++)
        {
            for (int i = N - 2 - k; i >= 0; i--)
            {
                for (int j = N - 1; j >= 0; j--)
                {
                    if (j == N - k - 1)
                    {
                        continue;
                    }
                    else
                    {
                        res[i][j] = res[i][j] + (-1 * (matrix[i][N - k - 1] / matrix[N - k - 1][N - k - 1]) * res[N - k - 1][j]);
                        matrix[i][j] = matrix[i][j] + (-1 * (matrix[i][N - k - 1] / matrix[N - k - 1][N - k - 1]) * matrix[N - k - 1][j]);
                    }
                }
                res[i][N - k - 1] = res[i][N - k - 1] + (-1 * (matrix[i][N - k - 1] / matrix[N - k - 1][N - k - 1]) * res[N - k - 1][N - k - 1]);
                matrix[i][N - k - 1] = matrix[i][N - k - 1] + (-1 * (matrix[i][N - k - 1] / matrix[N - k - 1][N - k - 1]) * matrix[N - k - 1][N - k - 1]);
            }
        }

        //最后一步，将矩阵化成单位矩阵
        for (int i = 0; i < N; i++)
        {
            for (int j = 0; j < N; j++)
            {
                if (j == i)
                {
                    continue;
                }
                else
                {
                    res[i][j] = res[i][j] / matrix[i][i];
                    matrix[i][j] = matrix[i][j] / matrix[i][i];
                }
            }
            res[i][i] = res[i][i] / matrix[i][i];
            matrix[i][i] = matrix[i][i] / matrix[i][i];
        }
        return res;
    }
    //矩阵相加
    float **matrixAdd(float **matrix1, float **matrix2, int N)
    {
        float **resMatrix = new float *[N];
        for (int i = 0; i < N; i++)
        {
            resMatrix[i] = new float[N];
        }
        for (int i = 0; i < N; i++)
        {
            for (int j = 0; j < N; j++)
            {
                resMatrix[i][j] = matrix1[i][j] + matrix2[i][j];
            }
        }
        return resMatrix;
    }
    //矩阵相减
    float **matrixSub(float **matrix1, float **matrix2, int N)
    {
        float **resMatrix = new float *[N];
        for (int i = 0; i < N; i++)
        {
            resMatrix[i] = new float[N];
        }
        for (int i = 0; i < N; i++)
        {
            for (int j = 0; j < N; j++)
            {
                resMatrix[i][j] = matrix1[i][j] - matrix2[i][j];
            }
        }
        return resMatrix;
    }
    //矩阵相乘
    float **matrixMutliply(float **matrix1, float **matrix2, int N)
    {
        float **resMatrix = new float *[N];
        for (int i = 0; i < N; i++)
        {
            resMatrix[i] = new float[N];
        }
        for (int i = 0; i < N; i++)
        {
            for (int j = 0; j < N; j++)
            {
                resMatrix[i][j] = 0.0;
                for (int k = 0; k < N; k++)
                {
                    resMatrix[i][j] = resMatrix[i][j] + matrix1[i][k] * matrix2[k][j];
                }
            }
        }
        return resMatrix;
    }
    //矩阵相除
    float **matrixDivide(float **matrix1, float **matrix2, int N)
    {
        //矩阵相除等于矩阵1乘以矩阵2的逆矩阵
        float **matrixInverseOfMatrix2 = matrixInverse(matrix2, 2);
        return matrixMutliply(matrix1, matrixInverseOfMatrix2, 2);
    }
};
/*主函数*/
int main()
{
    MatrixOperator mOp;
    Matrix m;
    float arr1[] = {1.0, 2.0, 3.0, 4.0};
    float **matrix1 = m.createMatrix(2, arr1);
    cout << "矩阵1为：" << endl;
    mOp.printMatrix(matrix1, 2);

    float arr2[] = {5.0, 6.0, 7.0, 8.0};
    float **matrix2 = m.createMatrix(2, arr2);
    cout << "矩阵2为：" << endl;
    mOp.printMatrix(matrix2, 2);

    float arr3[] = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 10.0};
    float **matrix3 = m.createMatrix(3, arr3);
    cout << "矩阵3为：" << endl;
    mOp.printMatrix(matrix3, 3);

    float valueOfMatrix1 = mOp.matrixValue(matrix1, 2);
    cout << "矩阵1对应的行列式的值为：" << valueOfMatrix1 << endl;

    float **inverseOfmatrix2 = mOp.matrixInverse(matrix2, 2);
    cout << "矩阵2的逆矩阵为：" << endl;
    mOp.printMatrix(inverseOfmatrix2, 2);

    float **inverseOfmatrix3 = mOp.matrixInverse(matrix3, 3);
    cout << "矩阵3的逆矩阵为：" << endl;
    mOp.printMatrix(inverseOfmatrix3, 3);

    float **matrixOfAdd = mOp.matrixAdd(matrix1, matrix2, 2);
    cout << "矩阵1和矩阵2相加结果：" << endl;
    mOp.printMatrix(matrixOfAdd, 2);

    float **matrixOfSub = mOp.matrixSub(matrix1, matrix2, 2);
    cout << "矩阵1和矩阵2相减结果：" << endl;
    mOp.printMatrix(matrixOfSub, 2);

    float **matrixOfMultiply = mOp.matrixMutliply(matrix1, matrix2, 2);
    cout << "矩阵1和矩阵2相乘结果：" << endl;
    mOp.printMatrix(matrixOfMultiply, 2);

    float **matrixOfDivide = mOp.matrixDivide(matrixOfMultiply, matrix2, 2);
    cout << "矩阵matrixOfMultiply和矩阵2相除的结果为：(应该为矩阵1)" << endl;
    mOp.printMatrix(matrixOfDivide, 2);

    system("pause");
    return 0;
}

输出结果

矩阵操作类创建成功！
矩阵类创建成功！
矩阵1为：
         1         2
         3         4
矩阵2为：
         5         6
         7         8
矩阵3为：
         1         2         3
         4         5         6
         7         8        10
矩阵1对应的行列式的值为：-2
矩阵2的逆矩阵为：
        -4         3
       3.5      -2.5
矩阵3的逆矩阵为：
 -0.666667  -1.33333         1
 -0.666667   3.66667        -2
         1        -2         1
矩阵1和矩阵2相加结果：
         6         8
        10        12
矩阵1和矩阵2相减结果：
        -4        -4
        -4        -4
矩阵1和矩阵2相乘结果：
        19        22
        43        50
矩阵matrixOfMultiply和矩阵2相除的结果为：(应该为矩阵1)
         1         2
         3         4
请按任意键继续. . .