GEEGABYTE1

 from tree import TreeNode

def dfs(root_node, goal, path=(), layers_lst=[], root=None):
    if root == None:
        root = root_node
    path = path + (root_node,)
    current_level_lst=[]
    
    for i in path:
        if not i.value in current_level_lst:

GEEGABYTE1

from Tree import Tree
from collections import deque

def bfs(root, count=0):
    path_queue = deque()
    initial_path = [root]
    path_queue.appendleft(initial_path)

    while path_queue:
        if count == 0 or len(path_queue) == 2:

GEEGABYTE1

def dfs(graph, current_vertex, target, visited=None):
    if visited == None:
        visited = []
    visited.append(current_vertex)
    if current_vertex == target:
        return visited 
    else:
        for neighbour in graph[current_vertex]:
            if not neighbour in visited:
                path = dfs(graph, neighbour, target, visited)

GEEGABYTE1

def bfs(graph, start_vertex, target):
    path = [start_vertex]
    vertex_and_path = [start_vertex, path]
    bfs_queue = [vertex_and_path]
    visited = set()
    paths = {}
    counter = 0

    while bfs_queue:
        print('-'*24)

GEEGABYTE1

## Our graph has been converted into a dictionary in the form of {vertex: [edge1, edge2, edge3, ..., edge n]} ##

### BFS Traversal ###

first_element = list(test_graph.graph_dict.keys())[0]
last_element = list(test_graph.graph_dict.keys())[-1]
lst = list(test_graph.graph_dict[first_element].edges.keys())

for i in range(len(lst)):
    first_edge = lst[0]

GEEGABYTE1

from dfs import dfs 

from inputs import g1, g2

paths = []

def eulerian(*args):
    graphs = args 
    for graph in graphs:
        print("-"*24 + "\n")

GEEGABYTE1

def dfs(graph, current_vertex, edges, last_edge, last_vertex, prev_vertex=None, visited=None):
    edges_vertices = (list(graph.values()))

    lst_values = []
    for lst in edges_vertices:
        lst_values.append(len(lst))
    
    biggest_lst = max(lst_values)
    biggest_edge = None

GEEGABYTE1

def visit_checker(graph):
    for status in list(graph.values()):
        if status == "unvisited":
            return False 
        else:
            continue 
    
    return True  

def traveling_salesperson(graph):

GEEGABYTE1

def sieve_of_eratosthenes(limit):
  true_indices = []
  array = [i for i in range(2, limit + 1)]
  dictionary = {}
  for number in array:
      dictionary[number] = True 
   
  for key, value in dictionary.items():
      if value == False:
          continue 

GEEGABYTE1

import math
 
def sieve_of_eratosthenes (limit):
  
  if (limit <= 1):
    return []

  output = [True] * (limit+1)
 
  output[0] = False