标签：__init__   复杂度   none   python   列表   添加   import   bre   测试   

一、数组

说动态数组之前，首先要说数组，数组是一种顺序存储的线性表，所有元素的内存地址都是连续的。数组的最大优点是他的查找时间复杂度能够达到O(1)，但是增和删的时间复杂度较高O(n)

二、动态数组

动态数组，即根据用户的输入动态扩充或缩小当前数组的容量。在python中，已经内置了动态数组，叫做列表，List

下面是利用python代码实现动态数组的增删改查操作。

# ArrryList.py
class Arr:
    # 设置两个常亮，分别是默认容量大小与未找到元素返回的值
    DEFAULT_CAPACITY = 10
    ELEMENT_NOT_FOUND = -1

    # 初始化，若用户未指定数组大小或者小于默认，直接使用默认容量，否则容量为用户指定
    def __init__(self, capacity=DEFAULT_CAPACITY):
        capacity = self.DEFAULT_CAPACITY if capacity bool
    def contains(self, element):
        # if self.index_of(element):
        #     return True
        # return False

        return True if self.index_of(element) else False

    # 根据索引添加，添加结束后判断是否需要扩容
    def add(self, index, element):
        self._out_of_index(index)
        self._size = i = self._size + 1
        while i >= index:
            self._elements[i] = self._elements[i - 1]
            i -= 1
        self._elements[index] = element
        self._expend_capacity()

    # 数组末尾追加，添加结束后判断是否需要扩容
    def add_last(self, element):
        self._out_of_index(self._size)
        self._elements[self._size] = element
        self._size += 1
        self._expend_capacity()

    # 根据索引取值
    def get(self, index):
        self._out_of_index(index)
        return self._elements[index]

    # 根据索引改值
    def set(self, index, element):
        self._out_of_index(index)
        self._elements[index] = element

    # 删除元素，若用户未指定参数，默认删除最后一个元素，删除后判断是否要缩容
    def remove(self, index=ELEMENT_NOT_FOUND):
        self._out_of_index(index)
        if index == self.ELEMENT_NOT_FOUND:
            self._remove_last()

        # 删除元素后，该索引后的每个元素都要往前移一格，然后数组大小减一
        i = index
        while i  self._size + 1:
            raise IndexError(‘index out of range‘)

    # 当容量不够时动态扩容，默认为扩大为原来的1.5倍
    def _expend_capacity(self):
        # 当size小于容量，直接返回，当size正好等于容量，需要扩容
        if self._size  (self._capacity // 2):
            return

        self._capacity = (self._capacity // 2).__ceil__()
        for i in range(self._size):
            self._new_elements[i] = self._elements[i]

        self._elements = self._new_elements

    def __str__(self):
        arrlist = ‘‘
        num = 0

        for i in self._elements:
            if num == self._size:
                break
            arrlist = arrlist + str(i) + ‘,‘
            num += 1

        arrlist = arrlist.strip(",")
        arrlist = ‘[‘ + arrlist + ‘]‘
        return arrlist

    """
    删除最后一个元素，因为最后一个元素也是往前移动一格，虽然size-1，但是其实最后一个元素引用了两次，
    即当前的数组末尾加上原来位置的引用，无法回收，所以对于最后一个元素要手动设置为None
    """

    def _remove_last(self):
        self._size -= 1
        self._elements[self._size] = None
        self._reduce_capacity()

# 测试文件,test.py
if __name__ == ‘__main__‘:
    from ArrayList import Arr
    a = Arr()
    # a = a  #type:Arr
    a.add_last(11)
    a.add_last(22)
    a.add_last(33)
    a.add_last(44)
    a.add_last(‘55‘)
    a.add_last(66)
    a.add_last(77)
    a.add_last(88)
    a.add_last(99)
    # a.add(2,‘st‘)
    # a.remove(2)
    # print(a.size())
    # print(a.is_empty())
    # print(a.contains(‘55‘))
    # print(a.index_of(99))
    # print(a.get(789))
    # a.set(-1,99)
    # a.clear()

    print(a)

线性表-数组

标签：__init__   复杂度   none   python   列表   添加   import   bre   测试   

原文地址：https://www.cnblogs.com/chiyun/p/14052671.html