Kr2.1

semester_1/kr2.1/task2/String/String.c

@@ -0,0 +1,48 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "String.h"
+
+char *getString(size_t * const len, FILE * file, char const endOfLine)
+{
+    *len = 0;
+    size_t capacity = 1;
+    char *s = (char *)malloc(sizeof(char));
+    if (s == NULL)
+    {
+        return NULL;
+    }
+
+    for (char c = fgetc(file); c != endOfLine && c != EOF; c = fgetc(file))
+    {
+        s[(*len)++] = c;
+
+        if (*len >= capacity)
+        {
+            capacity *= 2;
+            char *tmp = (char *)realloc(s, capacity * sizeof(char));
+            if (tmp == NULL)
+            {
+                free(s);
+                return NULL;
+            }
+            s = tmp;
+        }
+    }
+
+    s[*len] = '\0';
+
+    return s;
+}
+
+char *copyString(char const * const string)
+{
+    const size_t len = strlen(string);
+    char *copy = (char *)malloc(len * sizeof(char));
+    if (copy != NULL)
+    {
+        strcpy(copy, string);
+    }
+    return copy;
+}

semester_1/kr2.1/task2/String/String.h

@@ -0,0 +1,8 @@
+#pragma once
+
+#include <stdbool.h>
+#include <string.h>
+#include <stdio.h>
+
+char *getString(size_t * const len, FILE * file, char const endOfLine);
+char *copyString(char const * const string);

semester_1/kr2.1/task2/file.txt

@@ -0,0 +1,7 @@
+5
+6
+1 1 1 0 1 0
+1 0 0 1 0 0
+0 1 0 0 0 1
+0 0 1 0 0 1
+0 0 0 1 1 0

semester_1/kr2.1/task2/graph/graph.c

@@ -0,0 +1,111 @@
+#include <stdbool.h>
+
+#include "graph.h"
+#include "../list/list.h"
+
+typedef struct Edge
+{
+    size_t firstNodeNumber;
+    size_t secondNodeNumber;
+} Edge;
+
+typedef struct Graph
+{
+    size_t edgeAmount;
+    Edge **edges;
+} Graph;
+
+Graph *createGraph(const size_t nodeAmount, const size_t edgeAmount)
+{
+    Graph *graph = calloc(1, sizeof(Graph));
+    if (graph == NULL)
+    {
+        return NULL;
+    }
+
+    Edge **edges = calloc(edges, sizeof(Edge *));
+    if (edges == NULL)
+    {
+        free(graph);
+        return NULL;
+    }
+    graph->edgeAmount = edgeAmount;
+    graph->edges = edges;
+}
+
+void connectNode(Graph *graph, size_t index, size_t nodeNumber)
+{
+    Edge *edge = graph->edges[index];
+    switch (edge->firstNodeNumber == 0)
+    {
+    case false:
+    {
+        edge->firstNodeNumber = nodeNumber;
+        break;
+    }
+
+    case true:
+    {
+        edge->secondNodeNumber = nodeNumber;
+        break;
+    }
+
+    default:
+        break;
+    }
+}
+
+static List **createComponentsTable(Graph *graph, const size_t nodeAmount)
+{
+    List **table = calloc(nodeAmount, sizeof(List *));
+    if (table == NULL)
+    {
+        return NULL;
+    }
+
+    ListErrorCode listErrorCode = okList;
+    for (size_t i = 0; i < graph->edgeAmount; i++)
+    {
+        Edge *currentEdge = graph->edges[i];
+        for (size_t j = 0; j < nodeAmount; ++j)
+        {
+            if (!(checkValue(table[j], currentEdge->firstNodeNumber) || checkValue(table[j], currentEdge->secondNodeNumber)))
+            {
+                listErrorCode = append(table[i], currentEdge->firstNodeNumber);
+                listErrorCode = append(table[i], currentEdge->secondNodeNumber);
+                break;
+            }
+        }   
+    }  
+    return table;
+}
+
+void printComponentsTable(Graph *graph, const size_t nodeAmount)
+{
+    List ** componentsTable = createComponentsTable;
+    if (componentsTable == NULL)
+    {
+
+        return;
+    }
+
+    for (size_t i = 0; i < nodeAmount; ++i)
+    {
+        printList(componentsTable[i]);
+    }
+
+    for (size_t i = 0; i < nodeAmount; ++i)
+    {
+        deleteList(componentsTable[i]);
+    }
+    free(componentsTable);
+}
+
+void deleteGraph(Graph * const graph)
+{
+    for (size_t i = 0; i < graph->edgeAmount; ++i)
+    {
+        free(graph->edges[i]);
+    }
+    free(graph);
+}

semester_1/kr2.1/task2/graph/graph.h

@@ -0,0 +1,10 @@
+#pragma once
+#include <stdlib.h>
+
+typedef struct Graph Graph;
+
+Graph *createGraph(const size_t nodeAmount, const size_t edgeAmount);
+void connectNode(Graph *graph, size_t index, size_t nodeNumber);
+void printComponentsTable(Graph *graph, const size_t nodeAmount);
+void deleteGraph(Graph * const graph);
+

semester_1/kr2.1/task2/list/list.c

@@ -0,0 +1,132 @@
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "list.h"
+
+typedef struct Node
+{
+    int value;
+    struct Node *next;
+} Node;
+
+typedef struct List
+{
+    Node *head;
+} List;
+
+void printList(List const *const list)
+{
+    printf("\n[");
+    for (Node *currentNode = list->head; currentNode != NULL; currentNode = currentNode->next)
+    {
+        printf("%d", currentNode->value);
+        if (currentNode->next != NULL)
+        {
+            printf(", ");
+        }
+    }
+    printf("]\n");
+}
+
+List *createList(void)
+{
+    List *newList = (List *)calloc(1, sizeof(List));
+
+    return newList;
+}
+
+ListErrorCode append(List *const list, int const value)
+{
+    Node **currentNode = list->head;
+    for (; *currentNode != NULL; currentNode = &((*currentNode)->next))
+    {
+        if ((*currentNode)->value == value)
+        {
+            return okList;
+        }
+    }
+
+    Node *newNode = (Node *)calloc(1, sizeof(Node));
+    if (newNode == NULL)
+    {
+        return memoryErrorList;
+    }
+
+    newNode->value = value;
+    *currentNode = newNode;
+    return okList;
+}
+
+void deleteList(List *const list)
+{
+    while (list->head != NULL)
+    {
+        Node *currentNode = list->head;
+        list->head = currentNode->next;
+        free(currentNode);
+    }
+    free(list);
+}
+
+int getValueByIndex(List *list, size_t index, ListErrorCode *listErrorCode)
+{
+    size_t currentIndex = 0;
+    for (Node *currentNode = list->head; currentNode != NULL; currentNode = currentNode->next)
+    {
+        if (currentIndex == index)
+        {
+            *listErrorCode = okList;
+            return currentNode->value;
+        }
+
+        ++currentIndex;
+    }
+    *listErrorCode = indexErrorList;
+    return -1;
+}
+
+const bool checkValue(List *list, int value)
+{
+    for (Node *currentNode = list->head; currentNode != NULL; currentNode = currentNode->next)
+    {
+        if (currentNode->value == value)
+        {
+            return true;
+        }
+    }
+    return false;
+}
+
+ListErrorCode popByIndex(List *const list, size_t const index)
+{
+    Node *temp = list->head;
+    Node *previous = NULL;
+    size_t i = 0;
+    for (Node *currentNode = temp; currentNode != NULL; currentNode = currentNode->next)
+    {
+        if (i == index)
+        {
+            if (i == 0)
+            {
+                list->head = currentNode->next;
+            }
+            else
+            {
+                temp->next = currentNode->next;
+            }
+            free(currentNode);
+            return okList;
+        }
+        ++i;
+        previous = temp;
+        temp = currentNode;
+    }
+
+    if (index == -1)
+    {
+        free(temp);
+        previous->next = NULL;
+        return okList;
+    }
+    return indexErrorList;
+}

semester_1/kr2.1/task2/list/list.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdbool.h>
+
+typedef enum ListErrorCode 
+{
+    okList,
+    memoryErrorList,
+    indexErrorList
+} ListErrorCode;
+
+typedef struct List List;
+
+//creates list
+List *createList(void);
+
+//prints list to console
+void printList(List const * const list);
+
+//appends int value to list
+ListErrorCode append(List *const list, int const value);
+
+//deletes list
+void deleteList(List * const list);
+
+//deletes element
+ListErrorCode popByIndex(List *const list, size_t const index);
+
+//gets value from list by index
+int getValueByIndex(List *list, size_t index, ListErrorCode *listErrorCode);
+
+//checks if value is already in the list
+const bool checkValue(List *list, int value)

semester_1/kr2.1/task2/main.c

@@ -0,0 +1,23 @@
+#include <stdio.h>
+
+#include "workWithFile/workWithFile.h"
+#include "graph/graph.h"
+
+#define PROGRAM_FINISHED_CORRECTLY 0
+#define ERROR_OCCURED 1
+
+#define FILENAME "file.txt"
+
+int main()
+{
+    Graph *graph = NULL;
+    size_t nodeAmount = 0;
+    WorkWithFileErrorCode errorCode = readTableFromFile(FILENAME, &graph, &nodeAmount);
+    if (errorCode != okFile)
+    {
+        return ERROR_OCCURED;
+    }
+
+    printComponentsTable(graph, nodeAmount);
+    return PROGRAM_FINISHED_CORRECTLY;
+}