java递归函数,用于检查矩阵是否对称

r8xiu3jd  于 2021-07-03  发布在  Java
关注(0)|答案(2)|浏览(260)

嗨,我有一个任务来实现矩阵类和一个检查矩阵是否对称的方法。方法必须是递归的,然后我必须计算它的复杂性。之后,我必须将递归函数转换为它的迭代版本。
现在我的矩阵类是这样的:

public class Matrix<T> {

    private int m, n;
    private T[][] data;

    public Matrix(int m, int n) {
        this.m = m;
        this.n = n;
    }

    public Matrix(T[][] data) {
        this.data = data;
    }

    public boolean isSymmetric() {
        if (m != n) {
            for (int i = 0; i < m; i++) {
                for (int j = 0; j < n; j++) {
                    if (data[i][j] != data[j][i]) {
                        return false;
                    }
                }
            }
            return true;
        }
        return false;
    }

    public boolean isSymmetric(int i, int j) {
        if (i < 0 && j < 0) return true;
        else {
            return isSymmetric(i - 1, j - 1);
        }
    }

    public T get(int i, int j) {
        return data[i][j];
    }

    public void set(int i, int j, T value) {
        data[i][j] = value;
    }

    public int[] getSize() {
        return new int[] { m, n };
    }

    @Override
    public String toString() {
        String rep = "";
        for (int i = 0; i < m; i++) {
            rep += "( ";
            for (int j = 0; j < n; j++) {
                rep += data[i][j].toString() + "\t";
            }
            rep += ")\n";
        }
        return rep;
    }
}

我有一个迭代版本的 isSymmetric() 函数,但我不能得到递归函数。

yqlxgs2m

yqlxgs2m1#

在递归版本中,您忘记添加一个检查来查看这两个元素是否相等。没有它,就没有方法返回的情况 false .

public boolean isSymmetric(){
     return m == n && isSymmetric(m-1, n-1);
}
public boolean isSymmetric(int i, int j) {
        if (i < 0 && j < 0) return true;
        else if(data[i][j] != data[j][i]) return false;
        else {
            return isSymmetric(i - 1, j - 1);
        }
}
wrrgggsh

wrrgggsh2#

您可以从最大值开始检查 row 以及 col 每个递归都将用 1 直到 0 ;

public class Matrix<T> {

    private final int height;
    private final int width;
    private final T[][] data;

    public Matrix(T[][] data) {
        height = data.length;
        width = data[0].length;
        this.data = data;   // it brakes OOP: encapsulation
    }

    public boolean isSymmetricIterative() {
        if (height != width)
            return false;

        for (int row = 0; row < height; row++)
            for (int col = 0; col < width; col++)
                if (data[row][col] != data[col][row])
                    return false;

        return true;
    }

    public boolean isSymmetricRecursive() {
        return isSymmetricRecursive(height - 1, width - 1);
    }

    private boolean isSymmetricRecursive(int row, int col) {
        return row < 0 && col < 0 || data[row][col] == data[col][row] && isSymmetricRecursive(row - 1, col - 1);
    }

}

相关问题