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

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() 函数，但我不能得到递归函数。