Python hat keine integrierte Datenstruktur für kreisförmige Array. Sie können jedoch eine mit einer Standard -Python -Liste und dem Modulo -Operator (`%`) effizient implementieren. Hier sind zwei Ansätze:
Methode 1:Verwenden einer Liste und eines Modulo -Operators
Diese Methode ist die einfachste und im Allgemeinen am effizientesten. Es verwendet den Modulo -Operator, um die Indizes des Arrays zu wickeln.
`` `Python
KlassencircularArray:
def __init __ (Selbst, Kapazität):
self.capacity =Kapazität
self.array =[keine] * Kapazität
self.head =0
self.size =0
Def is_empty (Selbst):
return self.size ==0
def is_full (selbst):
return self.size ==self.capacity
Def Enqueue (Selbst, Element):
Wenn self.is_full ():
IndexError erhöhen ("Rundschreiben ist voll")
self.array [(self.head + self.size) % self.capacity] =item
self.size +=1
Def dequeue (Selbst):
Wenn self.is_empty ():
IndexError erhöhen ("Kreisarmarray ist leer")
item =self.array [self.head]
self.head =(self.head + 1) % self.capacity
self.size -=1
Artikel zurückgeben
Def Peek (Selbst):
Wenn self.is_empty ():
IndexError erhöhen ("Kreisarmarray ist leer")
return self.array [self.head]
Def __len __ (Selbst):
Return self.size
Def __str __ (Selbst):
return str (self.array)
#Expample -Verwendung
circular_array =circularArray (5)
Circular_Array.Enqueue (10)
circular_array.enqueue (20)
Circular_Array.Enqueue (30)
print (circular_array) # output:[10, 20, 30, keine, keine]
print (circular_array.dequeue ()) # output:10
print (circular_array) # output:[keine, 20, 30, keine, keine]
circular_array.enqueue (40)
Circular_Array.Enqueue (50)
print (circular_array) # output:[Keine, 20, 30, 40, 50]
print (circular_array.is_full ()) # output:true:true
`` `
Methode 2:Verwenden von `collections.deque` (für eine einfachere Implementierung, aber möglicherweise weniger effizient für große Arrays)
Pythons `collections.deque` bietet eine doppelte Warteschlange, mit der ein kreisförmiges Array nachahmen kann. Es ist einfacher zu implementieren, ist jedoch für sehr große Arrays weniger effizient im Vergleich zum direkten listenbasierten Ansatz aufgrund von Overhead.
`` `Python
aus den Sammlungen importieren Deque
Klasse CircularArraydeque:
def __init __ (Selbst, Kapazität):
self.capacity =Kapazität
self.array =deque (maxlen =Kapazität)
Def is_empty (Selbst):
Return len (self.array) ==0
def is_full (selbst):
RECHEN SIE LEN (SELBSTE.Array) ==Self.Capacity
Def Enqueue (Selbst, Element):
Wenn self.is_full ():
IndexError erhöhen ("Rundschreiben ist voll")
self.array.append (Artikel)
Def dequeue (Selbst):
Wenn self.is_empty ():
IndexError erhöhen ("Kreisarmarray ist leer")
return self.array.popleft ()
Def Peek (Selbst):
Wenn self.is_empty ():
IndexError erhöhen ("Kreisarmarray ist leer")
Return Self.Array [0]
Def __len __ (Selbst):
Rückkehr Len (self.array)
Def __str __ (Selbst):
return str (list (self.array))
#Example -Verwendung (wie oben, ersetzen Sie einfach CircularArray durch CircularArraydeque)
`` `
Welche Methode zu wählen?
In den meisten Fällen Methode 1 (unter Verwendung einer Liste und eines Modulo -Operators) wird aufgrund seiner allgemein besseren Leistung empfohlen, insbesondere für größere Arrays. `collections.deque` ist eine gute Option, wenn Einfachheit und Lesbarkeit gegenüber der Rohleistung priorisiert werden und die Array -Größe nicht extrem groß ist. Wenn Sie mit wirklich massiven Arrays arbeiten, können Sie in Betracht ziehen, Numpy -Arrays für weitere Leistungssteigerungen zu verwenden. Dies ergibt jedoch ein anderes Maß an Komplexität.
