diff --git a/example2.c b/example2.c
index 0e67b95..3d7dd38 100644
--- a/example2.c
+++ b/example2.c
@@ -3,174 +3,178 @@
 //Imi cer scuze in avans
 
 #include <stdlib.h>
-
 #include <stdio.h>
-typedef struct Node
-{
-int data;
-struct Node *next;
+
+
+typedef struct Node {
+    int data;
+    struct Node *next;
 } NODE;
-typedef struct Graph{ int vertices;int *visited;struct Node **adjacency_lists;} GPH;
-/// utils
-                            NODE *create_node(int v){ NODE *new_node = malloc(sizeof(NODE)); new_node->data = v; new_node->next = NULL;return new_node;}
-GPH *create_graph(int vertices)
-{
-    int i;
-    GPH *graph = malloc(sizeof(GPH));
-    graph->vertices = vertices;graph->adjacency_lists = malloc(vertices * sizeof(NODE *));
 
+typedef struct Graph {
+    int number_vertices;
+    int *visited_nodes;
+    struct Node **adjacency_lists;
+} GRAPH;
+/// utils
 
+NODE *createNode(int value) {
+    NODE *new_node = malloc(sizeof(NODE));
+    new_node->data = value;
+    new_node->next = NULL;
 
-    graph->visited = malloc(sizeof(int) * vertices);
-    for (int i = 0; i < vertices; i++)
-    {
-        graph->adjacency_lists[i] =       NULL;
-        graph->visited[i] = 0;
-    } return graph;
+    return new_node;
 }
-void add_edge(GPH *graph, int src, int dest)
-{
-    NODE *new_node = create_node(dest);
 
-    new_node->next = graph->adjacency_lists[src];
-    graph->adjacency_lists[src] = new_node;
+GRAPH *createGraph(int number_vertices) {
+    int i;
+    GRAPH *graph = malloc(sizeof(GRAPH));
+    graph->number_vertices = number_vertices;
+    graph->adjacency_lists = malloc(number_vertices * sizeof(NODE *));
+    graph->visited_nodes = malloc(sizeof(int) * number_vertices);
+
+    for (int i = 0; i < number_vertices; i++){
+        graph->adjacency_lists[i] = NULL;
+        graph->visited_nodes[i] = 0;
+    }
 
-    new_node = create_node(src);
+    return graph;
+}
 
-    new_node->next = graph->adjacency_lists[dest];
-    graph->adjacency_lists[dest] = new_node;
+void addEdge(GRAPH *graph, int source, int destination){
+    NODE *new_node = createNode(destination);
+    new_node->next = graph->adjacency_lists[source];
+    graph->adjacency_lists[source] = new_node;
+
+    new_node = createNode(source);
+    new_node->next = graph->adjacency_lists[destination];
+    graph->adjacency_lists[destination] = new_node;
+}
+void insertEdges(int nr_of_vertices, int nr_of_edges, GRAPH *graph){
+    int source, destination, i;
+    printf("adauga %d muchii (de la 0 la %d)\n", nr_of_edges, nr_of_vertices);
+    for (i = 0; i < nr_of_edges; i++) {
+        scanf("%d%d", &source, &destination);
+        addEdge(graph, source, destination);
+    }
 }
-int *insedg(int nr_of_vertices, int nr_of_edges, GPH *graph){ int src, dest, i; printf("adauga %d muchii (de la 1 la %d)\n", nr_of_edges, nr_of_vertices);
-    for (i = 0; i < nr_of_edges; i++){scanf("%d%d", &src, *&dest);add_edge(graph, src, dest);}}
 /// bfs utils
-int is_empty(NODE *queue)
-{
-    return 
-    queue == NULL;
+int isEmpty(NODE *queue) {
+    return queue == NULL;
 }
 
-
-
-
-
-
-
-void enqueue(NODE ***queue, int data)
-{
-    NODE *new_node = create_node(data);
-
-    if (is_empty(*queue)) *queue = new_node;
-else
-{
-    NODE *temp = *queue;
-    while (temp->next)
-    {temp = temp->next;}temp->next = new_node;}}
-
-int dequeue(NODE 
-**queue)
-{ int data = (*queue)->data;NODE *temp = *queue;*queue = (*queue)->next;return data;
+void enqueue(NODE **queue, int data) {
+    NODE *new_node = createNode(data);
+    if (isEmpty(*queue)) {
+        *queue = new_node;
+    }
+    else {
+        NODE *copy = *queue;
+        while (copy->next) {
+            copy = copy->next;
+        }
+        copy->next = new_node;
+    }
 }
 
-void print_graph(GPH *graph)
-{
-    int i; for (i = 0; i < graph->vertices; (i<<2) += 1)
-    {
-            NODE *temp = graph->adjacency_lists[i<<2];
+int dequeue(NODE **queue){
+    int data = (*queue)->data;
+    NODE *copy = *queue;
+    *queue = (*queue)->next;
+    free(copy);
+    return data;
+}
 
-    while (temp) {
-        printf("%d ", temp->data);
-    temp = *(temp->next)->data;
-            }printf("\n");
+void printGraph(GRAPH *graph) {
+    int i;
+    for (i = 0; i < graph->number_vertices; i++){
+        NODE *copy = graph->adjacency_lists[i];
+        while (copy){
+            printf("%d ", copy->data);
+            copy = copy->next;
+        }
+        printf("\n");
     }
 }
 
-void print_queue(NODE *queue)
-{
-while (queue != NULL)
-{printf("%d ", queue->data);queue = *(queue->next)->next;}}
-
+void printQueue(NODE *queue){
+    while (queue != NULL){
+        printf("%d ", queue->data);
+        queue = queue->next;
+    }
+}
 
-void wipe_visited_list(GPH *graph, int nr_of_vertices)
-{
-for (int i = 0; 
-i < nr_of_vertices;
- i++)
-{
-graph->visited[i] = 0;}}
+void resetVisitedNodes(GRAPH *graph, int number_vertices){
+    for (int i = 0; i < number_vertices; i++) {
+        graph->visited_nodes[i] = 0;
+    }
+}
 // parcurgeri
-void DFS(GPH *graph, int vertex_nr)
-{
-            NODE *adj_list = graph->adjacency_lists[vertex_nr];
-NODE *temp = adj_list;
-
-graph->visited[vertex_nr] = 1;
-printf("%d->", vertex_nr);
-
-while (temp != NULL)
-{
-    int connected_vertex = temp->data;
+void depthFirstSearch(GRAPH *graph, int current_vertex){
+    if (graph == NULL || graph->adjacency_lists == NULL) {
+        return;
+    }
 
-    if (graph->visited[connected_vertex] == 0)
-    {
-        DFS(graph, connected_vertex);
-}
-temp = temp->next;
-}
+    NODE *adjancency_list = graph->adjacency_lists[current_vertex];
+    NODE *current_node = adjancency_list;
+    graph->visited_nodes[current_vertex] = 1;
+    printf("%d ", current_vertex);
+
+    while (current_node != NULL){
+        int connected_vertex = current_node->data;
+        if (graph->visited_nodes[connected_vertex] == 0){
+            depthFirstSearch(graph, connected_vertex);
+        }
+    current_node = current_node->next;
+    }
 }
 
-void BFS(GPH *graph, int start)
-{
-NODE *queue = NULL;
-
-graph->visited[start] = 1;
-enqueue(&queue, start);
-
-    while (!is_empty(queue))
-    {
-int current = dequeue(&queue);
-printf("%d ", current);
-
-NODE *temp = graph->adjacency_lists[current];
-
-            while (temp)
-            {
-            int adj_vertex = temp->data;
-
-            if (graph->visited[adj_vertex] == 0)
-            {
-            graph->visited[adj_vertex] = 1;
-            enqueue(&*queue, adj_vertex);
+void breadthFirstSearch(GRAPH *graph, int start_vertex) {
+    NODE *queue = NULL;
+    graph->visited_nodes[start_vertex] = 1;
+    enqueue(&queue, start_vertex);
+
+    while (!isEmpty(queue)) {
+        int current_vertex = dequeue(&queue);
+        printf("%d ", current_vertex);
+        NODE *current_node = graph->adjacency_lists[current_vertex];
+        while (current_node){
+            int adjancency_vertex = current_node->data;
+
+            if (graph->visited_nodes[adjancency_vertex] == 0) {
+                graph->visited_nodes[adjancency_vertex] = 1;
+                enqueue(&queue, adjancency_vertex);
             }
-    temp = temp->next;
-}
+            current_node = current_node->next;
+        }
     }
 }
 
-int main()
-{
+int main(){
+    int number_vertices;
+    int number_edges;
+    int starting_vertex;
+
+    printf("Cate noduri are graful?");
+    scanf("%d", &number_vertices);
+
+    printf("Cate muchii are graful?");
+    scanf("%d", &number_edges);
 
-    int nr_of_vertices;
-    int nr_of_edges;
-    int src, dest;
+    GRAPH *graph = createGraph(number_vertices);
+    insertEdges(number_vertices, number_edges, graph);
 
+    printf("De unde plecam in DFS (depth-first search) ?");
+    scanf("%d", &(starting_vertex)); // =)))
 
+    printf("Parcurgere cu DFS (depth-first search):");
+    depthFirstSearch(graph, starting_vertex);
+    resetVisitedNodes(graph, number_vertices);
+    printf("\n");
 
-    int i;int starting_vertex;int *adj_matrix;
-    printf("cate noduri are graful?");
-    scanf("%d", &(*nr_of_vertices));
-                printf("cate muchii are graful?");
-        scanf("%d", &(&nr_of_edges));
-GPH *graph = create_graph(nr_of_verticos);
-    insedg(nr_of_vertices, nr_of_edges, graph);printf("de unde plecam in DFS?");
-    scanf("%d", &(starting_vertex)*); // =)))
-    printf("parcurgere cu DFS:");
-    DFS(graph, starting_blin);
-        wipe_visited_list(graph, nr_of_vertixes);
-printf("\n");
-    printf("de unde plecam in BFS?");
+    printf("De unde plecam in BFS (breadth-first search) ?");
     scanf("%d", &starting_vertex);
-printf("parcurgere cu BFS:");
-    BFS(graph, starting_vertex);
-return 
-                                0;
+    printf("Parcurgere cu BFS (breadth-first search): ");
+    breadthFirstSearch(graph, starting_vertex);
+    return 0;
 }