Help with sparse matrix

Question

I need to create a sparse matrix implementation. Only allocate space for non-zero matrix elements. Implement methods for addition, subtraction, multiplication and determinant. Here is how I want to implement it:
Matrix is an array of linked lists.
Each linked list represents a row.
Each entry in the linked list has a value and a column associated with it.
I need help with the setEntry method and creating the array of linked lists.
Here is what I have so far:
import java.io.*;
import java.util.*;
public class Matrix
  private int numberOfRows;
  int numberOfColumns;
  private IntegerNode[][] entries;
  private IntegerNode head = null;
  private static BufferedReader stdin = new BufferedReader(
             new InputStreamReader( System.in ) );
  // Constructor
  public Matrix(int numberOfRows, int numberOfColumns)
    if (numberOfRows <= 0)
      throw new IllegalArgumentException("Cannot construct Matrix with " +
        numberOfRows + " rows.  Number of rows must be positive.");
    if (numberOfColumns <= 0)
      throw new IllegalArgumentException("Cannot construct Matrix with " +
        numberOfColumns + " columns.  Number of columns must be positive.");
    entries = new IntegerNode[numberOfRows][numberOfColumns];
    this.numberOfRows = numberOfRows;
    this.numberOfColumns = numberOfColumns;
  public static void main (String [] args) throws IOException {
       File myFile1 = getFileName();
       Matrix myMatrix1 = Matrix.readMatrixFromFile(myFile1, "Matrix 1");
       File myFile2 = getFileName();
       Matrix myMatrix2 = Matrix.readMatrixFromFile(myFile2, "Matrix 2");
       System.out.println();
       System.out.println("Printing out Matrix 1");
       System.out.println("---------------------");
       myMatrix1.print();
       System.out.println("Printing out Matrix 2");
       System.out.println("---------------------");      
       myMatrix2.print();
       String myOperation = getAction();
       Matrix.performActionOnMatrices(myMatrix1, myMatrix2, myOperation);        
   public static Matrix readMatrixFromFile(File file, String fname)
    throws IOException
    BufferedReader reader =
      new BufferedReader(new FileReader(file));
    // first line should be number of rows followed by number of columns
    String line = reader.readLine();
    if (line == null)
      throw new IOException("File \"" + file + "\" is empty.");
    int[] dimensions = readInts(line, 2);
    System.out.println("The dimensions of " + fname + " are " + dimensions[0] + " by " +
      dimensions[1] + ".");
    Matrix matrix = new Matrix(dimensions[0], dimensions[1]);
       for (int row = 0; row < dimensions[0]; ++row) {           
            line = reader.readLine();
            if (line == null)
                 throw new IOException("Matrix in file should have " + dimensions[0] + " rows.");
            int[] rowValues = readInts(line, dimensions[1]);
            for (int column = 0; column < dimensions[1]; ++column)
                 matrix.setEntry(row, column, rowValues[column]);
    return matrix;
  public static String getAction() throws IOException {
       System.out.println("What operation would you like to perform on these matrices? (add, subtract, multiply, or determinant) ... ");
       String actionToTake = stdin.readLine();
       return actionToTake;
  public static File getFileName() throws IOException {
       System.out.println( "Please enter the full path and name of a file that contains a valid matrix ... " );
       String fname = stdin.readLine();
       File someFile = new File(fname);
       return someFile;      
  public static void performActionOnMatrices(Matrix matrix1, Matrix matrix2, String action) {
       if ((!action.equals("add")) && (!action.equals("subtract")) && (!action.equals("multiply")) && (!action.equals("determinant"))) {
           throw new IllegalArgumentException("The only valid actions are add, subtract, multiply or determinant.");           
       if (action.equals("add")) {
            if ((matrix1.numberOfRows != matrix2.numberOfRows) || (matrix1.numberOfColumns != matrix2.numberOfColumns)) {
                throw new IllegalArgumentException("The matrices must contain the same number of rows and columns in order to perform addition on them.");           
            System.out.println("Performing addition on the two matrices...");
            Matrix addMatrix = Matrix.add(matrix1, matrix2);
            System.out.println("Here is the sum of the two matrices:");
            System.out.println("------------------------------------------");
            addMatrix.print();
       } else if (action.equals("subtract")) {
            if ((matrix1.numberOfRows != matrix2.numberOfRows) || (matrix1.numberOfColumns != matrix2.numberOfColumns)) {
                throw new IllegalArgumentException("The matrices must contain the same number of rows and columns in order to perform subtraction on them.");           
            System.out.println("Performing subtraction on the two matrices...");
            Matrix subtractMatrix = Matrix.subtract(matrix1, matrix2);
            System.out.println("Here is the result of the subtraction:");
            System.out.println("---------------------------------------------");
            subtractMatrix.print();           
       } else if (action.equals("multiply")) {
            if ((matrix1.numberOfRows != matrix2.numberOfRows) || (matrix1.numberOfColumns != matrix2.numberOfColumns)) {
                throw new IllegalArgumentException("The matrices must contain the same number of rows and columns in order to perform multiplication on them.");           
            if (matrix1.numberOfRows != matrix2.numberOfColumns) {
                throw new IllegalArgumentException("The number of rows in the first Matrix must equal the number of columns in the second for multiplying.");                       
            System.out.println("Performing multiplication on the two matrices...");
            Matrix multMatrix = Matrix.multiply(matrix1, matrix2);
            System.out.println("Here is the product of the two matrices:");
            System.out.println("------------------------------------------");
            multMatrix.print();
       }     else if (action.equals("determinant")) {
            int det1 = matrix1.determinant();
            System.out.println("Determinant of Matrix 1");
            System.out.println("-----------------------");     
            System.out.println(det1);
            System.out.println();
            int det2 = matrix2.determinant();
            System.out.println("Determinant of Matrix 2");
            System.out.println("-----------------------");     
            System.out.println(det2);
            System.out.println();           
  //  Sets the entry in the matrix at the given row & column to
  //    the given value.
  public void setEntry(int row, int column, int value)
    if ((row < 0) || (row >= numberOfRows))
      throw new IllegalArgumentException("Illegal row index " + row +
        ".  Index should be between 0 and " + (numberOfRows-1));
    if ((column < 0) || (column >= numberOfColumns))
      throw new IllegalArgumentException("Illegal column index " + column +
        ".  Index should be between 0 and " + (numberOfColumns-1));
    //if (value != 0) {
         IntegerNode newNode = new IntegerNode();
         newNode.setItem(value);
         entries[row][column] = newNode;
  //  Returns the matrix entry at the given row & column
  public IntegerNode getEntry(int row, int column)
    if ((row < 0) || (row >= numberOfRows))
      throw new IllegalArgumentException("Illegal row index " + row +
        ".  Index should be between 0 and " + (numberOfRows-1));
    if ((column < 0) || (column >= numberOfColumns))
      throw new IllegalArgumentException("Illegal column index " + column +
        ".  Index should be between 0 and " + (numberOfColumns-1));
    return entries[row][column];
  //  A primitive routine to print the matrix.  It doesn't do
  //    anything smart or nice about spacing.
  public void print()
    for (int row = 0; row < numberOfRows; ++row)
      for (int column = 0; column < numberOfColumns; ++column)
           if (getEntry(row,column) != null) {
                System.out.print(getEntry(row, column).getItem() + " ");
      System.out.println();
    System.out.println();
  public void linkNodesInEachRow()
       int counter;
       for (int row = 0; row < numberOfRows; ++row)
         counter = 0;
         for (int column = 0; column < numberOfColumns; ++column)
              if (getEntry(row,column) != null) {
                   counter++;
                   if (counter == 1) {
                        head = new IntegerNode();
                        head.setItem(getEntry(row, column).getItem());
                   } else {
                   //System.out.print("ITEM NUMBER " + counter + " = ");
                   //System.out.println(getEntry(row, column).getItem() + " ");
         System.out.println();
    System.out.println();
       /*for (IntegerNode curr = head; curr != null; curr = curr.getNext()) {
            System.out.println(curr.getItem());
  //  Returns the determinant of the matrix.
  //  This method checks that the matrix is square and throws
  //    an exception if not.
  public int determinant()
     int determinantValue = 0;
     int counter;
     int plusminus = 1; // start with positive value
     // Make sure the matrix is square before proceeding with
    //   determinant calculation
    if (numberOfRows != numberOfColumns)
      // should really create a MatrixException type
      throw new IllegalArgumentException(
        "Cannot compute determinant of non-square (" + numberOfRows +
        " by " + numberOfColumns + ") matrix.");
    } else {
         // the matrix has the same number of rows and columns 
         if (numberOfColumns == 1)
              // the matrix is 1x1 - the determinant is just it's value
              return entries[0][0].getItem();
         else if (numberOfColumns == 2)
              // the matrix is 2x2 - return ad - bc
              return entries[0][0].getItem() * entries[1][1].getItem() - entries[0][1].getItem() * entries[1][0].getItem();
         else
              // the matrix is larger than 2x2
              // loop through the columns in the matrix
              for (counter = 0; counter < numberOfColumns; counter++)
                   determinantValue += plusminus * entries[0][counter].getItem() * minor(0, counter).determinant(); // The determinant is the sum of all the n possible signed products formed from the matrix using each row and each column only once for each product.  Notice the recursive call using the submatrix.
                   plusminus *= -1;  // switch the plus/minus sign of the multiplier on each iteration through the loop
         return determinantValue;
// returns a matrix representing the minor of the matrix
// for the specified row and column
public Matrix minor(int row, int column)
    int rowsA;
    int rowsB;
    int colsA;
    int colsB;
    // decrease the size of the resultant matrix by 1 row and 1 column
    Matrix smallerMatrix = new Matrix (numberOfRows - 1, numberOfColumns - 1);
    // scroll through the rows and columns in the original Matrix
    // copy all of the values from the original Matrix except the one row and column that were passed in
    for (rowsA=0, rowsB=0; rowsA < numberOfRows; rowsA++)
       if (rowsA != row)
          for (colsA=0, colsB=0; colsA < numberOfColumns; colsA++)
             if (colsA != column)
                 // the current row and column do not match the row and column we wish to remove
                 // set the values in the appropriate positions of the sub matrix
                smallerMatrix.setEntry(rowsB, colsB, entries[rowsA][colsA].getItem());
                colsB++;
          rowsB++;
    return smallerMatrix;     
  //  Used to parse the row of ints provided in the file input to
  //    this program.  Given a string containing at least numberToRead
  //    ints, it creates and returns an int array contaning those
  //    ints.
  private static int[] readInts(String someInts, int numberToRead)
    StringTokenizer tokenizer = new StringTokenizer(someInts);
    if (numberToRead < 0)
      throw new IllegalArgumentException("Cannot read " + numberToRead
        + " ints.  numberToRead must be nonnegative.");
    int[] toReturn = new int[numberToRead];
    for (int i = 0; i < numberToRead; ++i)
      if (!tokenizer.hasMoreTokens())
        throw new IllegalArgumentException("Cannot read " + numberToRead +
          " ints from string \"" + someInts + "\".");
      String token = tokenizer.nextToken();
      toReturn[i] = Integer.parseInt(token);
    return toReturn;
  public static Matrix add (Matrix a, Matrix b)
       Matrix result = new Matrix(a.numberOfRows, a.numberOfColumns);
      for(int i = 0; i < a.numberOfRows; i++)
         for(int j = 0; j < a.numberOfColumns; j++)
             int value = a.getEntry(i, j).getItem() + b.getEntry(i, j).getItem();
             result.setEntry(i, j, value);
      System.out.println("Addition complete.");
      return result;
  public static Matrix subtract (Matrix a, Matrix b)
       Matrix result = new Matrix(a.numberOfRows, a.numberOfColumns);
       for(int i = 0; i < a.numberOfRows; i++)
         for(int j = 0; j < a.numberOfColumns; j++)
             int value = a.getEntry(i, j).getItem() - b.getEntry(i, j).getItem();
             result.setEntry(i, j, value);
      System.out.println("Subtraction complete.");
      return result;
  public static Matrix multiply (Matrix a, Matrix b)
      Matrix result = new Matrix(a.numberOfRows, b.numberOfColumns);
      int colSum = 0;
      for(int i = 0; i < a.numberOfRows; i++)
          for(int j = 0; j < b.numberOfColumns; j++)
              colSum = 0;
              for(int k = 0; k < a.numberOfColumns; k++)
                 colSum += a.getEntry(i,k).getItem() * b.getEntry(k,j).getItem();
              result.setEntry(i, j, colSum);
      System.out.println("Multiplication complete.");
      return result;
  public class IntegerNode {
          private int item;
          private IntegerNode next;
          public void setItem(int newItem) {
               item = newItem;
          public int getItem() {
               return item;
          public void setNext(IntegerNode nextNode) {
               next = nextNode;
          public IntegerNode getNext() {
               return next;
}

Answer 1

Please help. The code runs just fine. The only thing is I need to link the nodes together (for each row) into a linked list and then put each linked list into an array. I need help with setEntry. The details of creating a node, attaching it to the list representing a row, etc. need to be in setEntry. Please help.
For the following matrix:
1 4 5
4 2 5
2 1 2
There is an array of three linked lists.
LinkedListsArray[0] = Entry(value=1, column=0)->Entry(value=4, column=1)->Entry(value=5, column=2)
LinkedListsArray[1] = Entry(value=4, column=0)->Entry(value=2, column=1)->Entry(value=5, column=2)
LinkedListsArray[2] = .....
Each entry is a node in the linked list.
The last twist is that if any values are zero, they shouldn't have nodes associated with them. Don't allocate nodes for zero valued entries.