4.5 應用：稀疏矩陣

        稀疏矩陣(Sparse Matrix)：一個矩陣中大部分元素都是零元素的矩陣(m × n)，即其非零元素個數k << m × n。

        與稀疏矩陣相反的是稠密矩陣。

        如果採用二維陣列來實現稀疏矩陣，就意味著大部分的記憶體都會用來儲存零元素，這就會造成記憶體的極大浪費，相關操作也會變得低效(?)。

        基於此，本節來考慮使用python列表來實現稀疏矩陣。稀疏矩陣中的每一個非零元素都以儲存類例項存在，其屬性包括所在行、所在列以及相應值，而python列表的每一項就是指向儲存類例項的引用。

        4.1.2 基於列表的實現

#-*-coding: utf-8-*-

# 使用列表實現稀疏矩陣

class SparseMatrix(object):
    def __init__(self, numRows, numCols):
        self._numRows = numRows
        self._numCols = numCols
        self._elementList = list()

    def numRows(self):
        return self._numRows

    def numCols(self):
        return self._numCols

    def __getitem__(self, ndxTuple):
        ndx = self._findPosition(ndxTuple[0], ndxTuple[1])
        if ndx is not None:
            return self._elementList[ndx].value
        else:
            return 0

    def __setitem__(self, ndxTuple, scalar):
        ndx = self._findPosition(ndxTuple[0], ndxTuple[1])
        if ndx is not None: # 當指定索引是非零元素時
            if scalar != 0.0: # 新傳入的值不是0，直接賦值
                self._elementList[ndx].value = scalar
            else: # 新傳入的值為0時，只需從列表中刪除這一項，即表明指定索引的值是0
                self._elementList.pop(ndx)
        else: # 當指定索引是0時
            if scalar != 0.0 # 傳入值非零，即在底層列表中新增一項即可
                element = _MatrixElement(ndxTuple[0], ndxTuple[1], scalar)
                self._elementList.append(element)

    # 數乘運算
    def scaleBy(self, scalar):
        for element in self._elementList:
            element.value *= scalar

    # 矩陣加法
    def __add__(self, other):
        assert other.numRows() == self.numRows() and other.numCols() == self.numCols(), "Matrix sizes not compatible for the add operation."
        newMatrix = SparseMatrix(self.numRows(), self.numCols())
        # 將self中的所有非零項複製到newMatrix中
        for element in self._elementList:
            dupElement = _MatrixElement(element.row, element.col, element.value)
            newMatrix._elementList.append(dupElement)
        # 將other中的所有非零項加到newMatrix中
        for element in other._elementList:
            newMatrix[element.row, element.col] += element.value
        return newMatrix

    # 矩陣減法
    def __sub__(self, other):
        pass

    # 矩陣乘法
    def __mul__(self, other):
        pass

    # 輔助方法
    def _findPosition(self, row, col):
        n = len(self._elementList)
        for i in range(n):
            if row == self._elementList[i].row and col == self._elementList[i].col:
                return i
        return None

# 儲存類，儲存非零元素的值，以及其在矩陣中的位置
class _MatrixElement(object):
    def __init__(self, row, col, value):
        self.row = row
        self.col = col
        self.value = value
 

        值得注意的是，在修改稀疏矩陣的值時，會出現以下四種情況：

• 原值非零，新值非零；
• 原值非零，新值是零；
• 原值是零，新值非零；
• 原值是零，新值是零。

        還要值得注意的是稀疏矩陣的加法運算，程式中首先是建立新的係數矩陣，再將原有的稀疏矩陣所有非零項複製到新的稀疏矩陣中，再將另一個稀疏矩陣中的非零項加進來，最後一步依賴於__gettitem__()和__setitem__()的準確實現。

        4.5.2 效率分析

       假設矩陣是n × n，稀疏矩陣含有k個非零元素，_findPosition()的執行時間是O(k)。__gettitem__()和__setitem__()都呼叫了_findPosition()，所以執行時間都是O(k)，比起矩陣來說要慢。

       但是在構造器方面，矩陣是O(n²)，因為呼叫了clear()，而clear()中含有一個巢狀迴圈，而稀疏矩陣只是構造了一個空列表。

       數乘運算方面，矩陣是每一個元素都乘以相應的數值，需要遍歷每一個元素，所以是O(n²)，而稀疏矩陣只需將列表中每一個值乘以給定的數值即可，因此是O(k)。

       在加法上，矩陣需要遍歷每一個元素，並與對應元素相加，時間是O(n²)，而在稀疏矩陣中，複製所有項需要O(k)，在第二個迴圈中，要注意newMatrix[element.row, element.col]本身就需要O(k)，這一操作又要迴圈k次，所以時間是O(k) + O(k²) = O(k²)。兩者效率的高低要取決於k。