数组结构

#! /usr/bin/env python
# _*_coding: utf-8 _*_

class Array(object):
    """Represent Array"""
    def __init__(self, capacity, fillValue=None):
        self._items = list()
        for count in range(capacity):
            self._items.append(fillValue)

    def __iter__(self):
        return iter(self._items)

    def __len__(self):
        return len(self._items)

    def __str__(self):
        return str(self._items)

    def __getitem__(self, index):
        return self._items[index]

    def __setitem__(self, index, newItem):
        self._items[index] = newItem


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

from arrays import Array


class DiffGrid(object):
    """定义不规则的Grid"""
    def __init__(self, rows, columns, fillValue=None):
        self.data = Array(rows, 1)
        self._columns = columns
        self._rows = rows
        for row in list(range(rows)):
            self.data[row] = Array(columns[row] + 1, fillValue)

    def getHight(self):
        return self._rows

    def __str__(self):
        result = ""
        for row in range(self.getHight()):
            for column in range(self._columns[row] + 1):
                result += str(self.data[row][column]) + " "
            result += "\n"
        return result
    def __getitem__(self, index):
        return self.data[index]

    def __setitem__(self, row, index, newItem):
        self.data[row][index] = newItem

rows = 9
columns = list(range(9))
dGrid = DiffGrid(rows, columns, 0)
for i in range(rows):
    for j in range(columns[i] + 1):
        dGrid[i][j] = str((i + 1) * (j + 1))
print(dGrid)

columns = [3,3,3]
maxtrix = DiffGrid(3,columns)
for row in range(maxtrix.getHight()):
    for column in range(3):
        maxtrix[row][column] = row*column

print(maxtrix)


class threeDimGrid(object):
    """"""

    def __init__(self, rows, columns, heights, fillValue=None):
        self._rows = rows
        self._columns = columns
        self._heights = heights
        self.data = Array(self._rows)
        for row in range(rows):
            self.data[row] = Array(self._columns)
            for column in range(self._columns):
                self.data[row][column] = Array(self._heights, 0)

    def getRow(self):
        return self._rows

    def __str__(self):
        result = ""
        for row in range(self._rows):
            for column in range(self._columns):
                for height in range(self._heights):
                    result += str(self.data[row][column]) + " "
                result += "\n"
            result += "\n"
        return result
    def __getitem__(self, index):
        return self.data[index]

数组操作的时间复杂度

第i个位置访问	O(1) ，最好和最差情况
第i个位置替换	O(1) ，最好和最差情况
末尾插入	O(1)，平均情况
末尾删除	O(1)，平均情况
第i个位置插入	O(n)， 平均情况
第i个位置删除	O(n)， 平均情况
增加容量	O(n) ，最好和最差情况
减少容量	O(n) ，最好和最差情况

数组的优点

• 随机访问性强（通过下标进行快速定位）
• 查找速度快

数组的缺点

• 插入和删除效率低（插入和删除需要移动数据）
• 可能浪费内存（因为是连续的，所以每次申请数组之前必须规定数组的大小，如果大小不合理，则可能会浪费内存）
• 内存空间要求高，必须有足够的连续内存空间。
• 数组大小固定，不能动态拓展