C++矩阵基本操作

最新推荐文章于 2026-05-22 15:24:47 发布
原创 最新推荐文章于 2026-05-22 15:24:47 发布 · 791 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测

#ifndef WPC_H  
#define WPC_H  
#include <iostream>  
#include <vector>  
#include <string>  
#include <ctime> 
#include<map>
#include<random>
#include <thread>
#include <mutex>
#include <utility>
#include<stack>
#include<queue>
#include<set>
#include <algorithm>  
#include <exception>  
#include <typeinfo>
#include<cmath>
#include <chrono>
#include <cstdlib> 
#include<cstdio>
//本库不需要其他C++第三方库,只需要     C++ STL标准库，各种c库，其他内置库
///  本库仅仅在符合如下条件的环境下通过测试：
//   C++标准：C++ 14   C++17    C++20
//   x64
//   Debug/Release
//   Windows 11
//   Visual Studio profession 2022    (未在vscode测试过)
//  本库不兼容C++20 或C++23新增加内容
//  编译器: mingw
//  暂不支持英伟达等显卡加速
//为了保证数据安全性本库基本不提供对任何原始数据直接操作的函数
//=================================================================================================================================================================
template <typename T>//矩阵元素可以为任意类型
class juzhen {//矩阵类
private:
    int hanshu;//行数
    int lieshu;//列数
    std::vector<std::vector<T>> data;//数据

public:
    juzhen(int hanshu, int lieshu) : hanshu(hanshu), lieshu(lieshu), data(hanshu, std::vector<T>(lieshu)) {}
    int juzhen_hanshu() const {
        return hanshu;
    }

    int juzhen_lieshu() const {
        return lieshu;
    }
    //重载符号[],方便通过下标访问矩阵合法元素
    const std::vector<T>& operator[](int index) const {
        if (index < 0 || index >= hanshu) {
            throw std::out_of_range("超出矩阵边界");
        }
        return data[index];
    }

    std::vector<T>& operator[](int index) {
        if (index < 0 || index >= hanshu) {
            throw std::out_of_range("超出矩阵边界");
        }
        return data[index];
    }
    //重载符号(),方便通过下标访问矩阵合法元素
    const T& operator()(int i, int j) const {
        if (i < 0 || i >= hanshu || j < 0 || j >= lieshu) {
            throw std::out_of_range("超出矩阵边界");
        }
        return data[i][j];
    }
    T& operator()(int i, int j) {
        if (i < 0 || i >= hanshu || j < 0 || j >= lieshu) {
            throw std::out_of_range("超出矩阵边界");
        }
        return data[i][j];
    }
    //juzhen类判断是否合法  注意不是juzhen_2D
    bool panduan() {
        int p = 1;
        if (!data.empty()) {
            for (int i = 0; i != hanshu; i++) {
                if (data[i].size() != lieshu || data[i].empty())p = 0;
                break;
            }
        }
        return (p != 0);
    }

    //模仿python中.append()函数      但需要指定坐标   如   l.append(i,j,k) 意思为l[i][j]=k,而不是python的添加功能
    void append(int i, int j, const T& value) {
        if (i < 0 || i >= hanshu || j < 0 || j >= lieshu) {
            throw std::out_of_range("超出矩阵边界");
        }
        data[i][j] = (value);
    }
    //只可以用于juzhen 类矩阵
    void juzhen_print() {
        for (int i = 0; i != hanshu; i++) {
            for (int j = 0; j != lieshu; j++) {
                std::cout << data[i][j] << " ";
            }
            std::cout << std::endl;
        }
    }
    //矩阵元素初始化为任意类型(T)  x
    void chushihua(const T x) {
        if (!data.empty()) {
            for (int i = 0; i != hanshu; i++) {
                for (int j = 0; j != lieshu; j++) {
                    data[i][j] = x;
                }

            }
        }
    }


};

//-----------------------------------------------------------------------------------------------------------------------------------------------------
//==========================================================================================================================================================

//==========================================================================================================================================================
// 
// 
//与juzhen类不同的是,juzhen_2D_  系列函数是指类型为std::vector<std::vector<T>  的二维数组，使得操作跟灵活,而juzhen类矩阵必须初始化矩阵行数，列数
template <typename T>
bool juzhen_2D_panduan(std::vector<std::vector<T>>& x) {
    if (x.empty())return false;
    int p = 1;
    for (int i = 1; i != x.size(); i++) {
        if (x[i].size() != x[0].size())p = 0;
        break;
    }
    return p != 0;
}
//juzhen_2D行数
template <typename T>
int juzhen_2D_hanshu(std::vector<std::vector<T>>& x) {
    if (juzhen_2D_panduan(x) == false)return -1;
    int sum = 0;
    for (int i = 0; i != x.size(); i++) {
        sum++;
    }
    return sum;

}
//juzhen_2D列数
template <typename T>
int juzhen_2D_lieshu(std::vector<std::vector<T>>& x) {
    if (juzhen_2D_panduan(x) == false)return -1;
    int sum = 0;
    for (int i = 0; i != x[0].size(); i++) {
        sum++;
    }
    return sum;
}
//矩阵初始化 创造一个 m*n 矩阵  所有元素设置为zhi(任意类型)
template <typename T>
std::vector<std::vector<T>> juzhen_chushihua(int m, int n, T zhi) {
    if (m <= 0 || n <= 0)return{ {0} };
    std::vector<std::vector<T>> l;
    std::vector<T> t;
    for (int i = 0; i != m; i++) {
        for (int j = 0; j != n; j++) {
            t.push_back(zhi);
        }
        l.push_back(t);
        t.clear();
    }
    return l;
}
//将juzhen_2D转换为juzhen类矩阵
template <typename T>
juzhen<T> juzhen_fuzhi(std::vector<std::vector<T>>& x) {
    int a = vector_2D_hanshu(x);
    int b = vector_2D_lieshu(x);
    juzhen<T> l(a, b);
    for (int i = 0; i != a; i++) {
        for (int j = 0; j != b; j++) {
            l.append(i, j, x[i][j]);
        }
    }
    return l;
}
//juzhen_2D单位矩阵
std::vector<std::vector<int>> juzhen_2D_danweijuzhen(int n) {
    if (n <= 0)return { {0} };
    std::vector<int> t;
    std::vector<std::vector<int>> l;
    for (int i = 0; i != n; i++) {
        for (int j = 0; j != n; j++) {
            if (j == i) {
                t.push_back(1);
            }
            else {
                t.push_back(0);
            }
        }
        l.push_back(t);
        t.clear();
    }
    return l;
}
template <typename T>
//矩阵归一化，控制均值，标准差
std::vector<std::vector<T>> juzhen_guiyihua(std::vector<std::vector<T>>& x, T junzhi, T biaozhuncha) {
    if (juzhen_2D_panduan(x) == false) {
        std::cout << "输入矩阵不合法" << std::endl;
        return { {0} };
    }
    int m = juzhen_2D_hanshu(x);
    int n = juzhen_2D_lieshu(x);
    double sum, Sum;
    sum = 0.0;
    Sum = 0.0;
    for (int i = 0; i != m; i++) {
        for (int j = 0; j != n; j++) {
            sum += x[i][j];
            Sum += x[i][j] * x[i][j];
        }
    }
    std::vector<int> t;
    std::vector<std::vector<int>> l;
    double jj = sum / m * n;
    if (abs(jj - junzhi) >= 1e-5) {
        for (int s = 0; s != m; s++) {
            for (int f = 0; f != n; f++) {
                t.push_back(x[s][f] * (junzhi / jj));
            }
            l.push_back(t);
            t.clear();
        }
        return l;
    }
    double aa = sqrt(Sum/m*n - jj * jj);
    if (abs(aa - biaozhuncha) > 1e-5) {
        for (int s = 0; s != m; s++) {
            for (int f = 0; f != n; f++) {
                t.push_back(x[s][f] * (junzhi / jj));
            }
            l.push_back(t);
            t.clear();
        }
        return l;
    }
    return x;
}

//仅仅适合juzhen类矩阵
juzhen<int> juzhen_danweijuzhen(int n) {
    juzhen<int> cuo(1, 1);
    cuo.append(0, 0, 0);
    if (n <= 0) {
        return cuo;
    }
    juzhen<int> l(n, n);
    for (int i = 0; i != n; i++) {
        l.append(i, i, 1);
    }
    return l;
}

template <typename T>
juzhen<T> juzhen_zhuanzhi(juzhen<T>& x) {
    juzhen<int> cuo(1, 1);
    cuo.append(0, 0, 0);
    if (x.panduan() == false)return cuo;
    int m = x.juzhen_hanshu();
    int n = x.juzhen_lieshu();
    juzhen<int> l(n, m);
    for (int j = 0; j != n; j++) {
        for (int i = 0; i != m; i++) {
            l.append(j, i, x[i][j]);
        }
    }
    return l;

}
//坐标合法  
template <typename T>
bool zuobiao_hefa(juzhen<T>& x, std::vector<int>& zuobiao) {
    if (x.panduan() == false || zuobiao.size() != 2 || zuobiao[0] < 0 || zuobiao[0] >= x.juzhen_hanshu() || zuobiao[1] < 0 || zuobiao[1] >= x.juzhen_lieshu()) {
        return false;
    }
    return true;
}

//抓取矩阵同列元素   如抓取第1列 ，第2行至第5行 所有元素，以vector<T> 类型返回函数值   
template <typename T>
std::vector<T> juzhen_zhuaqu_tonlie(juzhen<T>& x, std::vector<int>& zuobiao1, std::vector<int>& zuobiao2) {

    if (x.panduan() == false || zuobiao_hefa(x, zuobiao1) == false || zuobiao_hefa(x, zuobiao2) == false || zuobiao1[1] != zuobiao2[1]) return { 0 };
    std::vector<T> l;
    if (zuobiao1[0] <= zuobiao2[0]) {
        for (int i = zuobiao1[0]; i <= zuobiao2[0]; i++) {
            l.push_back(x[i][zuobiao1[1]]);
        }
    }
    if (zuobiao1[0] > zuobiao2[0]) {
        for (int j = zuobiao2[0]; j >= zuobiao1[0]; j--) {
            l.push_back(x[j][zuobiao1[1]]);
        }
    }
    return l;

}
//juzhen_2D 的初始化，指定行数(int)，列数(int)，任意类型数值x(T)
template <typename T>
std::vector<std::vector<T>> juzhen_2D_chushihua(int m,int n,T x) {
    if (m<=0 || n <= 0) {
        std::cout << "输入不合法，请重新输入" << std::endl;
        return { {0} };
    }
    std::vector<std::vector<T> >l;
    std::vector<T> t;
    for (int i = 0; i != m; i++) {
        for (int j = 0; j != n; j++) {
            t.push_back(x);
        }
        l.push_back(t);
        t.clear();
    }
    return l;
}
//将矩阵元素分类
template <typename T>
std::vector<std::vector<T>> fenlei(std::vector<T>& x) {
    std::set<T> t;
    for (const auto& elem : x) {
        t.insert(elem);
    }

    std::map<T, int> counts;//整数，浮点数，字符串可以组成对
    for (const auto& elem : x) {
        counts[elem]++;
    }

    std::vector<std::vector<T>> result;
    for (const auto& pair : counts) {
        result.push_back({ pair.first, pair.second });
    }

    return result;
}
//矩阵元素随机配对 :  n对
//随机从矩阵中获取两个合法且不同的元素坐标,保存在一个二维数组容器内
std::vector<std::vector<int>> juzhen_yuansu_suijipeidui(juzhen<int>& x, int n) {
    if (x.panduan() == false || n <= 0)return { {0} };
    int a = 0;  // 区间下限    
    int b = x.juzhen_hanshu() - 1;  
    int m = x.juzhen_lieshu() - 1;  

    std::random_device rd; // 用于获取随机数种子    
    std::mt19937 gen(rd()); // 使用Mersenne Twister算法生成随机数    
    std::uniform_int_distribution<> dis(a, b); // 创建分布，范围是[a, b]    

    std::vector<std::vector<int>> result;
    for (int i = 0; i < n; i++) {
        std::vector<int> temp;
        for (int j = 0; j < 2; j++) { // 生成两个随机数  
            int random_num = dis(gen); // 生成随机数  
            temp.push_back(random_num); // 将随机数添加到temp中  
        }
        result.push_back(temp); // 将temp添加到结果中  
    }
    return result; // 返回结果 
}//待完善——————————————————————————————————————————————————————————————————---------------

/// 向量内积
template<typename T>
T xianlian_neiji(std::vector<T>& x, std::vector<T>& y) {
    if (x.empty() || y.empty() || x.size() != y.size())return { 0 };
    T sum = 0;
    for (int i = 0; i != x.size(); i++) {
        sum += x[i] * y[i];
    }
    return sum;
}
template<typename T>
//向量初始化
std::vector<T> xianlian_chushihua(int n, T zhi) {
    std::vector<T> t;
    if (n <= 0)return {0} ;
    for (int i = 0; i != n; i++) {
        t.push_back(zhi);
    }
    return t;
}

//矩阵点乘  001
template<typename T>
std::vector<std::vector<T>> juzhen_dianchen(std::vector<std::vector<T>>& x, std::vector<std::vector<T>>& y) {
    if (juzhen_2D_panduan(x) == false || juzhen_2D_panduan(y) == false || juzhen_2D_hanshu(x) != juzhen_2D_hanshu(y) || juzhen_2D_lieshu(x) != juzhen_2D_lieshu(y)) {
        std::cout << "输入矩阵不合法" << std::endl;
        return { {0} };
    }
    std::vector<std::vector<T>> l;
    std::vector<T> t;
    for (int i = 0; i != juzhen_2D_hanshu(x); i++) {
        for (int j = 0; j != juzhen_2D_lieshu(x); j++) {
            t.push_back(x[i][j] * y[i][j]);
        }
        l.push_back(t);
        t.clear();
    }
    return l;
}
//矩阵内积
template<typename T>
T juzhen_neiji(std::vector<std::vector<T>>& x, std::vector<std::vector<T>>& y) {
    std::vector<std::vector<T>> l;
    std::vector<T> t;
    T sum = 0;
    if (juzhen_2D_panduan(x) == false || juzhen_2D_panduan(y) == false ||  x.size()!=y.size() || x[0].size()!=y[0].size())return false;
    else {
        for (int i = 0; i != x.size(); i++) {
            for (int j = 0; j != x[0].size(); j++) {
                sum += x[i][j] * y[i][j];
            }
        }
        return sum;
    }
}

//矩阵乘法   001
template<typename T>
std::vector<std::vector<T>> juzhen_chenfa(std::vector<std::vector<T>>& x, std::vector<std::vector<T>>& y) {
    if (juzhen_2D_panduan(x) == false || juzhen_2D_panduan(y) == false || juzhen_2D_lieshu(x) != juzhen_2D_hanshu(y))return { {0} };
    int sum = 0;
    std::vector<T> t;
    std::vector<T> s;
    std::vector<std::vector<T>> l;
    int xl = juzhen_2D_hanshu(x);
    int xd = juzhen_2D_lieshu(x);
    int yl = juzhen_2D_hanshu(y);
    int yd = juzhen_2D_lieshu(y);
    for (int i = 0; i != xl; i++) {
        for (int j = 0; j != yd; j++) {
            for (int k = 0; k != yl; k++) {
                s.push_back(y[k][j]);
            }
            sum = xianlian_neiji(x[i], s);//向量内积
            s.clear();
            t.push_back(sum);
            sum = 0;
        }
        l.push_back(t);
        t.clear();
    }
    return l;
}
//----------------------------------------------------------------------------------------------------------------------------------
// 矩阵pad填充
//默认填充0    输入：矩阵，填充位数
template<typename T>
std::vector<std::vector<T>> juzhen_pad0(std::vector<std::vector<T>>& x, int k) {
    if (juzhen_2D_panduan(x) == false || k <= 0) {
        std::cout << "矩阵或填充层数输入错误" << std::endl;
        return { {0} };
    }
    int a = juzhen_2D_hanshu(x);
    int b = juzhen_2D_lieshu(x);
    std::vector<std::vector<T>> l;
    std::vector<T> t;
    for (int i = 0; i != a + 2*k ; i++) {
        for (int j = 0; j != b +2* k; j++) {
            if (i >= k  && i <= x.size() - 1 + k  && j>=k && j<=x[0].size()-1+k) {
                t.push_back(x[i - k][j - k]);
            }
            else {
                t.push_back(0);
            }
            
        }
        l.push_back(t);
        t.clear();
        
    }
    return l;

}

//自定义填充值，自定义填充位数
template<typename T> 
//   输入：矩阵，填充值，填充位数
std::vector<std::vector<T>> juzhen_pad(std::vector<std::vector<T>>& x, T zhi, int k) {
    if (juzhen_2D_panduan(x) == false || k <= 0) {
        std::cout << "矩阵或填充层数输入错误" << std::endl;
        return { {0} };
    }
    int a = juzhen_2D_hanshu(x);
    int b = juzhen_2D_lieshu(x);
    std::vector<std::vector<T>> l;
    std::vector<T> t;
    for (int i = 0; i != a + 2 * k; i++) {
        for (int j = 0; j != b + 2 * k; j++) {
            if (i >= k && i <= x.size() - 1 + k && j >= k && j <= x[0].size() - 1 + k) {
                t.push_back(x[i - k][j - k]);
            }
            else {
                t.push_back(zhi);
            }

        }
        l.push_back(t);
        t.clear();

    }
    return l;
}

//矩阵加法
template<typename T>
std::vector <std::vector<T>> juzhen_jiafa(std::vector<std::vector<T>>& x, std::vector<std::vector<T>>& y) {
    if (juzhen_2D_panduan(x) == false || juzhen_2D_panduan(y) == false) {
        std::cout << "输入矩阵不符合矩阵加法要求" << std::endl;
        return { {0} };
    }
    std::vector<T> t;
    std::vector<std::vector<T>> l;
    int m = juzhen_2D_hanshu(x);
    int n = juzhen_2D_lieshu(x);
    for (int i = 0; i != m; i++) {
        for (int j = 0; j != n; j++) {
            t.push_back(x[i][j] + y[i][j]);
        }
        l.push_back(t);
        t.clear();
    }
    return l;
}
//矩阵减法
template<typename T>
std::vector <std::vector<T>> juzhen_jianfa(std::vector<std::vector<T>>& x, std::vector<std::vector<T>>& y) {
    if (juzhen_2D_panduan(x) == false || juzhen_2D_panduan(y) == false) {
        std::cout << "输入矩阵不符合矩阵减法要求" << std::endl;
        return { {0} };
    }
    std::vector<T> t;
    std::vector<std::vector<T>> l;
    int m = juzhen_2D_hanshu(x);
    int n = juzhen_2D_lieshu(x);
    for (int i = 0; i != m; i++) {
        for (int j = 0; j != n; j++) {
            t.push_back(x[i][j]-y[i][j]);
        }
        l.push_back(t);
        t.clear();
    }
    return l;
}
//time 检测程序运行时间
template<typename Func>
auto time(Func&& func)
{
    auto start = std::chrono::high_resolution_clock::now();

    func();

    auto end = std::chrono::high_resolution_clock::now();

    std::chrono::duration<double> elapsed = end - start;

    std::cout << "Elapsed time: " << elapsed.count() << " seconds." << std::endl;

    return elapsed.count();
}

//命名空间python的应用, 应为   using namespace python;   或者python::   暂时不支持C++23 新增加功能

//python命名空间,提供类似python语法功能。
namespace python {
    //打印任意类型数据
    template<typename T>
    void print(T x) {
        std::cout << x << std::endl;
    }
    //print函数第2次重载,打印一维数组
    template<typename T>
    void print(const std::vector<T>& x) {
        for (int i = 0; i != x.size(); i++) {
            std::cout << x[i] << " ";
        }
        std::cout << std::endl;
    }
    //print函数第3次重载,打印二维数组
    template<typename T>
    void print(const std::vector<std::vector<T>>& x) {
        if (x.empty()) {
            std::cout << "二维数组为空" <<std::endl;
        }
        int p = 1;
        for (int k = 0; k != x.size(); k++) {
            if (x[k].empty() || x[k].size()!=x[0].size())p = 0;
            break;
        }
        if (p == 0) {
            std::cout << "输入矩阵不合法"<<std::endl;
        }
        
        for (int i = 0; i != x.size(); i++) {
            for (int j = 0; j != x[0].size(); j++) {
                std::cout << x[i][j] << " ";
           }
            std::cout << std::endl;
        }
        
    }
    //print函数第4次重载，打印矩阵类的矩阵
    template<typename T>
    void print(const juzhen<T>& x) {
        if (x.juzhen_panduan() == false) {
            std::cout << "矩阵不合法"<<std::endl;
        }
        else {
            for (int i = 0; i != x.juzhen_hanshu(); i++) {
                for (int j = 0; j != x.juzhen_lieshu(); j++) {
                    std::cout << x[i][j] << " ";
                }
                std::cout << std::endl;
            }
        }
    }
    

}
#endif 

#ifndef WPC_H  
#define WPC_H  
#include <iostream>  
#include <vector>  
#include <string>  
#include <ctime> 
#include<map>
#include<random>
#include <thread>
#include <mutex>
#include <utility>
#include<stack>
#include<queue>
#include<set>
#include <algorithm>  
#include <exception>  
#include <typeinfo>
#include<cmath>
#include <chrono>
#include <cstdlib> 
#include<cstdio>
//本库不需要其他C++第三方库,只需要     C++ STL标准库，各种c库，其他内置库
///  本库仅仅在符合如下条件的环境下通过测试：
//   C++标准：C++ 14   C++17    C++20
//   x64
//   Debug/Release
//   Windows 11
//   Visual Studio profession 2022    (未在vscode测试过)
//  本库不兼容C++20 或C++23新增加内容
//  编译器: mingw
//  暂不支持英伟达等显卡加速
//为了保证数据安全性本库基本不提供对任何原始数据直接操作的函数
//=================================================================================================================================================================
template <typename T>//矩阵元素可以为任意类型
class juzhen {//矩阵类
private:
	int hanshu;//行数
	int lieshu;//列数
	std::vector<std::vector<T>> data;//数据

public:
	juzhen(int hanshu, int lieshu) : hanshu(hanshu), lieshu(lieshu), data(hanshu, std::vector<T>(lieshu)) {}
	int juzhen_hanshu() const {
		return hanshu;
	}

	int juzhen_lieshu() const {
		return lieshu;
	}
	//重载符号[],方便通过下标访问矩阵合法元素
	const std::vector<T>& operator[](int index) const {
		if (index < 0 || index >= hanshu) {
			throw std::out_of_range("超出矩阵边界");
		}
		return data[index];
	}

	std::vector<T>& operator[](int index) {
		if (index < 0 || index >= hanshu) {
			throw std::out_of_range("超出矩阵边界");
		}
		return data[index];
	}
	//重载符号(),方便通过下标访问矩阵合法元素
	const T& operator()(int i, int j) const {
		if (i < 0 || i >= hanshu || j < 0 || j >= lieshu) {
			throw std::out_of_range("超出矩阵边界");
		}
		return data[i][j];
	}
	T& operator()(int i, int j) {
		if (i < 0 || i >= hanshu || j < 0 || j >= lieshu) {
			throw std::out_of_range("超出矩阵边界");
		}
		return data[i][j];
	}
	//juzhen类判断是否合法  注意不是juzhen_2D
	bool panduan() {
		int p = 1;
		if (!data.empty()) {
			for (int i = 0; i != hanshu; i++) {
				if (data[i].size() != lieshu || data[i].empty())p = 0;
				break;
			}
		}
		return (p != 0);
	}

	//模仿python中.append()函数      但需要指定坐标   如   l.append(i,j,k) 意思为l[i][j]=k,而不是python的添加功能
	void append(int i, int j, const T& value) {
		if (i < 0 || i >= hanshu || j < 0 || j >= lieshu) {
			throw std::out_of_range("超出矩阵边界");
		}
		data[i][j] = (value);
	}
	//只可以用于juzhen 类矩阵
	void juzhen_print() {
		for (int i = 0; i != hanshu; i++) {
			for (int j = 0; j != lieshu; j++) {
				std::cout << data[i][j] << " ";
			}
			std::cout << std::endl;
		}
	}
	//矩阵元素初始化为任意类型(T)  x
	void chushihua(const T x) {
		if (!data.empty()) {
			for (int i = 0; i != hanshu; i++) {
				for (int j = 0; j != lieshu; j++) {
					data[i][j] = x;
				}

			}
		}
	}


};

//-----------------------------------------------------------------------------------------------------------------------------------------------------
//==========================================================================================================================================================

//==========================================================================================================================================================
// 
// 
//与juzhen类不同的是,juzhen_2D_  系列函数是指类型为std::vector<std::vector<T>  的二维数组，使得操作跟灵活,而juzhen类矩阵必须初始化矩阵行数，列数
template <typename T>
bool juzhen_2D_panduan(std::vector<std::vector<T>>& x) {
	if (x.empty())return false;
	int p = 1;
	for (int i = 1; i != x.size(); i++) {
		if (x[i].size() != x[0].size())p = 0;
		break;
	}
	return p != 0;
}
//juzhen_2D行数
template <typename T>
int juzhen_2D_hanshu(std::vector<std::vector<T>>& x) {
	if (juzhen_2D_panduan(x) == false)return -1;
	int sum = 0;
	for (int i = 0; i != x.size(); i++) {
		sum++;
	}
	return sum;

}
//juzhen_2D列数
template <typename T>
int juzhen_2D_lieshu(std::vector<std::vector<T>>& x) {
	if (juzhen_2D_panduan(x) == false)return -1;
	int sum = 0;
	for (int i = 0; i != x[0].size(); i++) {
		sum++;
	}
	return sum;
}
//矩阵初始化 创造一个 m*n 矩阵  所有元素设置为zhi(任意类型)
template <typename T>
std::vector<std::vector<T>> juzhen_chushihua(int m, int n, T zhi) {
	if (m <= 0 || n <= 0)return{ {0} };
	std::vector<std::vector<T>> l;
	std::vector<T> t;
	for (int i = 0; i != m; i++) {
		for (int j = 0; j != n; j++) {
			t.push_back(zhi);
		}
		l.push_back(t);
		t.clear();
	}
	return l;
}
//将juzhen_2D转换为juzhen类矩阵
template <typename T>
juzhen<T> juzhen_fuzhi(std::vector<std::vector<T>>& x) {
	int a = vector_2D_hanshu(x);
	int b = vector_2D_lieshu(x);
	juzhen<T> l(a, b);
	for (int i = 0; i != a; i++) {
		for (int j = 0; j != b; j++) {
			l.append(i, j, x[i][j]);
		}
	}
	return l;
}
//juzhen_2D单位矩阵
std::vector<std::vector<int>> juzhen_2D_danweijuzhen(int n) {
	if (n <= 0)return { {0} };
	std::vector<int> t;
	std::vector<std::vector<int>> l;
	for (int i = 0; i != n; i++) {
		for (int j = 0; j != n; j++) {
			if (j == i) {
				t.push_back(1);
			}
			else {
				t.push_back(0);
			}
		}
		l.push_back(t);
		t.clear();
	}
	return l;
}
template <typename T>
//矩阵归一化，控制均值，标准差
std::vector<std::vector<T>> juzhen_guiyihua(std::vector<std::vector<T>>& x, T junzhi, T biaozhuncha) {
	if (juzhen_2D_panduan(x) == false) {
		std::cout << "输入矩阵不合法" << std::endl;
		return { {0} };
	}
	int m = juzhen_2D_hanshu(x);
	int n = juzhen_2D_lieshu(x);
	double sum, Sum;
	sum = 0.0;
	Sum = 0.0;
	for (int i = 0; i != m; i++) {
		for (int j = 0; j != n; j++) {
			sum += x[i][j];
			Sum += x[i][j] * x[i][j];
		}
	}
	std::vector<int> t;
	std::vector<std::vector<int>> l;
	double jj = sum / m * n;
	if (abs(jj - junzhi) >= 1e-5) {
		for (int s = 0; s != m; s++) {
			for (int f = 0; f != n; f++) {
				t.push_back(x[s][f] * (junzhi / jj));
			}
			l.push_back(t);
			t.clear();
		}
		return l;
	}
	double aa = sqrt(Sum/m*n - jj * jj);
	if (abs(aa - biaozhuncha) > 1e-5) {
		for (int s = 0; s != m; s++) {
			for (int f = 0; f != n; f++) {
				t.push_back(x[s][f] * (junzhi / jj));
			}
			l.push_back(t);
			t.clear();
		}
		return l;
	}
	return x;
}

//仅仅适合juzhen类矩阵
juzhen<int> juzhen_danweijuzhen(int n) {
	juzhen<int> cuo(1, 1);
	cuo.append(0, 0, 0);
	if (n <= 0) {
		return cuo;
	}
	juzhen<int> l(n, n);
	for (int i = 0; i != n; i++) {
		l.append(i, i, 1);
	}
	return l;
}

template <typename T>
juzhen<T> juzhen_zhuanzhi(juzhen<T>& x) {
	juzhen<int> cuo(1, 1);
	cuo.append(0, 0, 0);
	if (x.panduan() == false)return cuo;
	int m = x.juzhen_hanshu();
	int n = x.juzhen_lieshu();
	juzhen<int> l(n, m);
	for (int j = 0; j != n; j++) {
		for (int i = 0; i != m; i++) {
			l.append(j, i, x[i][j]);
		}
	}
	return l;

}
//坐标合法  
template <typename T>
bool zuobiao_hefa(juzhen<T>& x, std::vector<int>& zuobiao) {
	if (x.panduan() == false || zuobiao.size() != 2 || zuobiao[0] < 0 || zuobiao[0] >= x.juzhen_hanshu() || zuobiao[1] < 0 || zuobiao[1] >= x.juzhen_lieshu()) {
		return false;
	}
	return true;
}

//抓取矩阵同列元素   如抓取第1列 ，第2行至第5行 所有元素，以vector<T> 类型返回函数值   
template <typename T>
std::vector<T> juzhen_zhuaqu_tonlie(juzhen<T>& x, std::vector<int>& zuobiao1, std::vector<int>& zuobiao2) {

	if (x.panduan() == false || zuobiao_hefa(x, zuobiao1) == false || zuobiao_hefa(x, zuobiao2) == false || zuobiao1[1] != zuobiao2[1]) return { 0 };
	std::vector<T> l;
	if (zuobiao1[0] <= zuobiao2[0]) {
		for (int i = zuobiao1[0]; i <= zuobiao2[0]; i++) {
			l.push_back(x[i][zuobiao1[1]]);
		}
	}
	if (zuobiao1[0] > zuobiao2[0]) {
		for (int j = zuobiao2[0]; j >= zuobiao1[0]; j--) {
			l.push_back(x[j][zuobiao1[1]]);
		}
	}
	return l;

}
//juzhen_2D 的初始化，指定行数(int)，列数(int)，任意类型数值x(T)
template <typename T>
std::vector<std::vector<T>> juzhen_2D_chushihua(int m,int n,T x) {
	if (m<=0 || n <= 0) {
		std::cout << "输入不合法，请重新输入" << std::endl;
		return { {0} };
	}
	std::vector<std::vector<T> >l;
	std::vector<T> t;
	for (int i = 0; i != m; i++) {
		for (int j = 0; j != n; j++) {
			t.push_back(x);
		}
		l.push_back(t);
		t.clear();
	}
	return l;
}
//将矩阵元素分类
template <typename T>
std::vector<std::vector<T>> fenlei(std::vector<T>& x) {
	std::set<T> t;
	for (const auto& elem : x) {
		t.insert(elem);
	}

	std::map<T, int> counts;//整数，浮点数，字符串可以组成对
	for (const auto& elem : x) {
		counts[elem]++;
	}

	std::vector<std::vector<T>> result;
	for (const auto& pair : counts) {
		result.push_back({ pair.first, pair.second });
	}

	return result;
}
//矩阵元素随机配对 :  n对
//随机从矩阵中获取两个合法且不同的元素坐标,保存在一个二维数组容器内
std::vector<std::vector<int>> juzhen_yuansu_suijipeidui(juzhen<int>& x, int n) {
	if (x.panduan() == false || n <= 0)return { {0} };
	int a = 0;  // 区间下限    
	int b = x.juzhen_hanshu() - 1;  
	int m = x.juzhen_lieshu() - 1;  

	std::random_device rd; // 用于获取随机数种子    
	std::mt19937 gen(rd()); // 使用Mersenne Twister算法生成随机数    
	std::uniform_int_distribution<> dis(a, b); // 创建分布，范围是[a, b]    

	std::vector<std::vector<int>> result;
	for (int i = 0; i < n; i++) {
		std::vector<int> temp;
		for (int j = 0; j < 2; j++) { // 生成两个随机数  
			int random_num = dis(gen); // 生成随机数  
			temp.push_back(random_num); // 将随机数添加到temp中  
		}
		result.push_back(temp); // 将temp添加到结果中  
	}
	return result; // 返回结果 
}//待完善——————————————————————————————————————————————————————————————————---------------

/// 向量内积
template<typename T>
T xianlian_neiji(std::vector<T>& x, std::vector<T>& y) {
	if (x.empty() || y.empty() || x.size() != y.size())return { 0 };
	T sum = 0;
	for (int i = 0; i != x.size(); i++) {
		sum += x[i] * y[i];
	}
	return sum;
}
template<typename T>
//向量初始化
std::vector<T> xianlian_chushihua(int n, T zhi) {
	std::vector<T> t;
	if (n <= 0)return {0} ;
	for (int i = 0; i != n; i++) {
		t.push_back(zhi);
	}
	return t;
}

//矩阵点乘  001
template<typename T>
std::vector<std::vector<T>> juzhen_dianchen(std::vector<std::vector<T>>& x, std::vector<std::vector<T>>& y) {
	if (juzhen_2D_panduan(x) == false || juzhen_2D_panduan(y) == false || juzhen_2D_hanshu(x) != juzhen_2D_hanshu(y) || juzhen_2D_lieshu(x) != juzhen_2D_lieshu(y)) {
		std::cout << "输入矩阵不合法" << std::endl;
		return { {0} };
	}
	std::vector<std::vector<T>> l;
	std::vector<T> t;
	for (int i = 0; i != juzhen_2D_hanshu(x); i++) {
		for (int j = 0; j != juzhen_2D_lieshu(x); j++) {
			t.push_back(x[i][j] * y[i][j]);
		}
		l.push_back(t);
		t.clear();
	}
	return l;
}
//矩阵内积
template<typename T>
T juzhen_neiji(std::vector<std::vector<T>>& x, std::vector<std::vector<T>>& y) {
	std::vector<std::vector<T>> l;
	std::vector<T> t;
	T sum = 0;
	if (juzhen_2D_panduan(x) == false || juzhen_2D_panduan(y) == false ||  x.size()!=y.size() || x[0].size()!=y[0].size())return false;
	else {
		for (int i = 0; i != x.size(); i++) {
			for (int j = 0; j != x[0].size(); j++) {
				sum += x[i][j] * y[i][j];
			}
		}
		return sum;
	}
}

//矩阵乘法   001
template<typename T>
std::vector<std::vector<T>> juzhen_chenfa(std::vector<std::vector<T>>& x, std::vector<std::vector<T>>& y) {
	if (juzhen_2D_panduan(x) == false || juzhen_2D_panduan(y) == false || juzhen_2D_lieshu(x) != juzhen_2D_hanshu(y))return { {0} };
	int sum = 0;
	std::vector<T> t;
	std::vector<T> s;
	std::vector<std::vector<T>> l;
	int xl = juzhen_2D_hanshu(x);
	int xd = juzhen_2D_lieshu(x);
	int yl = juzhen_2D_hanshu(y);
	int yd = juzhen_2D_lieshu(y);
	for (int i = 0; i != xl; i++) {
		for (int j = 0; j != yd; j++) {
			for (int k = 0; k != yl; k++) {
				s.push_back(y[k][j]);
			}
			sum = xianlian_neiji(x[i], s);//向量内积
			s.clear();
			t.push_back(sum);
			sum = 0;
		}
		l.push_back(t);
		t.clear();
	}
	return l;
}
//----------------------------------------------------------------------------------------------------------------------------------
// 矩阵pad填充
//默认填充0    输入：矩阵，填充位数
template<typename T>
std::vector<std::vector<T>> juzhen_pad0(std::vector<std::vector<T>>& x, int k) {
	if (juzhen_2D_panduan(x) == false || k <= 0) {
		std::cout << "矩阵或填充层数输入错误" << std::endl;
		return { {0} };
	}
	int a = juzhen_2D_hanshu(x);
	int b = juzhen_2D_lieshu(x);
	std::vector<std::vector<T>> l;
	std::vector<T> t;
	for (int i = 0; i != a + 2*k ; i++) {
		for (int j = 0; j != b +2* k; j++) {
			if (i >= k  && i <= x.size() - 1 + k  && j>=k && j<=x[0].size()-1+k) {
				t.push_back(x[i - k][j - k]);
			}
			else {
				t.push_back(0);
			}
			
		}
		l.push_back(t);
		t.clear();
		
	}
	return l;

}

//自定义填充值，自定义填充位数
template<typename T> 
//   输入：矩阵，填充值，填充位数
std::vector<std::vector<T>> juzhen_pad(std::vector<std::vector<T>>& x, T zhi, int k) {
	if (juzhen_2D_panduan(x) == false || k <= 0) {
		std::cout << "矩阵或填充层数输入错误" << std::endl;
		return { {0} };
	}
	int a = juzhen_2D_hanshu(x);
	int b = juzhen_2D_lieshu(x);
	std::vector<std::vector<T>> l;
	std::vector<T> t;
	for (int i = 0; i != a + 2 * k; i++) {
		for (int j = 0; j != b + 2 * k; j++) {
			if (i >= k && i <= x.size() - 1 + k && j >= k && j <= x[0].size() - 1 + k) {
				t.push_back(x[i - k][j - k]);
			}
			else {
				t.push_back(zhi);
			}

		}
		l.push_back(t);
		t.clear();

	}
	return l;
}

//矩阵加法
template<typename T>
std::vector <std::vector<T>> juzhen_jiafa(std::vector<std::vector<T>>& x, std::vector<std::vector<T>>& y) {
	if (juzhen_2D_panduan(x) == false || juzhen_2D_panduan(y) == false) {
		std::cout << "输入矩阵不符合矩阵加法要求" << std::endl;
		return { {0} };
	}
	std::vector<T> t;
	std::vector<std::vector<T>> l;
	int m = juzhen_2D_hanshu(x);
	int n = juzhen_2D_lieshu(x);
	for (int i = 0; i != m; i++) {
		for (int j = 0; j != n; j++) {
			t.push_back(x[i][j] + y[i][j]);
		}
		l.push_back(t);
		t.clear();
	}
	return l;
}
//矩阵减法
template<typename T>
std::vector <std::vector<T>> juzhen_jianfa(std::vector<std::vector<T>>& x, std::vector<std::vector<T>>& y) {
	if (juzhen_2D_panduan(x) == false || juzhen_2D_panduan(y) == false) {
		std::cout << "输入矩阵不符合矩阵减法要求" << std::endl;
		return { {0} };
	}
	std::vector<T> t;
	std::vector<std::vector<T>> l;
	int m = juzhen_2D_hanshu(x);
	int n = juzhen_2D_lieshu(x);
	for (int i = 0; i != m; i++) {
		for (int j = 0; j != n; j++) {
			t.push_back(x[i][j]-y[i][j]);
		}
		l.push_back(t);
		t.clear();
	}
	return l;
}
//time 检测程序运行时间
template<typename Func>
auto time(Func&& func)
{
	auto start = std::chrono::high_resolution_clock::now();

	func();

	auto end = std::chrono::high_resolution_clock::now();

	std::chrono::duration<double> elapsed = end - start;

	std::cout << "Elapsed time: " << elapsed.count() << " seconds." << std::endl;

	return elapsed.count();
}

//命名空间python的应用, 应为   using namespace python;   或者python::   暂时不支持C++23 新增加功能

//python命名空间,提供类似python语法功能。
namespace python {
	//打印任意类型数据
    template<typename T>
    void print(T x) {
        std::cout << x << std::endl;
    }
	//print函数第2次重载,打印一维数组
    template<typename T>
    void print(const std::vector<T>& x) {
        for (int i = 0; i != x.size(); i++) {
            std::cout << x[i] << " ";
        }
        std::cout << std::endl;
    }
	//print函数第3次重载,打印二维数组
    template<typename T>
    void print(const std::vector<std::vector<T>>& x) {
        if (x.empty()) {
            std::cout << "二维数组为空" <<std::endl;
        }
        int p = 1;
        for (int k = 0; k != x.size(); k++) {
            if (x[k].empty() || x[k].size()!=x[0].size())p = 0;
            break;
        }
		if (p == 0) {
			std::cout << "输入矩阵不合法"<<std::endl;
		}
        
        for (int i = 0; i != x.size(); i++) {
            for (int j = 0; j != x[0].size(); j++) {
                std::cout << x[i][j] << " ";
           }
            std::cout << std::endl;
        }
		
    }
	//print函数第4次重载，打印矩阵类的矩阵
	template<typename T>
	void print(const juzhen<T>& x) {
		if (x.juzhen_panduan() == false) {
			std::cout << "矩阵不合法"<<std::endl;
		}
		else {
			for (int i = 0; i != x.juzhen_hanshu(); i++) {
				for (int j = 0; j != x.juzhen_lieshu(); j++) {
					std::cout << x[i][j] << " ";
				}
				std::cout << std::endl;
			}
		}
	}
	

}
#endif

标签
#c++ #矩阵 #开发语言
m0_71353975
关注
C++项目练手：矩阵类的功能实现
weixin_51958878的博客
06-13 3785
C++项目练手：矩阵类的功能实现 C++课程设计：矩阵类的相关功能实现 矩阵简述： 实数矩阵是由一个按照长方阵列排列的实数集合。除数据外，两个实数矩阵可以进行加法和乘法运算，一个矩阵也可以和一个实数相乘，得到一个新的矩阵，请基于抽象出的矩阵的属性和方法，定义和实现一个矩阵类，并编写主函数，测试矩阵对象的构造和测试。 功能实现要求： 在缺省情况下，构造一个4*4的数据全为0的矩阵 可以按给定的行数和列数，构造一个值为全0的矩阵 可以使用给定的矩阵构造一个新的矩阵（定义并使用拷贝构造函数） 可以获取矩阵中的给
C++实现矩阵类型的基本操作：创建矩阵（M x N）、释放内存、获取某一元素的值、修改某一元素的值、乘法操作
Gongxs7的专栏
03-30 4315
#include #include using namespace std; class MAT; MAT operator*(const MAT& A, const MAT& B); class MAT { public: MAT(int rows, int cols); MAT(const MAT& m); ~MAT();//释放矩阵 void cin_data(); float
矩阵操作的C/C++实现
m0_47037246的博客
09-05 559
在上面的代码中，我们定义了一个2x3的矩阵matrix1和一个3x2的矩阵matrix2，并创建一个新的2x2的矩阵result来保存乘法的结果。在上面的代码中，我们定义了两个3x3的矩阵matrix1和matrix2，并创建一个新的矩阵result来保存相加的结果。本文介绍了在C/C++中进行矩阵操作的基本方法，包括矩阵表示、矩阵加法和矩阵乘法。矩阵乘法是指将一个m×n的矩阵乘以一个n×p的矩阵得到一个m×p的矩阵。在上面的代码中，我们定义了一个3x3的矩阵，并使用嵌套的循环打印出矩阵的每个元素。
邻接矩阵存储的图的基本操作c++
guozhiyao4的博客
08-06 1253
注：若有错误或要改善的地方请告之，谢谢，新手上路，有些函数还是很冗余的，慢慢改进。 #include #include #include #include #include #include #include using namespace std; /**包含无向图、无向网、有向图、有向网 ***全部类型的图中，两个结点间若不存在弧，设置其edge[][]数组中的值为0 ***在构建图时，根
C++ 中的矩阵介绍：以二维矩阵查找为例
最新发布
wang的博客
05-22 422
本文介绍了C++中矩阵的基本概念和常见操作。矩阵作为二维数据结构，广泛应用于图像处理、动态规划等领域。文章详细讲解了两种矩阵表示方式（二维数组和vector容器），重点分析了从右上角开始查找目标值的优化算法，其时间复杂度从O(m*n)降至O(m+n)。同时强调了矩阵操作中的注意事项，包括空矩阵判断、行列区分和下标越界等问题。通过具体示例演示了查找过程，并总结了矩阵在各类算法问题中的应用场景。
C++实战笔记（一）：矩阵类
qq_41599413的博客
01-16 1万+
前言   上大学之前就对C++有过一些了解，知道C++是一种功能十分强大的语言。大一时学习了C语言，了解了面向过程的编程方法。现在大三开始学习C++，初步接触了面向对象的编程思想，对C++功能更为着迷，其既有C语言面向过程的特点，又能兼顾对问题对象的操作，自由度很高，是底层架构和高层架构对接的完美工具。   在学习C++的过程中，我将在这里整理学习的笔记，希望能对自己和他人有所帮助。 正文   第...
C++ 实现 Matrix （矩阵）类
m0_58880769的博客
07-28 9738
​c)实现高斯消元法求解线性方程组Matrixx=GaussianElimination(A,b);​b)实现高斯滤波MatrixB=GaussianFilter(A,H)​a)增广矩阵MatrixAb=AugmentMatrix(A,B);​a)零矩阵Matrixzeros(rows,cols);​b)逆矩阵MatrixIA=Inverse(A);​a)默认构造函数，生成一个1,1列的矩阵。......
[c++]二维矩阵存储及基本操作demo
LumenWang
03-06 1482
C++实现二维矩阵存储及基本操作demo /* 调试过程的低级错误：1.循环ij问题；2.指针未经初始化 */ #include<iostream> #include<iomanip> #include<cstdio> #include<stdlib.h> #include<cstring> using namespace std;...
矩阵基本操作 C++实现
抟土成人祖，炼石补青天。眼中览银河，手可摘星辰。
01-12 1057
矩阵的操作非常广泛，从基础运算到高级线性代数和特殊矩阵处理，不同的功能适用于不同的场景。如果你想在 C++ 中实现矩阵操作，可以逐步添加这些功能，或者选择现成的高性能矩阵库如。在矩阵操作中，除了基础和常见的操作外，还有许多高级操作和应用，涉及到线性代数、数据处理、图像处理等领域。的概述及其 C++ 实现，涵盖常见的矩阵操作，例如矩阵创建、加法、减法、乘法、转置、逆矩阵、行列式计算等。基于之前实现的矩阵类，可以扩展实现上述操作。，实现更加复杂的操作。
C++矩阵计算库Eigen3之：矩阵的基本操作和运算
热门推荐
MinCong Luo的博客
12-16 3万+
C++矩阵计算库Eigen3之：矩阵的基本操作和运算我写了一个示例程序来展示Eigen3的一些接口使用，一些来自官网示例，后续我还会写这种程序展示更复杂的矩阵运算功能。你必须在使用时，注释掉其他主函数，使用编译链接语句、运行 :root@master:# g++ mat.cpp -o mat -I/download/eigen root@master:# ./mat m = 94.0188 89.
Opencv C++ 矩阵的基本操作
廷益_飞鸟的博客
04-26 1108
#include <iostream> #include <string> #include <sstream> using namespace std; // OpenCV include; //#include <opencv2/opencv.hpp> #include <opencv2/core.hpp> #include &l...
OpenCV C++ 学习笔记（三）：矩阵基本操作、遍历图像矩阵的方法及性能分析
qq_39281631的博客
06-01 1391
本文介绍了OpenCV中常用数据类型定义、图像矩阵在内存中的存储方式以及矩阵基本操作方法。详细说明了各种矩阵操作方法，特别强调了在图像处理中高效遍历矩阵的技术。
C/C++实现矩阵的基本操作
qq_39100747的博客
08-16 1553
C/C++实现矩阵的基本操作
【C++】C++矩阵的三元表的表示和基本操作，矩阵转置、相加、相乘。
telescope_U的博客
02-05 1951
1.作用：此篇文章主要是矩阵和三元表的转换，可作为空间算法优化减少内存的使用。 2.代码： #pragma once #include<iostream> using namespace std; #define M 4//稀疏矩阵行数 #define N 4//稀疏矩阵列数 #define MaxSize 16//稀疏矩阵中非0元素最多个数 typedef struct { int r, c;//行(row)号与列(column)号 int e;//元素(element) }
C/C++ 图的基本操作
YunLan天地间
10-23 6966
数据结构—图的基本操作：添加节点、为有向图/无向图添加邻接矩阵、打印邻接矩阵、深度优先遍历、广度优先遍历等
【C++】ODA的基本操作-平移、旋转、矩阵变换
渲染引擎开发
05-01 2822
ODA(Open Design Alliance）是一套与ARX类似的图形开发库，熟练使用ODA接口，可以大大加快我们的几何图形开发效率。 一、添加常用的头文件 #include "OdaCommon.h" #include "GePoint2d.h" #include "GeVector2d.h" #include "GeMatrix2d.h" 二、 矩阵变换和图形放大 O...
c++版矩阵基本操作，行列式，逆（不限矩阵大小）
myazi
04-27 1690
原本是为了编程实现线性回归的，想想，里面太多矩阵操作，尤其是求逆。以前学数值分析时，也用到过列主元高斯消去求解线性方程组，LU分解求解线性方程组。这次，同样是用高斯消去法求矩阵行列式的值，用LU分解求解矩阵的逆，效率上程序执行起来还行，比用python跑一边速度快，结果一致，这也潜在说明python库中矩阵求逆的实现应该也是用的LU分解。至于矩阵的其他一些操作，基本上算简单，当然面的稀疏性矩阵的话，
C++数据结构邻接矩阵基本操作集（自编）
weixin_41546300的博客
11-08 1758
邻接矩阵基本操作 建立邻接矩阵 CreateMGraph(MGraph &G, VertexType v[],EdgeType e[][MAXSIZE],int n) 返回顶点下标 getVertexidx(MGraph G, VertexType x) 判断边是否存在 Adjacent(MGraph G, VertexType x, VertexType y) 某点所连接的所有点 Ne...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值