数据结构学习----矩阵(Java实现)

矩阵类：

package com.clarck.datastructure.matrix;

/**
 * 矩阵类
 * 
 * @author clarck
 *
 */
public class Matrix {
    /**
     * 存储矩阵元素的二维数组
     */
    private int element[][];
    
    /**
     * 构造m*n零矩阵
     * @param m
     * @param n
     */
    public Matrix(int m, int n) {
        //若m或n为负数，Java将抛出负数组长度异常NegativeArrayException
        this.element = new int[m][n];
    }
    
    /**
     * 深拷贝
     * @param mat
     */
    public Matrix(Matrix mat) {
        this(mat.element.length, mat.element[0].length, mat.element);
    }
    
    /**
     * 构造n*n零矩阵
     * @param n
     */
    public Matrix(int n) {
        this(n, n);
    }
    
    /**
     * 返回当前矩阵与mat相加后的矩阵，不改变当前矩阵，=this+mat，各对应元素相加
     * @param mat
     * @return
     */
    public Matrix plus(Matrix mat) {
        Matrix matc = new Matrix(this);                      //深拷贝
        matc.add(mat);
        return matc;                                       //返回对象引用
    }    
    
    /**
     * 构造m*n矩阵，由mat提供元素
     * @param m
     * @param n
     * @param mat
     */
    public Matrix(int m, int n, int mat[][]) {
        this(m, n);
        for (int i = 0; i < mat.length && i < m; i++) {
            for (int j = 0; j < mat[i].length && j < n; j++) {
                this.element[i][j] = mat[i][j];
            }
        }
    }
    
    /**
     * 返回矩阵第i行，第j列元素值 O(1)
     * @param i
     * @param j
     * @return
     */
    public int get(int i, int j) {
        //若i，j下标越界，Java将抛出数组下标越界异常ArrayIndexOutOfBoundsException
        return this.element[i][j];
    }
    
    /**
     * 设置矩阵第i行第j列的元素值为value O(1)
     * @param i
     * @param j
     * @param value
     */
    public void set(int i, int j, int value) {
        this.element[i][j] = value;
    }
    
    /**
     * 返回矩阵所有元素的描述字符串，行主序遍历
     */
    @Override
    public String toString() {
        String str = " 矩阵 " + this.getClass().getSimpleName() + " (" + this.element.length + " * " + this.element[0].length + ") :\n";
        for (int i = 0; i < this.element.length; i++) {
            for (int j = 0; j < this.element[i].length; j++) {
                str += String.format("%4d", this.element[i][j]);
            }
            str += "\n";
        }
        return str;
    }
    
    /**
     * 当前矩阵与mat矩阵相加，this += mat, 各对应元素相加;改变当前矩阵
     * @param mat
     */
    public void add(Matrix mat) {
        if (this.element.length != mat.element.length ||
            this.element[0].length != mat.element[0].length)
            throw new IllegalArgumentException("两个矩阵阶数不同，不能相加");
        for (int i = 0; i < this.element.length; i++) {
            for (int j = 0; j < this.element[i].length; j++) {
                this.element[i][j] += mat.element[i][j];
            }
        }
    }
    
    /**
     * 比较两个同阶矩阵是否相等
     */
    public boolean equals(Object obj) {
        if (this == obj)
            return true;

        if (!(obj instanceof Matrix))
            return false;

        Matrix mat = (Matrix) obj;
        if (this.element.length != mat.element.length
                || this.element[0].length != mat.element[0].length)
            return false;

        for (int i = 0; i < this.element.length; i++)
            for (int j = 0; j < this.element[i].length; j++)
                if (this.element[i][j] != mat.element[i][j])
                    return false;

        return true;
    }
    
    /**
     * 返回当前矩阵的转置矩阵
     * @return
     */
    public Matrix transpose() {
        //构造零矩阵
        Matrix trans = new Matrix(this.element[0].length, this.element.length);
        for (int i = 0; i < this.element.length; i++)
            for (int j = 0; j < this.element[i].length; j++)
                trans.element[j][i] = this.element[i][j];
        return trans;
    }
    
    /**
     * 判断当前矩阵是否为上三角矩阵
     * @return
     */
    public boolean isUpTriangular() {
        if (this.element.length != this.element[0].length)
            return false;
        for (int i = 0; i < this.element.length; i++)
            for (int j = 0; j < i; j++)
                //下三角元素为0
                if (this.element[i][j] != 0)
                    return false;
        
        return true;
    }
    
    /**
     * 判断当前矩阵是否为下三角矩阵
     * @return
     */
    public boolean isDownTriangular() {
        if (this.element.length != this.element[0].length)
            return false;
        for (int i = 0; i < this.element.length; i++)
            for (int j = i; j < this.element.length; j++)
                //上三角元素为0
                if (this.element[i][j] != 0)
                    return false;
        
        return true;
    }
    
    /**
     * 判断当前矩阵是否为对称矩阵
     * @return
     */
    public boolean isSymmetric() {
        if (this.element.length != this.element[0].length)
            return false;
        for (int i = 0; i < this.element.length; i++)
            for (int j = 0; j < this.element[i].length; j++)
                if (this.element[i][j] != this.element[j][i])
                    return false;
        return true;
    }
}

测试类：

package com.clarck.datastructure.matrix;

public class Matrix_test {
    public static void main(String args[]) {
        int m1[][] = {{1,2,3}, {4,5,6,7,8}, {9,10,11}};
        //矩阵对象，初值不足时自动补0,忽略多余元素
        Matrix mata = new Matrix(3,4,m1);
        System.out.println("A" + mata.toString());
        Matrix matb = new Matrix(3, 4);
        matb.set(0, 0, 1);
        matb.set(1, 1, 1);
        matb.set(2, 2, 1);
        System.out.println("B" + matb.toString());
        Matrix matc = mata.plus(matb);
        System.out.println("C=A+B" + matc.toString());
        mata.add(matb);
        System.out.println("A+=B" + mata.toString());
        
        System.out.println("C.equals(A) ?" + matc.equals(mata));
        System.out.println("A的转置矩阵" + mata.transpose().toString());
        System.out.println("B的转置矩阵" + matb.transpose().toString());
        System.out.println("A是上三角矩阵" + mata.isUpTriangular());
        
        int m2[][] = {{1,2,3,4}, {0,5,6,7}, {0,0,8,9}};
        Matrix mate = new Matrix(4, 4, m2);
        System.out.println("E" + mate.toString());
        System.out.println("E是上三角矩阵?" + mate.isUpTriangular());
        System.out.println("A是下三角矩阵?" + mata.isDownTriangular());
        
        int m3[][] = {{1},{1,2},{0,4},{5,6,7}};
        Matrix matf = new Matrix(4, 4, m3);
        System.out.println("F" + matf.toString());
        System.out.println("F是下三角矩阵?" + matf.isDownTriangular());
        System.out.println("A是对称矩阵?" + mata.isSymmetric());
        
        int m4[][] = {{1,2,3,4},{2},{3},{4}};
        Matrix matg = new Matrix(4, 4, m4);
        System.out.println("G" + matg.toString());
        System.out.println("G是对称矩阵?" + matg.isSymmetric());
    }
}

测试结果如下：

A 矩阵 Matrix (3 * 4) :
   1   2   3   0
   4   5   6   7
   9  10  11   0

B 矩阵 Matrix (3 * 4) :
   1   0   0   0
   0   1   0   0
   0   0   1   0

C=A+B 矩阵 Matrix (3 * 4) :
   2   2   3   0
   4   6   6   7
   9  10  12   0

A+=B 矩阵 Matrix (3 * 4) :
   2   2   3   0
   4   6   6   7
   9  10  12   0

C.equals(A) ?true
A的转置矩阵 矩阵 Matrix (4 * 3) :
   2   4   9
   2   6  10
   3   6  12
   0   7   0

B的转置矩阵 矩阵 Matrix (4 * 3) :
   1   0   0
   0   1   0
   0   0   1
   0   0   0

A是上三角矩阵false
E 矩阵 Matrix (4 * 4) :
   1   2   3   4
   0   5   6   7
   0   0   8   9
   0   0   0   0

E是上三角矩阵?true
A是下三角矩阵?false
F 矩阵 Matrix (4 * 4) :
   1   0   0   0
   1   2   0   0
   0   4   0   0
   5   6   7   0

F是下三角矩阵?false
A是对称矩阵?false
G 矩阵 Matrix (4 * 4) :
   1   2   3   4
   2   0   0   0
   3   0   0   0
   4   0   0   0

G是对称矩阵?true