Learn Complex Data Structures

                                

# A hash map where keys are state abbreviations and values are state names.
states = {
  'TN': "Tennessee",
  'CA': "California",
  'NY': "New York",
  'FL': "Florida"
}
# Retrieve the value for the key 'CA'
west_coast_state = states['CA']
print(west_coast_state)  # Output: California


                              

                                

# Valid hash map: keys are unique
valid_hash_map = {
  "a" : 1,
  "b" : 2,
  "c" : 3
}
# Invalid hash map: duplicate keys
invalid_hash_map = {
  "a" : 1,
  "a" : 2,
  "b" : 3
}
# Note: Duplicate keys will overwrite previous values.


                              

                                

class TreeNode:
  def __init__(self, value):
    self.value = value  # The node's value
    self.children = []  # List of child nodes
  def add_child(self, child_node):
    self.children.append(child_node)
  def remove_child(self, child_node):
    self.children = [child for child in self.children if child is not child_node]
  def traverse(self):
    nodes_to_visit = [self]
    while nodes_to_visit:
      current_node = nodes_to_visit.pop()
      print(current_node.value)
      nodes_to_visit.extend(current_node.children)

# Example usage:
root = TreeNode('root')
child1 = TreeNode('child1')
child2 = TreeNode('child2')
root.add_child(child1)
root.add_child(child2)
root.traverse()  # Output: root, child1, child2


                              

                                

  class MinHeap:
  def __init__(self):
      self.heap_list = [None]
      self.count = 0

  def retrieve_min(self):
      return self.heap_list[1] if self.count > 0 else None

  def add(self, element):
      self.heap_list.append(element)
      self.count += 1
      self.heapify_up()

  def heapify_up(self):
      idx = self.count
      while idx > 1 and self.heap_list[idx] < self.heap_list[idx // 2]:
          self.heap_list[idx], self.heap_list[idx // 2] = self.heap_list[idx // 2], self.heap_list[idx]
          idx //= 2

  def heapify_down(self):
      idx = 1
      while 2 * idx <= self.count:
          left = 2 * idx
          right = 2 * idx + 1
          smallest = idx

          if left <= self.count and self.heap_list[left] < self.heap_list[smallest]:
              smallest = left
          if right <= self.count and self.heap_list[right] < self.heap_list[smallest]:
              smallest = right
          if smallest == idx:
              break
          self.heap_list[idx], self.heap_list[smallest] = self.heap_list[smallest], self.heap_list[idx]
          idx = smallest



                              

                                

class Vertex:
  def __init__(self, value):
    self.value = value
    self.edges = []
  def add_edge(self, vertex, weight=0):
    self.edges.append((vertex, weight))
  def get_edges(self):
    return self.edges

class Graph:
  def __init__(self, directed=False):
    self.directed = directed
    self.vertices = {}
  def add_vertex(self, vertex):
    self.vertices[vertex.value] = vertex
  def add_edge(self, from_vertex, to_vertex, weight=0):
    self.vertices[from_vertex.value].add_edge(to_vertex, weight)
    if not self.directed:
      to_vertex.add_edge(from_vertex, weight)
  def find_path(self, start_vertex, end_vertex):
    # Placeholder for method to find a path between vertices
    pass

# Example usage:
vertex_a = Vertex('A')
vertex_b = Vertex('B')
graph = Graph()
graph.add_vertex(vertex_a)
graph.add_vertex(vertex_b)
graph.add_edge(vertex_a, vertex_b)