Python 使用单链表实现简单的稀疏矩阵

#!/usr/bin/python 
# -*- coding: utf-8 -*-

'''
Created on 2015-1-23
@author: beyondzhou
@name: SparseMatrix.py
'''

# Implementation of the Sparse Matrix ADT using an array of linked lists
from myarray import Array


class SparseMatrix:
    # Cleates a sparse matrix of size numRows * numCols initialized to 0
    def __init__(self, numRows, numCols):
        self._numCols = numCols
        self._listOfRows = Array(numRows)

    # Returns the number of rows in the matrix
    def numRows(self):
        return len(self._listOfRows)

    # Returns the number of columns in the matrix
    def numCols(self):
        return self._numCols

    # Returns the value of element (i,j)
    def __getitem__(self, ndxTuple):
        pass

    # Sets the value of element (i,j) to the value s
    def __setitem__(self, ndxTuple, value):
        predNode = None
        curNode = self._listOfRows[ndxTuple[0]]
        while curNode is not None and curNode.col != ndxTuple[1]:
            predNode = curNode
            curNode = curNode.next

        # See if the element is in the list
        if curNode is not None and curNode.col == ndxTuple[1]:
            if value == 0.0:
                if curNode == self._listOfRows[ndxTuple[0]]:
                    self._listOfRows[ndxTuple[0]] = curNode.next
                else:
                    predNode.next = curNode.next
            else:
                curNode.value = value

        # Otherwise, the element is not in the list
        elif value != 0.0:
            newNode = _MatrixElementNode(ndxTuple[1], value)
            newNode.next = curNode
            if curNode == self._listOfRows[ndxTuple[0]]:
                self._listOfRows[ndxTuple[0]] = newNode
            else:
                predNode.next = newNode  

    # Scales the matrix by the given scalar
    def scaleBy(self, scalar):
        for row in range(self.numRows()): 
            curNode = self._listOfRows[row]
            while curNode is not None:
                curNode.value *= scalar
                curNode = curNode.next

    # Creates and returns a new matrix that is the transpose of this matrix
    def transpose(self):
        pass

    # Matrix addition: newMatrix = self + rhsMatrix
    def __add__(self, rhsMatrix):
        # Make sure the two matrices have the correct size
        assert rhsMatrix.numRows() == self.numRows() and \
               rhsMatrix.numCols() == self.numCols(), \
                "Matrix sizes not comatable for adding."

        # Create a new sparse matrix of the same size
        newMatrix = SparseMatrix(self.numRows(), self.numCols())

        # Add the elements of this matrix to the new matrix
        for row in range(rhsMatrix.numRows()):
            curNode = rhsMatrix._listOfRows[row]
            while curNode is not None:
                value = newMatrix[row, curNode.col]
                value += curNode.value
                newMatrix[row, curNode.col] = value
                curNode = curNode.next

        # Return the new matrix
        return newMatrix

    # Matrix subtraction
    def __sub__(self, rhsMatrix):
        # Make sure the two matrices have the correct size
        assert rhsMatrix.numRows() == self.numRows() and \
               rhsMatrix.numCols() == self.numCols(), \
                "Matrix sizes not comatable for adding."

        # Create a new sparse matrix of the same size
        newMatrix = SparseMatrix(self.numRows(), self.numCols())

        # Add the elements of this matrix to the new matrix
        for row in range(rhsMatrix.numRows()):
            curNode = rhsMatrix._listOfRows[row]
            while curNode is not None:
                value = newMatrix[row, curNode.col]
                value -= curNode.value
                newMatrix[row, curNode.col] = value
                curNode = curNode.next

        # Return the new matrix
        return newMatrix

    # Multiplication
    def __mul__(self, rhsMatrix):
        pass

# Storage class for creating matrix element nodes
class _MatrixElementNode:
    def __init__(self, col, value):
        self.col = col
        self.value = value
        self.next = None