Question

what is the worst-case asymptotic performance of each method?

from Deque import Deque

class Array_Deque(Deque):


  def __init__(self):
    # capacity starts at 1; we will grow on demand.
    self.__capacity = 1
    self.__contents = [None] * self.__capacity
    self.__size = 0
    self.__front = 0
    self.__back = 0
    
  def __str__(self):
    if (self.__size == 0):
      return "[ ]"
    display_string = "[ "
    for i in range(self.__size):
      display_string = display_string + str(self.__contents[(self.__front + i) % self.__capacity])
      if (i != self.__size - 1):
        display_string = display_string + ", "
      
    display_string = display_string + " ]"
    return display_string  
    
    
  def __len__(self):
    return self.__size


  def __grow(self):
    # Note: list ranges exclude the second bound (eg. contents[0:2] contains only the zeroeth and first element.)
    if (self.__front > self.__back):
      self.__contents = self.__contents[self.__front : self.__capacity] + self.__contents[0 : self.__back + 1]
    else:
      self.__contents = self.__contents[self.__front : self.__back + 1]
    self.__front = 0
    self.__back = self.__capacity - 1
    more_room = [None] * self.__capacity    
    self.__capacity = self.__capacity * 2
    self.__contents = self.__contents + more_room #possible improvement remove cata
    
  def push_front(self, val):
    if ((((self.__front -1 + self.__capacity) % self.__capacity) == self.__back) and self.__size != 0):
      self.__grow()
    self.__front = self.__front - 1
    self.__front = (self.__front + self.__capacity) % self.__capacity 
    self.__contents[self.__front] = val
    self.__size = self.__size + 1
    
  def pop_front(self):
    val_popped = [None]
    if (self.__size != 0):
      val_popped = self.__contents[self.__front]
      self.__front = self.__front + 1
      self.__front = self.__front % self.__capacity
      self.__size = self.__size - 1
    return val_popped
    
  def peek_front(self):
    return self.__contents[self.__front]
    
  def push_back(self, val):
    if ((((self.__back + 1) % self.__capacity) == self.__front) and self.__size != 0):
      self.__grow()
    self.__back = self.__back + 1
    self.__back = self.__back % self.__capacity
    self.__contents[self.__back] = val
    self.__size = self.__size + 1
  
  def pop_back(self):
    val_popped = self.__contents[self.__back]
    if (self.__size != 0):
      self.__back = self.__back - 1
      self.__back = (self.__back + self.__capacity) % self.__capacity
      self.__size = self.__size - 1
    return val_popped


  def peek_back(self):
    return self.__contents[self.__back]


# No main section is necessary. Unit tests take its place.
  # if __name__ == '__main__':
  # a = Array_Deque()
  # print(a)
  # a.push_front(1)
  # print(a)
  # b = a.peek_front()
  # print(b)
  # a.pop_front()
  # print(a)
  # a.push_front(1)
  # print(a)
  # a.push_front(2)
  # print(a)
  # a.push_front(3)
  # print(a)
  # c = Array_Deque()
  # print(c)
  # d = c.peek_front()
  # print(d)
  # e = c.pop_front()
  # print(c)
  # print(e)

Answer 1

1) init ---> O(1) as it just initializes the value

2) __str__ ---> O(N) as it returns the string representation of string

3) __len__ ---> O(1) as it just return the length

4) __grow ---> O(1) as it just grows the lists

5) push_front ---> O(1)

6) pop_front ---> O(1)

7) peek_front ---> O(1)

8) push_back ---> O(1)

9) pop_back ---> O(1)

10) peek_back ---> O(1)

Thanks, PLEASE COMMENT if there is any concern.