¿Qué es una array dinámica?
Una array dinámica es similar a una array, pero con la diferencia de que su tamaño puede modificarse dinámicamente en tiempo de ejecución. No es necesario especificar el tamaño de una array de antemano. Los elementos de una array ocupan un bloque contiguo de memoria y, una vez creados, su tamaño no se puede cambiar. Una array dinámica puede, una vez que la array está llena, asignar una mayor cantidad de memoria, copiar el contenido de la array original a este nuevo espacio y continuar llenando las ranuras disponibles.
Usaremos una biblioteca integrada llamada ctypes of python. Consulte la documentación para obtener más información, pero básicamente se usará aquí como una array sin procesar del módulo ctypes.
Una nota rápida sobre los métodos públicos frente a los privados, podemos usar un guión bajo _ antes del nombre del método para que no sea público. Por ejemplo:
class M(object): def public(self): print 'Use Tab to see me !' def _private(self): print "You won't be able to Tab to see me !"
m = M() m.public()
Output: Use Tab to see me!
m._private()
Output: You won't be able to see me!
Implementación de lógica de array dinámica:
La clave es proporcionar medios para hacer crecer una array A que almacene los elementos de una lista. En realidad, no podemos hacer crecer la array, su capacidad es fija. Si un elemento se agrega a una lista a la vez, cuando la array subyacente está llena, debemos realizar los siguientes pasos.
- Asigne un nuevo arreglo B con mayor capacidad (una regla comúnmente utilizada para el nuevo arreglo es tener el doble de capacidad que el arreglo existente)
- Establezca B[i]=A[i] , para i=0 a n-1 donde n denota el número actual de artículos.
- Establezca A = B , es decir, de ahora en adelante usamos B como la array de la lista de soporte.
- Inserta un nuevo elemento en la nueva array.
Implementación de código de array dinámica:
import ctypes
class DynamicArray(object):
'''
DYNAMIC ARRAY CLASS (Similar to Python List)
'''
def __init__(self):
self.n = 0 # Count actual elements (Default is 0)
self.capacity = 1 # Default Capacity
self.A = self.make_array(self.capacity)
def __len__(self):
"""
Return number of elements sorted in array
"""
return self.n
def __getitem__(self, k):
"""
Return element at index k
"""
if not 0 <= k <self.n:
# Check it k index is in bounds of array
return IndexError('K is out of bounds !')
return self.A[k] # Retrieve from the array at index k
def append(self, ele):
"""
Add element to end of the array
"""
if self.n == self.capacity:
# Double capacity if not enough room
self._resize(2 * self.capacity)
self.A[self.n] = ele # Set self.n index to element
self.n += 1
def insertAt(self,item,index):
"""
This function inserts the item at any specified index.
"""
if index<0 or index>self.n:
print("please enter appropriate index..")
return
if self.n==self.capacity:
self._resize(2*self.capacity)
for i in range(self.n-1,index-1,-1):
self.A[i+1]=self.A[i]
self.A[index]=item
self.n+=1
def delete(self):
"""
This function deletes item from the end of array
"""
if self.n==0:
print("Array is empty deletion not Possible")
return
self.A[self.n-1]=0
self.n-=1
def removeAt(self,index):
"""
This function deletes item from a specified index..
"""
if self.n==0:
print("Array is empty deletion not Possible")
return
if index<0 or index>=self.n:
return IndexError("Index out of bound....deletion not possible")
if index==self.n-1:
self.A[index]=0
self.n-=1
return
for i in range(index,self.n-1):
self.A[i]=self.A[i+1]
self.A[self.n-1]=0
self.n-=1
def _resize(self, new_cap):
"""
Resize internal array to capacity new_cap
"""
B = self.make_array(new_cap) # New bigger array
for k in range(self.n): # Reference all existing values
B[k] = self.A[k]
self.A = B # Call A the new bigger array
self.capacity = new_cap # Reset the capacity
def make_array(self, new_cap):
"""
Returns a new array with new_cap capacity
"""
return (new_cap * ctypes.py_object)()
# Instantiate arr = DynamicArray() # Append new element arr.append(1) len(arr)
Output: 1
# Append new element arr.append(2) # Check length len(arr)
Output: 2
# Index arr[0]
Output: 1
arr[1]
Output: 2
Impresionante, ¡hicimos nuestra propia array dinámica! Juega con él y observa cómo cambia de tamaño automáticamente.
Publicación traducida automáticamente
Artículo escrito por $augata_debnath y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA