Método 1:Uso de un operador de lista y módulo
Este método es el más sencillo y generalmente el más eficiente. Utiliza el operador Modulo para envolver los índices de la matriz.
`` `Python
clase CircularArray:
def __init __ (self, capacidad):
self.capacity =capacidad
self.array =[ninguno] * Capacidad
self.head =0
self.size =0
def is_empty (self):
devolver self.size ==0
def is_full (self):
return self.size ==self.capacity
Def Enqueue (self, item):
Si self.is_full ()::
elevar indexError ("la matriz circular está llena")
self.array [(self.head + self.size) % self.capacity] =item
self.size +=1
Def dequeue (yo):
if self.is_empty ()::
elevar indexError ("la matriz circular está vacía")
item =self.array [self.head]
self.head =(self.head + 1) % self.capacity
self.size -=1
artículo de devolución
Def Pisek (yo):
if self.is_empty ()::
elevar indexError ("la matriz circular está vacía")
return self.array [self.head]
def __len __ (self):
regresar a sí mismo.
def __str __ (self):
RETURN STR (Self.Array)
#Uso de ejemplo
Circular_Array =CircularArray (5)
Circular_array.enqueue (10)
Circular_array.enqueue (20)
Circular_array.enqueue (30)
Imprimir (Circular_Array) # Salida:[10, 20, 30, ninguno, ninguno]
print (circular_array.dequeue ()) # Salida:10
Imprimir (Circular_Array) # Salida:[Ninguno, 20, 30, Ninguno, Ninguno]
Circular_array.enqueue (40)
Circular_array.enqueue (50)
Imprimir (Circular_Array) # Salida:[Ninguno, 20, 30, 40, 50]
print (circular_array.is_full ()) # Salida:Verdadero
`` `` ``
Método 2:Uso de `colección.deque` (para una implementación más simple pero potencialmente menos eficiente para matrices grandes)
La `colección.deque` de Python proporciona una cola de doble extremo, que puede usarse para imitar una matriz circular. Es más simple de implementar, pero puede ser menos eficiente para matrices muy grandes en comparación con el enfoque directo basado en listas debido a la sobrecarga.
`` `Python
de colecciones importar deque
clase CircularArraydeque:
def __init __ (self, capacidad):
self.capacity =capacidad
self.array =deque (maxlen =capacidad)
def is_empty (self):
return len (self.array) ==0
def is_full (self):
return len (self.array) ==self.capacity
Def Enqueue (self, item):
Si self.is_full ()::
elevar indexError ("la matriz circular está llena")
self.Array.Append (ítem)
Def dequeue (yo):
if self.is_empty ()::
elevar indexError ("la matriz circular está vacía")
return self.Array.popleft ()
Def Pisek (yo):
if self.is_empty ()::
elevar indexError ("la matriz circular está vacía")
devolver self.array [0]
def __len __ (self):
Return Len (self.array)
def __str __ (self):
return str (list (self.array))
Uso de #Ejemplo (igual que arriba, simplemente reemplace CircularArray con CircularArraydeque)
`` `` ``
¿Qué método elegir?
Para la mayoría de los casos, Método 1 (usando un operador de lista y módulo) se recomienda debido a su mejor rendimiento, especialmente para matrices más grandes. `colección.deque` es una buena opción si se priorizan la simplicidad y la legibilidad sobre el rendimiento bruto, y no se espera que el tamaño de la matriz sea extremadamente grande. Si está trabajando con matrices verdaderamente masivas, podría considerar usar matrices numpy para mayores ganancias de rendimiento, aunque eso agrega un nivel diferente de complejidad.