目录

行列式运算法则

矩阵的运算及其运算规则:

一、矩阵的加法与减法

二、矩阵与数的乘法

三、矩阵与矩阵的乘法

​

行列式运算法则

1、三角形（上三角，下三角）行列式的值，等于对角线元素的乘积。计算时，一般需要多次运算来把行列式转换为上三角型或下三角型


2、交换行列式中的两行（列），行列式变号（交换）


3、行列式中某行（列）的公因子，可以提出放到行列式之外。（倍乘）（注：矩阵是全部元素都乘，都提取）


4、行列式的某行乘以a，加到另外一行，行列式不变，常用于消去某些元素。（倍加）


5、若行列式中，两行（列）完全一样，则行列式为0；可以推论，如果两行（列）成比例，行列式为0。


6、行列式展开：行列式的值，等于其中某一行（列）的每个元素与其代数余子式乘积的和；但若是另一行（列）的元素与本行（列）的代数余子式乘积求和，则其和为0


7、克拉默法则：利用线性方程组的系数行列式求解方程，令系数行列式为D，Di为将等式右侧的值替换到行列式的第i列，则行列式的i个解为：



8、齐次线性方程组：在线性方程组等式右侧的常数项全部为0时，该方程组称为齐次线性方程组，否则为非齐次线性方程组。齐次线性方程组一定有零解，但不一定有非零解。当D=0时，有非零解；当D!=0时，方程组无非零解。

 

矩阵的运算及其运算规则:

一、矩阵的加法与减法

1、运算规则　　设矩阵

   则  

两个矩阵相加减，即它们相同位置的元素相加减！注意：只有对于两个行数、列数分别相等的矩阵（即同型矩阵），加减法运算才有意义，即加减运算是可行的．　　

2、运算性质（假设运算都是可行的）　　满足交换律和结合律

交换律　

结合律　

 

二、矩阵与数的乘法

1、运算规则数乘矩阵A，就是将数乘矩阵A中的每一个元素，记为或特别地，称称为的负矩阵.　　

2、运算性质　　满足结合律和分配律　　结合律：(λμ)A=λ(μA)；(λ+μ)A =λA+μA．　　分配律：λ(A+B)=λA+λB．

已知两个矩阵



满足矩阵方程

，求未知矩阵

解　由已知条件知





三、矩阵与矩阵的乘法

1、运算规则　　设，，则A与B的乘积是这样一个矩阵：　

　(1) 行数与（左矩阵）A相同，列数与（右矩阵）B相同，即

    (2) C的第行第列的元素由A的第行元素与B的第列元素对应相乘，再取乘积之和．

　设矩阵



计算



解

是的矩阵．设它为

 



 

想一想：设列矩阵



，行矩阵

，和的行数和列数分别是多少呢

是3×3的矩阵，是1×1的矩阵，即

 

只有一个元素．课堂练习　　1、设



，



，求



．　　

2、在第1道练习题中，两个矩阵相乘的顺序是A在左边，B在右边，称为A左乘B或B右乘A．如果交换顺序，让B在左边，A在右边，即A右乘B，运算还能进行吗？请算算试试看．并由此思考：两个矩阵应当满足什么条件，才能够做乘法运算．　　

3、设列矩阵



，行矩阵



，求和

，比较两个计算结果，能得出什么结论吗？　　

4、设三阶方阵



，三阶单位阵为



，试求和，并将计算结果与A比较，看有什么样的结论．

解：　　第1题



．　　第2题　　对于



，



．　　求是有意义的，而是无意义的．

 

结论1　只有在下列情况下，两个矩阵的乘法才有意义，或说乘法运算是可行的：左矩阵的列数＝右矩阵的行数．　　

第3题

是矩阵，是的矩阵．





．





结论2　在矩阵的乘法中，必须注意相乘的顺序．即使在与均有意义时，也未必有=成立．可见矩阵乘法不满足交换律．　　

第4题　　计算得：

．　　

结论3　方阵A和它同阶的单位阵作乘积，结果仍为A，即



．　　单位阵在矩阵乘法中的作用相当于数1在我们普通乘法中的作用．典型例题例6.5.3　设

，试计算和

．解







．







结论4　两个非零矩阵的乘积可以是零矩阵．由此若，不能得出或的结论．

例6.5.4　利用矩阵的乘法，三元线性方程组



可以写成矩阵的形式





＝



若记系数、未知量和常数项构成的三个矩阵分别为





，



，



，　　则线性方程组又可以简写为矩阵方程的形式：

2、运算性质（假设运算都是可行的）　　

(1)　结合律　



(2)　分配律　



（左分配律）；



（右分配律）．　

(3)　



3、方阵的幂定义：设A是方阵，是一个正整数，规定，



显然，记号表示个A的连乘积．

四、矩阵的转置

1、定义

定义：将矩阵A的行换成同序号的列所得到的新矩阵称为矩阵A的转置矩阵，记作

或

 

例如，矩阵



的转置矩阵为



．

　　2、运算性质（假设运算都是可行的）　

　    (1)　

　　(2)　

　　(3)　 

　　(4)　   是常数．

　　2、运算性质（假设运算都是可行的）　

       (1)　

　　(2)　 

　　(3)　 

　　(4)　   ， 是常数．

典型例题 例6.5.5 利用矩阵



验证运算性质：



解







而



所以



．

定义：如果方阵满足，即，则称A为对称矩阵．

对称矩阵的特点是：它的元素以主对角线为对称轴对应相等．

五、方阵的行列式

1、定义

定义：由方阵A的元素所构成的行列式（各元素的位置不变），称为方阵A的行列式，记作



或



2、运算性质　

　(1)

（行列式的性质）　

　(2)



，特别地：

(3)



 

（

是常数，A的阶数为n）思考：设A为

阶方阵，那么



的行列式



与A的行列式



之间的关系为什么不是



，而是



？　　不妨自行设计一个二阶方阵，计算一下



和



．　　例如



，则



．　　于是



，而





．思考：设



，有几种方法可以求



？解 方法一：先求矩阵乘法



，得到一个二阶方阵，再求其行列式．　　　　方法二：先分别求行列式

，再取它们的乘积．

位算法的效率有多快我就不说，不信你可以去用 10 亿个数据模拟一下，今天给大家讲一讲位运算的一些经典例子。不过，最重要的不是看懂了这些例子就好，而是要在以后多去运用位运算这些技巧，当然，采用位运算，也是可以装逼的，不信，你往下看。我会从最简单的讲起，一道比一道难度递增，不过居然是讲技巧，那么也不会太难，相信你分分钟看懂。
判断奇偶数
判断一个数是基于还是偶数，相信很多人都做过，一般的做法的代码如下
if( n % 2) == 01
    // n 是个奇数
}

如果把 n 以二进制的形式展示的话，其实我们只需要判断最后一个二进制位是 1 还是 0 就行了，如果是 1 的话，代表是奇数，如果是 0 则代表是偶数，所以采用位运算的方式的话，代码如下：
if(n & 1 == 1){
    // n 是个奇数。
}

有人可能会说，我们写成 n % 2 的形式，编译器也会自动帮我们优化成位运算啊，这个确实，有些编译器确实会自动帮我们优化。但是，我们自己能够采用位运算的形式写出来，当然更好了。别人看到你的代码，我靠，牛逼啊。无形中还能装下逼，是不是。当然，时间效率也快很多，不信你去测试测试。
2、交换两个数
交换两个数相信很多人天天写过，我也相信你每次都会使用一个额外来变量来辅助交换，例如，我们要交换 x 与 y 值，传统代码如下：
int tmp = x;
x = y;
y = tmp;

这样写有问题吗？没问题，通俗易懂，万一哪天有人要为难你，**不允许你使用额外的辅助变量来完成交换呢？**你还别说，有人面试确实被问过，这个时候，位运算大法就来了。代码如下：
x = x ^ y   // （1）
y = x ^ y   // （2）
x = x ^ y   // （3）

我靠，牛逼！三个都是 x ^ y，就莫名交换成功了。在此我解释下吧，我们知道，两个相同的数异或之后结果会等于 0，即 n ^ n = 0。并且任何数与 0 异或等于它本身，即 n ^ 0 = n。所以，解释如下：
把（1）中的 x 带入 （2）中的 x，有
y = x^y = (xy)y = x(yy) = x^0 = x。 x 的值成功赋给了 y。
对于（3）,推导如下：
x = x^y = (xy)x = (xx)y = 0^y = y。

这里解释一下，异或运算支持运算的交换律和结合律哦。

以后你要是别人看不懂你的代码，逼格装高点，就可以在代码里面采用这样的公式来交换两个变量的值了，被打了不要找我。
讲这个呢，是想告诉你位运算的强大，让你以后能够更多着去利用位运算去解决一些问题，一时之间学不会也没事，看多了就学会了，不信？继续往下看，下面的这几道题，也是非常常见的，可能你之前也都做过。
3、找出没有重复的数

给你一组整型数据，这些数据中，其中有一个数只出现了一次，其他的数都出现了两次，让你来找出一个数 。

这道题可能很多人会用一个哈希表来存储，每次存储的时候，记录 某个数出现的次数，最后再遍历哈希表，看看哪个数只出现了一次。这种方法的时间复杂度为 O(n)，空间复杂度也为 O(n)了。
然而我想告诉你的是，采用位运算来做，绝对高逼格！
我们刚才说过，两个相同的数异或的结果是 0，一个数和 0 异或的结果是它本身，所以我们把这一组整型全部异或一下，例如这组数据是：1，  2，  3，  4，  5，  1，  2，  3，  4。其中 5 只出现了一次，其他都出现了两次，把他们全部异或一下，结果如下：
由于异或支持交换律和结合律，所以:
123451234 = （11)(22)(33)(44)5= 00005 = 5。
也就是说，那些出现了两次的数异或之后会变成0，那个出现一次的数，和 0 异或之后就等于它本身。就问这个解法牛不牛逼？所以代码如下
int find(int[] arr){
    int tmp = arr[0];
    for(int i = 1;i < arr.length; i++){
        tmp = tmp ^ arr[i];
    }
    return tmp;
}

时间复杂度为 O(n)，空间复杂度为 O(1)，而且看起来很牛逼。
4、m的n次方
如果让你求解 m 的 n 次方，并且不能使用系统自带的 pow 函数，你会怎么做呢？这还不简单，连续让 n 个 m 相乘就行了，代码如下：
int pow(int n){
    int tmp = 1;
    for(int i = 1; i <= n; i++) {
        tmp = tmp * m;
    }
    return tmp;
}

不过你要是这样做的话，我只能呵呵，时间复杂度为 O(n) 了，怕是小学生都会！如果让你用位运算来做，你会怎么做呢？
我举个例子吧，例如 n = 13，则 n 的二进制表示为 1101, 那么 m 的 13 次方可以拆解为:
m^1101 = m^0001 * m^0100 * m^1000。
我们可以通过 & 1和 >>1 来逐位读取 1101，为1时将该位代表的乘数累乘到最终结果。直接看代码吧，反而容易理解：
int pow(int n){
    int sum = 1;
    int tmp = m;
    while(n != 0){
        if(n & 1 == 1){
            sum *= tmp;
        }
        tmp *= tmp;
        n = n >> 1;
    }
    
    return sum;
}

时间复杂度近为 O(logn)，而且看起来很牛逼。

这里说一下，位运算很多情况下都是很二进制扯上关系的，所以我们要判断是否是否位运算，很多情况下都会把他们拆分成二进制，然后观察特性，或者就是利用与，或，异或的特性来观察，总之，我觉得多看一些例子，加上自己多动手，就比较容易上手了。所以呢，继续往下看，注意，先别看答案，先看看自己会不会做。

5、找出不大于N的最大的2的幂指数
传统的做法就是让 1 不断着乘以 2，代码如下：
int findN(int N){
    int sum = 1;
   while(true){
        if(sum * 2 > N){
            return sum;
        }
        sum = sum * 2;
   }
}

这样做的话，时间复杂度是 O(logn)，那如果改成位运算，该怎么做呢？我刚才说了，如果要弄成位运算的方式，很多时候我们把某个数拆成二进制，然后看看有哪些发现。这里我举个例子吧。
例如 N = 19，那么转换成二进制就是 00010011（这里为了方便，我采用8位的二进制来表示）。那么我们要找的数就是，把二进制中最左边的 1 保留，后面的 1 全部变为 0。即我们的目标数是 00010000。那么如何获得这个数呢？相应解法如下：
1、找到最左边的 1，然后把它右边的所有 0 变成 1

2、把得到的数值加 1，可以得到 00100000即 00011111 + 1 = 00100000。
3、把 得到的 00100000 向右移动一位，即可得到 00010000，即 00100000 >> 1 = 00010000。
那么问题来了，第一步中把最左边 1 中后面的 0 转化为 1 该怎么弄呢？我先给出代码再解释吧。下面这段代码就可以把最左边 1 中后面的 0 全部转化为 1，
n |= n >> 1;
n |= n >> 2;
n |= n >> 4;

就是通过把 n 右移并且做或运算即可得到。我解释下吧，我们假设最左边的 1 处于二进制位中的第 k 位(从左往右数),那么把 n 右移一位之后，那么得到的结果中第 k+1 位也必定为 1,然后把 n 与右移后的结果做或运算，那么得到的结果中第 k 和 第 k + 1 位必定是 1;同样的道理，再次把 n 右移两位，那么得到的结果中第 k+2和第 k+3 位必定是 1,然后再次做或运算，那么就能得到第 k, k+1, k+2, k+3 都是 1，如此往复下去…
最终的代码如下
int findN(int n){
    n |= n >> 1;
    n |= n >> 2;
    n |= n >> 4;
    n |= n >> 8 // 整型一般是 32 位，上面我是假设 8 位。
    return (n + 1) >> 1;
}

这种做法的时间复杂度近似 O(1)，重点是，高逼格。
总结
上面讲了 5 道题，本来想写十道的，发现五道就已经写了好久了，，，，十道的话，怕你们也没耐心写完，而且一道比一道难的那种，，，，。
不过呢，我给出的这些例子中，并不是让你们学会了这些题就 Ok，而且让你们有一个意识：很多时候，位运算是个不错的选择，至少时间效率会快很多，而且高逼格，装逼必备。所以呢，以后可以多尝试去使用位运算哦，以后我会再给大家找些题来讲讲，遇到高逼格的，感觉很不错的，就会拿来供大家学习了。
兄dei，如果觉得我写的不错，不妨帮个忙
1、关注我的原创微信公众号「帅地玩编程」，每天准时推送干货技术文章，专注于写算法 + 计算机基础知识（计算机网络+ 操作系统+数据库+Linux），听说关注了的不优秀也会变得优秀哦。
2、给俺点个赞呗，可以让更多的人看到这篇文章，顺便激励下我，嘻嘻。

作者简洁

作者：大家好，我是帅地，从大学、自学一路走来，深知算法，计算机基础知识的重要性，所以申请了一个微星公众号『帅地玩编程』，专业于写这些底层知识，提升我们的内功，帅地期待你的关注，和我一起学习。 转载说明：未获得授权，禁止转载

参加运算的两个对象，按二进制位进行运算。

进制转换地址：http://tool.oschina.net/hexconvert/

一：与运算符（&）

预算规则：

0&0=0；0&1=0；1&0=0；1&1=1

即：两个同时为1，结果为1，否则为0

例如：3&5

十进制3转为二进制的3：0000 0011

十进制5转为二进制的5：0000 0101

------------------------结果：0000 0001 ->转为十进制：1

即：3&5 = 1

二：或运算（|）

运算规则：

0|0=0；  0|1=1；  1|0=1；   1|1=1；

即 ：参加运算的两个对象，一个为1，其值为1。

例如：3|5　即 00000011 | 0000 0101 = 00000111，因此，3|5=7。　

三：异或运算符（^）

运算规则：0^0=0；  0^1=1；  1^0=1；   1^1=0；

即：参加运算的两个对象，如果两个位为“异”（值不同），则该位结果为1，否则为0。

例如：3^5 =  0000 0011 | 0000 0101 =0000 0110，因此，3^5 = 6

Maven
<!-- guava -->
<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>29.0-jre</version>
</dependency>

package com.bood.common.utils;

import com.google.common.base.Optional;

import java.math.BigDecimal;

/**
 * <p>
 * 精确运算工具类
 * </p>
 *
 * @author：bood
 * @date：2020/9/23
 */
public class MathUtils {

    public MathUtils() {
    }

    /**
     * <p>
     * BigDecimal 的加法运算封装
     * </p>
     *
     * @param b1: 第一个数
     * @param bn: 需要加的加法数组
     * @return：java.math.BigDecimal
     * @author：bood
     * @create：2020/5/3
     */
    public static BigDecimal safeAdd(BigDecimal b1, BigDecimal... bn) {
        if (null == b1) {
            b1 = BigDecimal.ZERO;
        }
        if (null != bn) {
            for (BigDecimal b : bn) {
                b1 = b1.add(null == b ? BigDecimal.ZERO : b);
            }
        }
        return b1;
    }

    /**
     * <p>
     * Integer 加法运算的封装
     * </p>
     *
     * @param b1: 第一个数
     * @param bn: 需要加的加法数组
     * @return：java.lang.Integer
     * @author：bood
     * @create：2020/5/3
     */
    public static Integer safeAdd(Integer b1, Integer... bn) {
        if (null == b1) {
            b1 = 0;
        }
        Integer r = b1;
        if (null != bn) {
            for (Integer b : bn) {
                r += Optional.fromNullable(b).or(0);
            }
        }
        return r > 0 ? r : 0;
    }

    /**
     * <p>
     * BigDecimal 的减法运算封装，结果为负数时是否返回0
     * </p>
     *
     * @param b1 被减数
     * @param bn 需要减的减数数组
     * @return：java.math.BigDecimal
     * @author：bood
     * @create：2020/5/3
     */
    public static BigDecimal safeSubtract(BigDecimal b1, BigDecimal... bn) {
        return safeSubtract(true, b1, bn);
    }

    /**
     * <p>
     * BigDecimal 的安全减法运算
     * </p>
     *
     * @param isZero 减法结果为负数时是否返回0，true 是返回0（金额计算时使用），false 是返回负数结果
     * @param b1     被减数
     * @param bn     需要减的减数数组
     * @return：java.math.BigDecimal
     * @author：bood
     * @create：2020/5/3
     */
    public static BigDecimal safeSubtract(Boolean isZero, BigDecimal b1, BigDecimal... bn) {
        if (null == b1) {
            b1 = BigDecimal.ZERO;
        }
        BigDecimal r = b1;
        if (null != bn) {
            for (BigDecimal b : bn) {
                r = r.subtract((null == b ? BigDecimal.ZERO : b));
            }
        }
        return isZero ? (r.compareTo(BigDecimal.ZERO) == -1 ? BigDecimal.ZERO : r) : r;
    }

    /**
     * <p>
     * Integer 减法运算的封装，小于0时返回0
     * </p>
     *
     * @param b1 被减数
     * @param bn 需要减的减数数组
     * @return：java.lang.Integer
     * @author：bood
     * @create：2020/5/3
     */
    public static Integer safeSubtract(Integer b1, Integer... bn) {
        if (null == b1) {
            b1 = 0;
        }
        Integer r = b1;
        if (null != bn) {
            for (Integer b : bn) {
                r -= Optional.fromNullable(b).or(0);
            }
        }
        return null != r && r > 0 ? r : 0;
    }

    /**
     * <p>
     * BigDecimal 的除法运算封装
     * 返回2位小数
     * </p>
     *
     * @param b1 被除数
     * @param b2 除数
     * @return：java.math.BigDecimal
     * @author：bood
     * @create：2020/5/3
     */
    public static <T extends Number> BigDecimal safeDivide(T b1, T b2, int precision) {
        return safeDivide(b1, b2, precision, BigDecimal.ZERO);
    }

    /**
     * <p>
     * BigDecimal 的除法运算封装，如果除数或者被除数为0，返回默认值
     * 默认返回小数位后2位
     * </p>
     *
     * @param b1           被除数
     * @param b2           除数
     * @param precision    小数点后保留几位
     * @param defaultValue 默认值
     * @return：java.math.BigDecimal
     * @author：bood
     * @create：2020/5/3
     */
    public static <T extends Number> BigDecimal safeDivide(T b1, T b2, int precision, BigDecimal defaultValue) {
        if (null == b1 || null == b2) {
            return defaultValue;
        }
        try {
            return BigDecimal.valueOf(b1.doubleValue()).divide(BigDecimal.valueOf(b2.doubleValue()), precision, BigDecimal.ROUND_HALF_UP);
        } catch (Exception e) {
            return defaultValue;
        }
    }

    /**
     * <p>
     * BigDecimal 的乘法运算封装
     * 默认返回小数位后2位
     * </p>
     *
     * @param b1        乘数
     * @param b2        乘数
     * @param precision 小数点后保留几位
     * @return：java.math.BigDecimal
     * @author：bood
     * @create：2020/5/3
     */
    public static <T extends Number> BigDecimal safeMultiply(T b1, T b2, int precision) {
        if (null == b1 || null == b2) {
            return BigDecimal.ZERO;
        }
        return BigDecimal.valueOf(b1.doubleValue()).multiply(BigDecimal.valueOf(b2.doubleValue())).setScale(precision, BigDecimal.ROUND_HALF_UP);
    }

}

混〔IT〕的小学生 热爱编程，喜欢挑战新事物！  撩撩博主 😃