def insert(self, key, value): if key is None or value is None: raise Exception # resizing if more than load factor if (self.item_count / self.array_size) > self.load_factor: self._resize_array() index = cs5112_hash1(key) % self.array_size # if index is not empty, it is either x or real tuple while self._get_array().get(index) is not None: # if it is x, it is removed. add it here. if self._get_array().get(index) == 'x': self._get_array().set(index, (key, value)) self.item_count += 1 break # the key is the same, just update the value elif self._get_array().get(index)[0] == key: self._get_array().set(index, (key, value)) break else: # there is a real, other tuple, move on # wrap-around logic if self.array_size - 1 == index: index = 0 # just probe the next cell else: index += 1 if self.array.get(index) is None: self._get_array().set(index, (key, value)) self.item_count += 1
def remove(self, key): if key is None: raise Exception index = cs5112_hash1(key) % self.array_size end = index while self._get_array().get(index) is not None: if self._get_array().get(index) != 'x' and self._get_array().get( index)[0] == key: value = self._get_array().get(index)[1] self._get_array().set(index, 'x') self.item_count -= 1 return value # wrap-around logic if self.array_size - 1 == index: index = 0 else: # just probe the next cell index += 1 if index == end: return None return None
def get(self, key): if key is None: raise Exception index = cs5112_hash1(key) % self.array_size end = index while self._get_array().get(index) is not None: #check that not removed and is the key if self._get_array().get(index) != 'x' and self._get_array().get( index)[0] == key: return self._get_array().get(index)[1] # wrap-around logic if self.array_size - 1 == index: index = 0 else: # just probe the next cell index += 1 if index == end: return None if self._get_array().get(index) is None: return None
def remove(self, key): # YOUR CODE HERE if (key == None): raise Exception("key cannot be none") hash_slot = cs5112_hash1(key) % self.array_size content_in_slot = self._get_array().get(hash_slot) if (content_in_slot == None): return content_in_slot else: cur_node = content_in_slot.head prev_node = None while (cur_node != None): if (cur_node.get_value()[0] == key): if (prev_node != None): prev_node.set_next(cur_node.get_next( )) ## HOW DO I ALTER THE ORIGINAL LINKED LIST? else: content_in_slot.head = cur_node.get_next() self.item_count = self.item_count - 1 self._get_array().set(hash_slot, content_in_slot) return cur_node.get_value()[1] prev_node = cur_node cur_node = cur_node.get_next() return None
def add_elem(self, elem): p1 = cs5112_hash1(elem) % self.size p2 = cs5112_hash2(elem) % self.size p3 = cs5112_hash3(elem) % self.size self.array.set(p1, True) self.array.set(p2, True) self.array.set(p3, True)
def insert(self, key, value): if key==None or value==None: raise Exception if (self.item_count/self.array_size)>=self.load_factor: self._resize_array() bucket= cs5112_hash1(key) % self.array_size new_node=SLLNode((key, value)) pointer= self.array.get(bucket) if not pointer: self.array.set(bucket, new_node) self.item_count+=1 return else: while pointer.get_next(): if pointer.get_value()[0]== key: pointer.set_value=((key, value)) return pointer=pointer.get_next() if pointer.get_value()[0]== key: pointer.set_value=((key, value)) return else: pointer.set_next(new_node) self.item_count+=1 return
def remove(self, key): if key== None: raise Exception bucket= cs5112_hash1(key) % self.array_size if not self.array.get(bucket): return None pointer= self.array.get(bucket) if pointer.get_value()[0]== key: val= pointer.get_value()[1] self.array.set(bucket, pointer.get_next()) self.item_count-=1 return val while pointer.get_next(): if pointer.get_next().get_value()[0]== key: val= pointer.get_next().get_value()[1] pointer.set_next((pointer.get_next().get_next())) self.item_count-=1 return val pointer=pointer.get_next() return None
def insert(self, key, value): if self.load_factor <= (self.item_count / self.array_size): self._resize_array() # create a new SLL node new_node = SLLNode((key, value)) # pass tuple as value hash_id = cs5112_hash1(key) % self.array_size curr_node = self.array.get(hash_id) # if hashed array elem is empty, set the elem to the new node if not curr_node: self.array.set(hash_id, new_node) self.item_count += 1 return # done, return override = False # otherwise, loop through linked list until the end while curr_node.get_next( ): # when the next node is None, you've reached the end # if the key in curr node == key passed, override the value if curr_node.get_value()[0] == key: curr_node.set_value((key, value)) override = True curr_node = curr_node.get_next() # if you're not overriding, you're adding the new node to the end if not override: curr_node.set_next(new_node) self.item_count += 1
def remove(self, key): # If key is None, raise an Exception if (key == None): raise ValueError("Key can't be None") # Get hash value and mod it hashval = cs5112_hash1(key) % self.array_size node = self.array.get(hashval) # Can't remove it if it doesn't exist if (node == None): return None # If it is the first element of the linked list, set that pointer to the next if (node.get_value()[0] == key): self.array.set(hashval, node.get_next()) self.item_count -= 1 return node.get_value()[1] prevNode = node node = node.get_next() # While 'node' isn't None, search through while (node != None): # If it is found further down the list, set the previous node's # pointer to the next node and return the value if (node.get_value()[0] == key): prevNode.set_next(node.get_next()) self.item_count -= 1 return node.get_value()[1] prevNode = node node = node.get_next() # Else return None return None
def insert(self, key, value): # first search self.item_count += 1 if (self.item_count * 1.0 / self.array_size) > self.load_factor: self._resize_array() hash_key = cs5112_hash1(key) % self.array_size #condtion: hash_key is not empty while self.array.get(hash_key) is not None: # condition 1: rewrite, same key and haven't been deleted if self.array.get( hash_key)[0] == key and not self.array.get(hash_key)[2]: self.item_count -= 1 self.array.set(hash_key, (key, value, False)) return #condition 2: rewrite, same key but been deleted elif self.array.get(hash_key)[0] == key and self.array.get( hash_key)[2]: self.array.set(hash_key, (key, value, False)) return #condition 3: empty space, but still need to search for the rest elif self.array.get(hash_key)[2]: self.array.set(hash_key, (key, value, False)) hash_key = (hash_key + 1) % self.array_size while self.array.get(hash_key) is not None: if self.array.get(hash_key)[0] == key: self.item_count -= 1 self.array.set( hash_key, (key, self.array.get(hash_key)[1], True)) return hash_key = (hash_key + 1) % self.array_size self.array.set(hash_key, (key, value, False)) return
def remove(self, key): try: if key is None: raise TypeError ind = cs5112_hash1(key) % self.array_size head = self.array.get(ind) prev = None print("HEAD = " + str(head)) while head != None: if head.get_value()[0] == key: break prev = head head = head.get_next() if not head: return None self.item_count -= 1 if prev != None: prev.set_next(head.get_next()) else: self.array.set(ind, head.get_next()) return head.get_value()[1] except TypeError: print('Key cannot be None!')
def insert(self, key, value): # check loading factor, if over, resize if self.load_factor <= (self.item_count / self.array_size): self._resize_array() # hash the key hash_ind = cs5112_hash1(key) % self.array_size # loop until an empty index found while self.array.get(hash_ind) != None and self.array.get( hash_ind) != 'removed': # if you hash and get back the key, then update the value if self.array.get( hash_ind)[0] == key: # check the first entry in the tuple self.array.set(hash_ind, (key, value)) # check hash of next index hash_ind = (hash_ind + 1) % self.array_size # loop broken, found None elem, so set it self.array.set(hash_ind, (key, value)) self.item_count += 1
def check_membership(self, elem): h_val1 = cs5112_hash1(elem) % 10 init_h_val2 = cs5112_hash2(elem) h_val2 = init_h_val2 % 10 init_h_val3 = cs5112_hash3(elem) h_val3 = init_h_val3 % 10 i = 1 while h_val2 == h_val1 and i < len(str(init_h_val2)): # h_val2 = int(cs5112_hash2(elem) % (10 ** (i + 1)) / 10 ** i) h_val2 = init_h_val2 % (10 ** (i + 1)) // 10 ** i i += 1 j = 1 while (h_val3 == h_val1 or h_val3 == h_val2) and j < len(str(init_h_val3)): # h_val3 = int(cs5112_hash3(elem) % (10 ** (j + 1)) / 10 **j) h_val3 = init_h_val3 % (10 ** (j + 1)) // 10 ** j j += 1 for ind in [h_val1, h_val2, h_val3]: if not self.array.get(ind): return False return True
def insert(self, key, value): # Raise exception if either key or value is None if (key == None or value == None): raise ValueError("Neither Key nor Value can be None") h = cs5112_hash1(key) % self.array_size # If nothing exists at this location, just insert, increment if self.array.get(h) == None: self.array.set(h, (key, value)) self.item_count += 1 else: # Iterate through the next elements until you reach a None, update if you see the same key while self.array.get(h) != None: if self.array.get(h)[0] == key: self.array.set(h, (key, value)) return h = (h + 1) % self.array_size # Insert value at this None self.array.set(h, (key, value)) self.item_count += 1 # If the load factor now exceeds the limit, resize if ((float(self.item_count) / self.array_size) > self.load_factor): self._resize_array()
def insert(self, key, value): # if key or value is None, raise an Exception if (key == None or value == None): raise ValueError("Neither Key nor Value can be None") # Get the hash value and take the modulus hashval = cs5112_hash1(key) % self.array_size # If there is nothing at that entry in the array, create the first node and inc count if (self.array.get(hashval) == None): newNode = SLLNode((key, value)) self.array.set(hashval, newNode) self.item_count += 1 else: # If something already exists, iterate through and see if any match the key node = self.array.get(hashval) prevNode = None while (node != None): # If so, update the value and don't change the count if (node.get_value()[0] == key): node.set_value((key, value)) return prevNode = node node = node.get_next() # Else at the end add the node and inc the count newNode = SLLNode((key, value), None) prevNode.set_next(newNode) self.item_count += 1 # If the load factor now exceeds the limit, resize if ((float(self.item_count) / self.array_size) > self.load_factor): self._resize_array()
def remove(self, key): hash_id = cs5112_hash1(key) % self.array_size front_node = self.array.get(hash_id) curr_node = front_node prev_node = None saved_value = None # if empty, return None if not curr_node: return None # otherwise, loop until elem is found, and set the prev next node to curr's next node while curr_node: node_key, node_value = curr_node.get_value() # unpack the value # check if keys match if node_key == key: # if prev, then item not in the front if prev_node: prev_node.set_next(curr_node.get_next()) # else: # item is in the front, so set hash elem to the elem after curr node self.array.set(hash_id, curr_node.get_next()) self.item_count -= 1 # decrement count return node_value # return saved value # update pointers prev_node = curr_node curr_node = curr_node.get_next() return None # not found if reaches here
def add_elem(self, elem): # raise NotImplementedError hash1 = cs5112_hash1(elem) % self.size hash2 = cs5112_hash2(elem) % self.size hash3 = cs5112_hash3(elem) % self.size for j in [hash1, hash2, hash3]: self.array.set(j, True)
def remove(self, key): if key is None: raise Exception("Key cannot be None") ind = cs5112_hash1(key) % self.array_size cur_list = self.array.get(ind) ret_val = None # if the list is None, we definitely don't have the value stored if cur_list is None: return None # first item in linked list if cur_list.get_value()[0] == key: ret_val = cur_list.get_value()[1] self.item_count -= 1 self.array.set(ind, cur_list.get_next()) else: # search through the list to see if the key is in it for n in self._iterate_list(cur_list): if n == None: # it isn't in the list return None next_node = n.get_next() if next_node == None: return None k, v = next_node.get_value() if k == key: # found the key, so store the value ret_val = v self.item_count -= 1 n.set_next(next_node.get_next()) return ret_val return ret_val
def add_elem(self, elem): index1 = cs5112_hash1(elem) % self.size index2 = cs5112_hash2(elem) % self.size index3 = cs5112_hash3(elem) % self.size self.array.set(index1, True) self.array.set(index2, True) self.array.set(index3, True)
def get(self, key): index = cs5112_hash1(key) node = self.array.get(index) while node is not None: if node.get_value()[0] == key: return node.get_value()[1] node = node.get_next() return None
def add_elem(self, elem): h1 = cs5112_hash1(elem) % self.size h2 = cs5112_hash2(elem) % self.size h3 = cs5112_hash3(elem) % self.size self.array.set(h1, True) self.array.set(h2, True) self.array.set(h3, True)
def get(self, key): hash_key = cs5112_hash1(key) % self.array_size while self.array.get(hash_key) is not None: if not self.array.get(hash_key)[2] and self.array.get( hash_key)[0] == key: return self.array.get(hash_key)[1] hash_key += 1 return None
def check_membership(self, elem): #TODO: YOUR CODE HERE, delete the line below and implement accordingly if (self.array.get(cs5112_hash1(elem) % 10) and self.array.get(cs5112_hash2(elem) % 10) and self.array.get(cs5112_hash3(elem) % 10)): return True else: return False
def check_membership(self, elem): p1 = cs5112_hash1(elem) % self.size p2 = cs5112_hash2(elem) % self.size p3 = cs5112_hash3(elem) % self.size if not self.array.get(p1) or not self.array.get( p2) or not self.array.get(p3): return False return True
def insert(self, key, value): # YOUR CODE HERE if key == None: raise Exception('Key cannot be None!') if value == None: raise Exception('Value cannot be None!') h = cs5112_hash1(key) % self.array_size while self.array.get(h) != None: if self.array.get(h)[0] == key: self.array.set(h, (key, value)) return h += 1 if h == self.array_size - 1: self._resize_array() h = cs5112_hash1(key) % self.array_size self.array.set(h, (key, value)) if self.item_count / self.array_size >= self.load_factor: self._resize_array()
def add_elem(self, elem): index1 = cs5112_hash1(elem) % self.size index2 = cs5112_hash2(elem) % self.size index3 = cs5112_hash3(elem) % self.size print(index1, index2, index3) # set indices to True self.array.set(index1, True) self.array.set(index2, True) self.array.set(index3, True)
def get(self, key): # YOUR CODE HERE if key == None: raise Exception('Key cannot be None!') h = cs5112_hash1(key) % self.array_size while self.array.get(h) != None: if self.array.get(h)[0] == key: return self.array.get(h)[1] else: h += 1
def check_membership(self, elem): h1 = cs5112_hash1(elem) % self.size h2 = cs5112_hash2(elem) % self.size h3 = cs5112_hash3(elem) % self.size r1 = self.array.get(h1) r2 = self.array.get(h2) r3 = self.array.get(h3) return r1 and r2 and r3
def check_membership(self, elem): hash1 = cs5112_hash1(elem) % self.size hash2 = cs5112_hash2(elem) % self.size hash3 = cs5112_hash3(elem) % self.size if self.array.get(hash1) and self.array.get(hash2) and self.array.get( hash3): return True return False
def check_membership(self, elem): # If elem is None, raise an Exception if (elem == None): raise ValueError("Key can't be None") # Calculate the hashes for a given element. h1 = cs5112_hash1(elem) % self.size h2 = cs5112_hash2(elem) % self.size h3 = cs5112_hash3(elem) % self.size return (self.array.get(h1) and self.array.get(h2) and self.array.get(h3))