說動態陣列之前，首先要說陣列，陣列是一種順序儲存的線性表，所有元素的記憶體位址都是連續的。陣列的最大優點是他的查詢時間複雜度能夠達到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 < self.default_capacity else capacity
self._capacity = capacity
self._size = 0
self._elements = [none] * self._capacity
def size(self):
return self._size
def is_empty(self):
# return true if self._size == 0 else false
# 改進上面這還**，因為在python中所有值都可以轉布林，所以利用隱式布林值
return self._size == 0
# 檢視元素是否存在--->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:
self._elements[i] = self._elements[i + 1]
i += 1
self._size -= 1
self._reduce_capacity()
# 返回第乙個匹配傳入值的索引
def index_of(self, element):
for index in range(self._size + 1):
if element == self._elements[index]:
return index
return self.element_not_found
def clear(self):
self._size = 0
return self._size
# 判斷索引是否越界
def _out_of_index(self, index):
if index < 0 or index > self._size + 1:
raise indexerror('index out of range')
# 當容量不夠時動態擴容，預設為擴大為原來的1.5倍
def _expend_capacity(self):
# 當size小於容量，直接返回，當size正好等於容量，需要擴容
if self._size < self._capacity - 1:
return
self._capacity = self._capacity * 2
self._new_elements = [none] * self._capacity
for i in range(self._size):
self._new_elements[i] = self._elements[i]
self._elements = self._new_elements
# 動態縮容，預設縮小到當前的一半
def _reduce_capacity(self):
# 當size小於預設容量或者大於當前容量的一半時直接返回
if self._size <= self._capacity or 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)
實現動態陣列
學過c語言的都知道陣列的長度在定義陣列時時固定的，不能在程式執行時發生變化，那麼動態陣列是否和以上的定義相違背？動態陣列的實現步驟 1.先使用malloc函式申請乙個足夠大的位址空間，並返回乙個指標作為首位址 2.將原有陣列的元素按照順序複製到新的位址中 3.將帶加入的元素加入到新的位址中並且時放在...
利用動態陣列生成魔方矩陣
利用動態陣列生成魔方矩陣 難點 魔方效果 如果矩陣大小為10 10，則矩陣內的100個數，為從1到100的整數不重複的隨機排序。效果如下圖所示 主要的兩個函式。srand time null 時間種子 k rand n n 產生隨機數 通過malloc 函式動態分配記憶體，n是待使用者輸入的值。ge...
動態陣列的實現
靜態陣列 編譯階段確定陣列的大小，執行階段不能改變陣列大小。缺點是事先無法準確確定陣列的大小，太小不滿足處理需要，太大浪費記憶體空間。動態陣列 執行階段，根據實際需要動態確定陣列的大小。在 c 語言中，可利用記憶體的申請和釋放庫函式，c語言培訓班 以及指向陣列的指標變數可當陣列名使用的特點，來實現動...