Python har inte en inbyggd cirkulär matrisdatastruktur. Du kan emellertid effektivt implementera en med en standard Python -lista och Modulo -operatören (`%`). Här är två tillvägagångssätt:
Metod 1:Använda en lista och Modulo -operatör
Denna metod är den mest enkla och i allmänhet den mest effektiva. Den använder Modulo -operatören för att svepa runt matrisindexen.
`` `python
Klass CircularArray:
def __init __ (själv, kapacitet):
self.kapacitet =kapacitet
self.array =[ingen] * kapacitet
själv.head =0
Självstorlek =0
def is_empty (self):
returnera self.size ==0
def is_full (self):
returnera self.size ==self.kapacitet
def enqueue (själv, artikel):
om self.is_full ():
höja indexError ("Circular Array är full")
self.array [(self.head + self.size) % self.kapacitet] =objekt
Självstorlek +=1
def dequeue (self):
om self.is_empty ():
höja indexError ("Circular Array är tom")
artikel =self.array [self.head]
self.head =(self.head + 1) % self.kapacitet
Självstorlek -=1
returobjekt
def peek (själv):
om self.is_empty ():
höja indexError ("Circular Array är tom")
returnera self.array [self.head]
def __len __ (själv):
returnera självstorlek
def __str __ (själv):
return str (self.array)
#Exempelanvändning
Circular_Array =CircularArray (5)
Circular_Array.enqueue (10)
Circular_Array.enqueue (20)
Circular_Array.enqueue (30)
utskrift (circular_array) # utgång:[10, 20, 30, ingen, ingen]
tryck (circular_array.dequeue ()) # utgång:10
utskrift (circular_array) # utgång:[ingen, 20, 30, ingen, ingen]
Circular_Array.enqueue (40)
Circular_Array.Enqueue (50)
utskrift (circular_array) # utgång:[ingen, 20, 30, 40, 50]
utskrift (circular_array.is_full ()) # utgång:true
`` `
Metod 2:Använda `collections.deque` (för enklare implementering men potentiellt mindre effektiv för stora matriser)
Pythons "Collections.deque" ger en dubbel-slutkö, som kan användas för att efterlikna en cirkulär matris. Det är enklare att implementera men kan vara mindre effektiv för mycket stora matriser jämfört med den direkta listbaserade metoden på grund av omkostnader.
`` `python
från samlingar import deque
Klass CircularArraydeque:
def __init __ (själv, kapacitet):
self.kapacitet =kapacitet
self.array =deque (maxlen =kapacitet)
def is_empty (self):
return len (self.array) ==0
def is_full (self):
return len (self.array) ==self.kapacitet
def enqueue (själv, artikel):
om self.is_full ():
höja indexError ("Circular Array är full")
self.array.append (artikel)
def dequeue (self):
om self.is_empty ():
höja indexError ("Circular Array är tom")
returnera self.array.popleft ()
def peek (själv):
om self.is_empty ():
höja indexError ("Circular Array är tom")
returnera self.array [0]
def __len __ (själv):
return len (self.array)
def __str __ (själv):
return Str (lista (self.array))
#Exempelanvändning (samma som ovan, ersätt bara CircularArray med CircularArrayDeque)
`` `
Vilken metod att välja?
För de flesta fall metod 1 (med en lista och modulooperatör) rekommenderas på grund av dess generellt bättre prestanda, särskilt för större matriser. `Collections.deque` är ett bra alternativ om enkelhet och läsbarhet prioriteras framför råprestanda, och matrisstorleken förväntas inte vara extremt stor. Om du arbetar med verkligt massiva matriser kan du överväga att använda Numpy -matriser för ytterligare prestandaförsvinster, även om det lägger till en annan komplexitetsnivå.
