Skip to content

Update example2.c #121

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
edyra wants to merge 1 commit into
base: main
Choose a base branch
from
Open

Update example2.c #121

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
278 changes: 141 additions & 137 deletions example2.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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;
}