一.排列
在说动态数组之前，先说数组。 数组是顺序存储的线性表，所有元素的内存地址都是连续的。 数组的最大优点是，他的搜索时间复杂度高于o(1)，而添加和删除时间复杂度高于o(1 )
二.动态数组
动态数组，根据用户输入动态扩展或缩小当前数组的容量。 python内置了称为列表的动态数组，List
以下是使用python代码添加/删除/更改动态数组的操作。
# ArrryList.py
class Arr:
#设置默认容量大小和从未找到的元素返回的值(两个始终亮起)
DEFAULT_CAPACITY=10
ELEMENT_NOT_FOUND=-1
#初始化，如果用户没有指定数组大小或小于默认值，则接受默认容量。 否则，容量由用户指定
def __init__(self，capacity=DEFAULT_CAPACITY ) :
capacity=self.default _ capacityifcapacityself.default _ capacityelsecapacity
self._capacity=capacity
self._size=0
self._ elements=[ none ] * self._ capacity
defsize(self ) :
return self._size
defis_empty(self ) :
# returntrueifself._ size==0else false
#改进上述代码。 使用隐式布尔值，因为python可以将所有值转换为布尔值
return self._size==0
检查#元素是否存在---bool
def contains (自，元件) :
#ifself.index_of(element ) :
#返回真
#返回假
returntrueifself.index _ of (element ) else False
#通过添加索引，在添加结束后，判断是否需要扩展
ef add (自、索引、元素) :
self._ out _ of _ 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 (
#添加到数组末尾，添加结束后判断是否需要放大
efadd_last(self，element ) :
自. _ out _ of _ index (self._ size )
self._ elements [ self._ size ]=element
self._size =1
self._expend_capacity (
#根据索引取值
defget (自，索引) :
self._ out _ of _ index (索引)
return self._elements[index]
#根据索引改变值
ef set (自、索引、元素) :
self._ out _ of _ index (索引)
self._elements[index]=element
删除#元素。 如果用户没有指定参数，默认情况下删除最后一个元素，并确定删除后是否缩进
efremove(self，index=ELEMENT_NOT_FOUND ) :
self._ out _ of _ index (索引)
ifindex==self.element _ not _ found :
self._remove_last (
删除#元素后，索引后的每个元素向前移动一个，减少一个数组大小
i=index
while i=self._size:
self._ elements [ I ]=self._ elements [ i1 ]
i =1
self._size -=1
self._reduce_capacity (
#返回与传入的值匹配的第一个索引
ef index _ of (自，元件) :
forindexinrange(self._size1) :
if element==self._ elements [ index ] :
返回索引
return self.ELEMENT_NOT_FOUND
德夫清除(自) :
self._size=0
return self._size
#确定索引是否越界
def_out_of_index(self，index ) :
ifindex0orindexself._ size 1:
raiseindexerror (索引输出框架)。
#容量不足时动态扩展，默认情况下扩展1.5倍
def_expend_capacity(self ) :
#size小于容量时，直接返回。 size正好等于容量，需要扩展容量
if self._ size self._ capacity-1:
返回
self._ capacity=self._ capacity * 2
self._ new _ elements=[ none ] * self._ capacity
forIinrange(self._size ) :
self._ new _ elements [ I ]=self._ elements [ I ]
self._ elements=self._ new _ elements
#动态缩小，默认缩小为当前的一半
def_reduce_capacity(self ) :
如果size小于默认容量或大于当前容量的一半，则直接返回
if self._ size=self._ capacityorself._ size (self._ capacity//2) :
返回
self._ capacity=(self._ capacity//2).__ceil__ () )
forIinrange(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:
布雷克
Arrlist=Arrliststr(I (，)。
num =1
arrlist=arrlist.strip '，')
arrlist='[' arrlist '] '
返回数组列表
''''
删除最后一个元素。 由于最后一个元素也向前移动一个体量，因此它是size-1，但实际上最后一个元素被引用了两次
也就是说，对原始位置的引用将添加到当前数组的末尾，并且不可重用，因此将最后一个元素手动设置为None
''''
def_remove_last(self ) :
self._size -=1
self._ elements [ self._ size ]=none
self._reduce_capacity (
#测试文件，test.py
if __name__=='__main__':
来自阵列导入arr
a=Arr () ) )。
# a=a #类型： 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 .添加(2，' st ' ) )。
# a .移除(2) )。
#print(a.size ) )
#print(a.is_empty ) )
#print(a.contains('55 ) )
#print(a.index_of ) ) )
#print(a.get ) 789 ) )
# a.set (-1，99 ) ) )。
# a.clear () )。
是打印(a )