递归方法没有达到基本情况，但是，我不确定为什么。 爪哇

Question

This is kind of a weird project, so bare with the pretty weird code. The real issue I'm having is why exactly this recursive method is never reaching the base case.

public int determinant() {
    int determinant = 0;
    if(getSize() == 2)
    {
        return (getElement(1, 1) * getElement (2, 2)) - (getElement(1,2) * getElement(2,1));
    }

    determinant += Math.pow(-1, getSize()+1) * getElement(getSize(), 1) * minor(getSize(),1).determinant();
    return determinant;
}

public SparseInterface minor(int row, int col) {
    SparseMatrix minor = new SparseMatrix();
    minor.matrix = matrix;
    for(int i = 0; i < matrix.size(); i++)
    {
        if(row == minor.matrix.get(i).getRow() || col == minor.matrix.get(i).getCol())
        {
            minor.matrix.remove(i);
        }
    }
    minor.size--;
    return minor;
}

So, determinant calls minor, which returns a new square matrix that's size is 1 smaller. I start with a 5x5 matrix, and I call the determinant method on it. That method then takes the determinant of the minor of the 5x5 matrix (a 4x4 matrix). This goes on until we reach the base case, where it is a 2x2 matrix and calculating the determinant is trivial.

However, the issue lies in the fact that the code never gets past the point of it being a 4x4 matrix. Every time that minor gets called (which it should on every recursive call) it should put out smaller matrix, due to the last line of code in minor, minor.size--;.

With some bug testing, it seems that the size of the matrix gets decremented the first time, but not on subsequent recursive calls. I'm somewhat new to Java, does Java have some weird rules in regards to method calls within method calls that is causing it to not get decremented the way it should be? Other than that I am at a loss.

Thanks in advance.

For those who asked:

public int getElement(int row, int col) {
    int element = 0;
    if(row > getSize() || col > getSize())
    {
        System.out.println("Column/row combination is out of bounds.");
        return element;
    }

    for(int i = 0; i < matrix.size(); i++)
    {
        if(matrix.get(i).getRow() == row && matrix.get(i).getCol() == col)
        {
            element = matrix.get(i).getData();
        }
    }
    return element;
}

public int getSize() {
    return size;
}

Size is is just a data member of the class SparseMatrix, that says the weird nonexistent matrix I'm modeling is SizexSize. For more details I wrote about it in the comments below.

public class SparseMatrix implements SparseInterface {
public LinkedList<Index> matrix;
public int size;

public SparseMatrix() {
    matrix = new LinkedList<Index>();
    size = 5;

}

Answer 1

The code is a bit confusing to me. I think you're trying to keep the state of the SparseMatrix object in the minor() method.

I think something like this is what you would be looking for maybe?

The minor.determinant() is a tad bit confusing. Is there a different determinant() method in SparseMatrix ? You were previously returning the SparseMatrix object created in the minor method, and previously had minor(getSize(),1).determinant() . It looks like you're calling the determinant() method inside the SparseMatrix class, but I don't see that method in that class in your code. Are these methods all in the SparseMatrix class?

I would also suggest changing the variable names of your objects to something different than the method names you are using. It reduces readability of your code.

Either way, I think this can get you going.

private SparseMatrix minor = new SparseMatrix();

public int determinant() {
    int determinant = 0;

    if(getSize() == 2)
    {
        return (getElement(1, 1) * getElement (2, 2)) - (getElement(1,2) * getElement(2,1));
    }

    minor(getSize(),1);

    determinant += Math.pow(-1, getSize()+1) * getElement(getSize(), 1) * this.minor.determinant();

    return determinant;
}

public void minor(int row, int col) {
    //in your previous code, I'm not sure where you're getting Matrix from, 
    //so I'll leave this in here - I think you're also wanting to use the 
    //matrix that is now stored in your minor object, so I changed that in
    //the for loop, but there are likely more elegant solutions for this if
    //I saw all the code
    minor.matrix = matrix;

    for(int i = 0; i < this.minor.matrix.size(); i++)
    {
        if(row == this.minor.matrix.get(i).getRow() || col == this.minor.matrix.get(i).getCol())
        {
            this.minor.matrix.remove(i);
        }
    }

    this.minor.size--;
}