| Python heeft geen ingebouwde circulaire array-datastructuur. U kunt er echter één efficiënt implementeren met behulp van een standaard Python-lijst en de modulo-operator (`%`). Hier zijn twee benaderingen:
Methode 1:een lijst- en modulo-operator gebruiken
Deze methode is het meest eenvoudig en over het algemeen het meest efficiënt. Het gebruikt de modulo-operator om de indices van de array te omsluiten.
```python
klasse CircularArray:
def __init__(zelf, capaciteit):
zelfcapaciteit =capaciteit
self.array =[Geen] * capaciteit
zelf.hoofd =0
zelf.grootte =0
def is_leeg(zelf):
return self.size ==0
def is_full(zelf):
retourneer self.size ==self.capacity
def enqueue(zelf, item):
als self.is_full():
raise IndexError("Circulaire array is vol")
self.array[(self.head + self.size) % self.capacity] =item
zelf.grootte +=1
def dequeue(zelf):
als self.is_empty():
raise IndexError("Circulaire array is leeg")
item =self.array[self.head]
eigen.hoofd =(eigen.hoofd + 1) % eigen.capaciteit
zelf.grootte -=1
artikel retourneren
def kijkje (zelf):
als self.is_empty():
raise IndexError("Circulaire array is leeg")
retourneer self.array[self.head]
def __len__(zelf):
retourneer zelf.grootte
def __str__(zelf):
return str(self.matrix)
#Voorbeeldgebruik
circulaire_array =CirculaireArray(5)
circular_array.enqueue(10)
circular_array.enqueue(20)
circular_array.enqueue(30)
print(circulaire_array) # Uitvoer:[10, 20, 30, Geen, Geen]
print(circulaire_array.dequeue()) # Uitvoer:10
print(circulaire_array) # Uitvoer:[Geen, 20, 30, Geen, Geen]
circular_array.enqueue(40)
circular_array.enqueue(50)
print(circulaire_array) # Uitvoer:[Geen, 20, 30, 40, 50]
print(circulaire_array.is_full()) # Uitvoer:Waar
```
Methode 2:`collections.deque` gebruiken (voor eenvoudigere implementatie maar mogelijk minder efficiënt voor grote arrays)
Python's `collections.deque` biedt een wachtrij met twee uiteinden, die kan worden gebruikt om een cirkelvormige array na te bootsen. Het is eenvoudiger te implementeren, maar is mogelijk minder efficiënt voor zeer grote arrays in vergelijking met de directe, op lijsten gebaseerde aanpak vanwege overhead.
```python
uit collecties import deque
klasse CircularArrayDeque:
def __init__(zelf, capaciteit):
zelfcapaciteit =capaciteit
self.array =deque(maxlen=capaciteit)
def is_leeg(zelf):
retourneer len(self.array) ==0
def is_full(zelf):
return len(self.array) ==self.capacity
def enqueue(zelf, item):
als self.is_full():
raise IndexError("Circulaire array is vol")
self.array.append(item)
def dequeue(zelf):
als self.is_empty():
raise IndexError("Circulaire array is leeg")
retourneer self.array.popleft()
def kijkje (zelf):
als self.is_empty():
raise IndexError("Circulaire array is leeg")
retourneer self.array[0]
def __len__(zelf):
retourneer len(self.array)
def __str__(zelf):
return str(lijst(self.matrix))
#Voorbeeldgebruik (hetzelfde als hierboven, vervang gewoon CircularArray door CircularArrayDeque)
```
Welke methode moet je kiezen?
In de meeste gevallen Methode 1 (met behulp van een lijst- en modulo-operator) wordt aanbevolen vanwege de over het algemeen betere prestaties, vooral voor grotere arrays. `collections.deque` is een goede optie als eenvoud en leesbaarheid prioriteit krijgen boven ruwe prestaties, en de arraygrootte naar verwachting niet extreem groot zal zijn. Als u met werkelijk enorme arrays werkt, kunt u overwegen om NumPy-arrays te gebruiken voor verdere prestatiewinst, hoewel dat een ander niveau van complexiteit toevoegt. |
