Exercitii

Exercitiul_1.c

@@ -0,0 +1,162 @@
+/*Determinati daca exista sau nu drum intre doua restaurante dintr-o retea de tip graf*/
+
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef struct Node
+{
+    int data;
+    struct Node *next;
+} NODE;
+// pentru simplitate, folosim int uri pt a numi restaurantele/locatiile
+// ex: 1 - restaurantul 1 si tot asa
+
+typedef struct Graph
+{
+    int number_of_restaurants;
+    int *visited_restaurants;
+    struct Node **adjacency_list;
+} GPH;
+
+typedef struct Stack
+{
+    int t;
+    int scap;
+    int *stack_array;
+} STK;
+
+NODE *create_node(int value)
+{
+    NODE *node = malloc(sizeof(NODE));
+    node->data = value;
+    node->next = NULL;
+    return node;
+}
+
+void add_edge(GPH *graph, int source, int destination)
+{
+    NODE *node = create_node(destination);
+    node->next = graph->adjacency_list[source];
+    graph->adjacency_list[source] = node;
+
+    node = create_node(source);
+    node->next = graph->adjacency_list[destination];
+    graph->adjacency_list[destination] = node;
+}
+
+GPH *create_graph(int node_number)
+{
+    GPH *graph = malloc(sizeof(GPH));
+    graph->number_of_restaurants = node_number;
+    graph->adjacency_list = malloc(node_number * sizeof(NODE *)); // CORECTAT
+    graph->visited_restaurants = malloc(node_number * sizeof(int));
+
+    for (int i = 0; i < node_number; i++)
+    {
+        graph->adjacency_list[i] = NULL;
+        graph->visited_restaurants[i] = 0;
+    }
+    return graph;
+}
+
+STK *create_stack(int scap)
+{
+    STK *s = malloc(sizeof(STK));
+    s->stack_array = malloc(scap * sizeof(int));
+    s->t = -1;
+    s->scap = scap;
+    return s;
+}
+
+void push(int pushed_value, STK *stack)
+{
+    stack->t = stack->t + 1;
+    stack->stack_array[stack->t] = pushed_value;
+}
+
+void visit_restaurants_DFS(GPH *graph, STK *stack, int current_restaurant)
+{
+    NODE *adj_list = graph->adjacency_list[current_restaurant];
+    NODE *aux = adj_list;
+
+    graph->visited_restaurants[current_restaurant] = 1;
+    printf("%d -> ", current_restaurant);
+    push(current_restaurant, stack);
+    while (aux != NULL)
+    {
+        int near_restaurant = aux->data;
+        if (graph->visited_restaurants[near_restaurant] == 0)
+        {
+            visit_restaurants_DFS(graph, stack, near_restaurant);
+        }
+        aux = aux->next;
+    }
+}
+
+void insert_edges(GPH *graph, int edge_number, int node_number)
+{
+    int source, destination, i;
+    printf("adauga %d muchii (de la 1 la %d)\n",
+           edge_number, node_number);
+    for (i = 0; i < edge_number; i++)
+    {
+        scanf("%d%d", &source, &destination);
+        add_edge(graph, source, destination);
+    }
+}
+
+void wipe(GPH *graph, int node_number)
+{
+    for (int i = 0; i < node_number; i++)
+    {
+        graph->visited_restaurants[i] = 0;
+    }
+}
+
+void could_it_be_visited(GPH *graph, int node_number) // 0 sau 1 - daca poate fi sau nu ajuns PENTRU GRAPH->VISITED_RESTAURANTS + AFISARI ADECVATE (completare)
+{
+    for (int i = 0; i < node_number; i++)
+    {
+        STK *stack = create_stack(node_number);
+        wipe(graph, node_number);
+        printf("\n");
+        visit_restaurants_DFS(graph, stack, i);
+        for (int j = 0; j < node_number; j++)
+        {
+            if (i != j)
+            {
+                if (graph->visited_restaurants[j])
+                {
+                    printf("\nExista drum intre restaurantele %4d si %d", i, j);
+                }
+                else
+                {
+                    printf("\nNU exista drum intre restaurantele %d si %d", i, j);
+                }
+            }
+        }
+        free(stack->stack_array);
+        free(stack);
+        printf("\n");
+    }
+}
+
+int main()
+{
+    int node_number;
+    int edge_number;
+
+    printf("cate noduri are graful? ");
+    scanf("%d", &node_number);
+
+    printf("cate muchii are graful? ");
+    scanf("%d", &edge_number);
+
+    GPH *graph = create_graph(node_number);
+
+    insert_edges(graph, edge_number, node_number);
+
+    could_it_be_visited(graph, node_number);
+}
+//Modificari mai importante aduse functiei canbe() (actuala could_it_be_visited())
+//A se citi detaliile din fisierul pdf!

Exercitiul_2.c

@@ -0,0 +1,205 @@
+#include <stdlib.h>
+#include <stdio.h>
+
+
+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 *));
+
+    graph->visited = malloc(sizeof(int) * vertices);
+    for (int i = 0; i < vertices; i++)
+    {
+        graph->adjacency_lists[i] = NULL;
+        graph->visited[i] = 0;
+    } 
+    return graph;
+}
+
+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;
+
+    new_node = create_node(src);
+
+    new_node->next = graph->adjacency_lists[dest];
+    graph->adjacency_lists[dest] = new_node;
+}
+
+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;
+}
+
+void enqueue(NODE *queue, int data)//trei stelute
+{
+    NODE *new_node = create_node(data);
+
+    if (is_empty(queue))//*queue 
+        queue = new_node;
+    else
+    {
+        NODE *temp = queue;//steluta
+
+        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 print_graph(GPH *graph)
+{
+    int i; 
+    for (i = 0; i < graph->vertices; i += 1) ///(i<<2) +=1)
+    {
+            NODE *temp = graph->adjacency_lists[i];
+
+            while (temp) {
+                printf("%d ", temp->data);
+                temp = (temp->next);
+            }
+            printf("\n");
+    }
+}
+
+void print_queue(NODE *queue)
+{
+    while (queue != NULL)
+    {
+        printf("%d ", queue->data);
+        queue = (queue->next)->next;
+    }
+}
+
+void wipe_visited_list(GPH *graph, int nr_of_vertices)
+{
+    for (int i = 0; i < nr_of_vertices; i++)
+    {
+        graph->visited[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;
+
+        if (graph->visited[connected_vertex] == 0)
+        {
+            DFS(graph, connected_vertex);
+        }
+    temp = temp->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);
+            }
+            temp = temp->next;
+        }
+    }
+}
+
+int main()
+{
+    int nr_of_vertices;
+    int nr_of_edges;
+    int src, dest;
+
+    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_vertices);
+    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_vertex);
+    wipe_visited_list(graph, nr_of_vertices);
+    printf("\n");
+    printf("de unde plecam in BFS?");
+    scanf("%d", &starting_vertex);
+    printf("parcurgere cu BFS:");
+    BFS(graph, starting_vertex);
+
+
+    return 0;
+}