Metodo 1:utilizzando un elenco e un operatore di modulo
Questo metodo è il più semplice e generalmente più efficiente. Utilizza l'operatore di modulo per avvolgere gli indici dell'array.
`` `Python
Classe Circulararay:
def __init __ (self, capacità):
auto -papacità =capacità
self.array =[nessuno] * Capacità
Self.head =0
self.size =0
def is_empty (self):
restituire self.size ==0
def is_full (self):
restituire self.size ==Self.Capacity
def enqueue (self, oggetto):
if self.is_full ():
Aumenta Indexerror ("L'array circolare è pieno")
self.array [(self.head + self.size) % self.capacity] =oggetto
Self.size +=1
def dequeue (self):
if self.is_empty ():
Aumenta Indexerror ("L'array circolare è vuoto")
oggetto =self.array [self.head]
Self.head =(self.head + 1) % self.capacity
Self.size -=1
Articolo di ritorno
Def Peek (Self):
if self.is_empty ():
Aumenta Indexerror ("L'array circolare è vuoto")
restituire self.array [self.head]
def __len __ (self):
restituire autocontrollo
def __str __ (self):
return str (self.array)
#Esempio di utilizzo
circolar_array =circolarrray (5)
circolare_array.enqueue (10)
Circular_array.enqueue (20)
circolare_array.enqueue (30)
Stampa (circolar_array) # output:[10, 20, 30, nessuno, nessuno]
print (circolar_array.dequeue ()) # output:10
Stampa (circolar_array) # output:[Nessuno, 20, 30, nessuno, nessuno]
circolare_array.enqueue (40)
circolar_array.enqueue (50)
Stampa (circolar_array) # output:[Nessuno, 20, 30, 40, 50]
print (circolar_array.is_full ()) # output:true
`` `
Metodo 2:usando `raccoltes.deque` (per implementazione più semplice ma potenzialmente meno efficiente per array di grandi dimensioni)
Python's `Collections.Deque` fornisce una coda a doppia estremità, che può essere utilizzata per imitare un array circolare. È più semplice da implementare, ma potrebbe essere meno efficiente per array molto grandi rispetto all'approccio basato sull'elenco diretto a causa delle spese generali.
`` `Python
Dalle collezioni Importa Deque
Classe CirculaRraydeque:
def __init __ (self, capacità):
auto -papacità =capacità
self.array =deque (maxlen =capacità)
def is_empty (self):
return len (self.array) ==0
def is_full (self):
return len (self.array) ==Self.capacity
def enqueue (self, oggetto):
if self.is_full ():
Aumenta Indexerror ("L'array circolare è pieno")
self.array.append (articolo)
def dequeue (self):
if self.is_empty ():
Aumenta Indexerror ("L'array circolare è vuoto")
restituire self.array.popleft ()
Def Peek (Self):
if self.is_empty ():
Aumenta Indexerror ("L'array circolare è vuoto")
return self.array [0]
def __len __ (self):
return len (self.array)
def __str __ (self):
return str (elenco (self.array))
#Esempio di utilizzo (uguale a quello sopra, basta sostituire CircularArray con CircularArraydeque)
`` `
Quale metodo scegliere?
Per la maggior parte dei casi, Metodo 1 (usando un elenco e un operatore di modulo) è raccomandato a causa delle sue prestazioni generalmente migliori, in particolare per array più grandi. `Collections.deque` è una buona opzione se la semplicità e la leggibilità sono prioritarie sulle prestazioni grezze e la dimensione dell'array non dovrebbe essere estremamente grande. Se stai lavorando con array davvero enormi, potresti prendere in considerazione l'uso di array numpy per ulteriori guadagni delle prestazioni, anche se questo aggiunge un diverso livello di complessità.
Programmazione © www.354353.com