def resize_array(self): """ Resizes table and rehashes data Args: None Returns: None Raises: None Precondition: Unchanged hash table Postcondition: Table is resized and rehashed """ old_hash = self.array # reset stats self.table_size += 2 self.array = build_array(self.table_size) self.count = 0 self.collisions = 0 self.avg_probe_length = 0 self.load = 0 # re-hash old key-value pairs for i in old_hash: if i is not None: self[i.key] = i.value
def __init__(self, maxCapacity=20): """ Keyword Arguments: maxCapacity {int} -- size of array, must not less than 20 (default: {20}) """ if maxCapacity < 20: maxCapacity = 20 self.array = build_array(maxCapacity) self._count = 0
def __init__(self): # initialise base size to 20 ''' Initialises a list for us of chosen size :complexity: O(N) ''' # assert maximum > 0, "Enter a valid number" self.array = build_array(20) self.count = 0 self.max = 20
def __init__(self): """ This is a constructor for class ArrayList. :param: None. :return: None. :exception: NONE. :pre-condition: A array, a counter. :post-condition: An array-based list object with a size 30 will be created. :complexity: O(1) """ self.array = build_array(50) self.count = 0
def __init__(self, table_size): """ Initialises the hash_table with an array storing any given data :param table_size: the size of the hash_table in which array :return: None :raise: ValueError when string is given """ if not self.is_digit(table_size): raise ValueError("Please give a number for table size") self.size = table_size self.hash_table = build_array(table_size) self.count = 0
def resize(self): ''' Resizing a list if :return: self.max :complexity: best case O(1) worst case O(N) ''' if self._is_full(): temp = self.array self.max = self.max * 2 self.array = build_array(self.max) # Now copy values in for i in range(self.count): self.array[i] = temp[i] elif 20 < self.count < int((1 / 8) * self.max): temp = self.array self.max = self.max // 2 self.array = build_array(self.max) # Now copy values in for i in range(self.count): self.array[i] = temp[i] return self.max
def rehash(self, oldhashtable): """ A function that takes the old hash-table and then rehashs every value with a larger hash-table :complexity: Best case O(n) and worst case, n being the size of the list :precondition: A key existing in the table :postcondition: A boolean value of the result :param oldhashtable: the old hash-table to copy from :return: A new hashtable doubled in size """ newsize = self.size * 2 self.size = newsize self.hash_table = build_array(newsize) for item in oldhashtable: if item is not None: self[item[0]] = item[1]
def __init__(self, table_size=31): """ Hash table constructor Args: table_size (int): maximum size of the table Returns: None Raises: No exceptions Precondition: table_size > 0 Postcondition: Creates a hash table instance """ self.array = build_array(table_size) self.table_size = table_size self.count = 0
def __init__(self, size): """ Constructor for ArrayBasedList Args: size (int): maximum size of the list Returns: None Raises: No exceptions Precondition: size cannot be negative Postcondition: len(self.array) <= size Complexity: O(1) """ self.array = build_array(size) self.maxSize = size
def __init__(self): """ Constructor for ArrayBasedList Args: None Returns: None Raises: No exceptions Precondition: initial size of array == 20 Postcondition: max size of array doubles if full, halves if contents occupy less than 1/8 of the max size Complexity: O(1) """ self.array = build_array(20) self.maxSize = 20
def __init__(self, table_size=31): """ Hash table constructor Args: table_size (int): initial maximum capacity of table Returns: None Raises: No exceptions Precondition: table_size > 0 Postcondition: Creates a dynamic hash table instance """ self.array = build_array(table_size) self.table_size = table_size self.count = 0 self.collisions = 0 self.avg_probe_length = 0 self.load = 0
def __init__(self,table_size=31): """ Hash table constructor Args: table_size (int): maximum size of the table Returns: None Raises: No exceptions Precondition: table_size > 0 Postcondition: Creates a hash table instance that tracks collisions and average probe length """ self.array = build_array(table_size) self.table_size = table_size self.count = 0 self.collisions = 0 self.avg_probe_length = 0 self.load = 0
def decrease(self): """ Decreases the size of the array Args: None Returns: None Raises: No exceptions Precondition: maxSize >= 0 Postcondition: maxSize will be halved array is a new array with size maxSize and its previous contents preserved Complexity: O(n) """ self.maxSize //= 2 tmp = self.array self.array = build_array(self.maxSize) for i in tmp: self.append(i)
def __init__(self): self.count = 0 self.array = build_array(100)
def __init__(self,tableSize=31): self.array = build_array(tableSize) self.tableSize = tableSize self.count = 0
def __init__(self, size): self.array = build_array(size) self.maxSize = size self.top = 0
def __init__(self, size): self.array = build_array(size) self.maxSize = size self.rear = 0 self.front = 0
def __init__(self,size): self.array = build_array(size) self.maxSize = size self.currentLen = 0
def __init__(self, max_capacity): assert max_capacity > 0, "Max capacity has to be positive" self.count = 0 self.array = build_array(max_capacity)
def rehash(): new = build_array(ts * 2) for i in range(self.tablesize): if self.array[i] is not None:
def __init__(self,tableSize, probeLengthList = [], count = 0): self.array = build_array(tableSize) self.tableSize = tableSize self.probeLengthList = probeLengthList self.count = count
def __init__(self, size): self.array = build_array(size) self.count = 0 self.top = -1
def __init__(self, max_capacity): assert max_capacity > 0, 'eh?' self.array = build_array(max_capacity) self.count = 0 self.top = -1