Exercice 3

ex3/ex3.c

@@ -16,30 +16,343 @@
 #include <stdlib.h>
 #include <string.h>
 
+// LinkedListNode.h
+
+typedef struct LinkedListNode {
+    struct LinkedListNode *next;
+    char value;
+} LinkedListNode;
+
+LinkedListNode *linked_list_node_init(LinkedListNode *next, char value);
+void linked_list_node_destroy(LinkedListNode **node);
+
+// LinkedListNode.c
+
+LinkedListNode *linked_list_node_init(LinkedListNode *next, char value) {
+    LinkedListNode *node = (LinkedListNode *)malloc(sizeof(LinkedListNode));
+    node->next = next;
+    node->value = value;
+    return node;
+}
+
+void linked_list_node_destroy(LinkedListNode **node) {
+    free(*node);
+    *node = NULL;
+}
+
+// LinkedList.h
+
+typedef struct {
+    LinkedListNode *root;
+} LinkedList;
+
+LinkedList *linked_list_init();
+void linked_list_destroy(LinkedList **list);
+int32_t linked_list_count(LinkedList *list);
+bool linked_list_is_empty(LinkedList *list);
+LinkedListNode *linked_list_last(LinkedList *list);
+LinkedListNode *linked_list_add_last(LinkedList *list, char value);
+void linked_list_remove(LinkedList *list, LinkedListNode **node);
+void linked_list_print(LinkedList *list);
+
+// LinkedList.c
+
+LinkedList *linked_list_init() {
+    LinkedList *list = (LinkedList *)malloc(sizeof(LinkedList));
+    list->root = NULL;
+    return list;
+}
+
+void linked_list_destroy(LinkedList **list) {
+    LinkedListNode *current_node = (*list)->root;
+
+    while (current_node != NULL) {
+        LinkedListNode *current_node_copy = current_node;
+        current_node = current_node->next;
+        free(current_node_copy);
+    }
+
+    free(*list);
+    *list = NULL;
+}
+
+int32_t linked_list_count(LinkedList *list) {
+    LinkedListNode *current_node = list->root;
+    int32_t count = 0;
+
+    while (current_node != NULL) {
+        count += 1;
+        current_node = current_node->next;
+    }
+
+    return count;
+}
+
+bool linked_list_is_empty(LinkedList *list) {
+    return linked_list_count(list) == 0;
+}
+
+LinkedListNode *linked_list_last(LinkedList *list) {
+    LinkedListNode *current_node = list->root;
+
+    while (current_node->next != NULL) {
+        current_node = current_node->next;
+    }
+
+    return current_node;
+}
+
+LinkedListNode *linked_list_add_last(LinkedList *list, char value) {
+    LinkedListNode *new_node = linked_list_node_init(NULL, value);
+
+    if (linked_list_is_empty(list)) {
+        list->root = new_node;
+    } else {
+        LinkedListNode *current_node = list->root;
+
+        while (current_node->next != NULL) {
+            current_node = current_node->next;
+        }
+
+        current_node->next = new_node;
+    }
+
+    return new_node;
+}
+
+void linked_list_remove(LinkedList *list, LinkedListNode **node) {
+    if (list->root == (*node)) {
+        list->root = (*node)->next;
+    } else {
+        LinkedListNode *current_node = list->root;
+
+        while (current_node->next != (*node)) {
+            current_node = current_node->next;
+        }
+
+        current_node->next = current_node->next->next;
+    }
+
+    free(*node);
+    *node = NULL;
+}
+
+void linked_list_print(LinkedList *list) {
+    LinkedListNode *current_node = list->root;
+
+    while (current_node != NULL) {
+        printf("%c ", current_node->value);
+        current_node = current_node->next;
+    }
+}
+
+// Stack.h
+
+typedef struct Stack {
+    LinkedList *list;
+} Stack;
+
+Stack *stack_init();
+void stack_destroy(Stack **stack);
+void stack_push(Stack *stack, char value);
+char stack_peek(Stack *stack);
+char stack_pop(Stack *stack);
+
+// Stack.c
+
+Stack *stack_init() {
+    Stack *stack = (Stack *)malloc(sizeof(Stack));
+    stack->list = linked_list_init();
+    return stack;
+}
+
+void stack_destroy(Stack **stack) {
+    linked_list_destroy(&(*stack)->list);
+    free(*stack);
+    *stack = NULL;
+}
+
+void stack_push(Stack *stack, char value) {
+    linked_list_add_last(stack->list, value);
+}
+
+char stack_peek(Stack *stack) {
+    return linked_list_last(stack->list)->value;
+}
+
+char stack_pop(Stack *stack) {
+    char value = stack_peek(stack);
+
+    LinkedListNode *last_node = linked_list_last(stack->list);
+    linked_list_remove(stack->list, &last_node);
+
+    return value;
+}
+
+void stack_print(Stack *stack) {
+    while (!linked_list_is_empty(stack->list)) {
+        printf("%c ", stack_pop(stack));
+    }
+    printf("\n");
+}
+
+// BinarySearchTree.h
+
+typedef struct Node {
+    struct Node *left;
+    struct Node *right;
+    int32_t key;
+} Node;
+
+Node *node_init();
+void node_destroy(Node **node);
+
+Node *binary_search_tree_init();
+void binary_search_tree_destroy(Node **root);
+Node *binary_search_tree_insert(Node *root, int32_t key);
+Node *binary_search_tree_search(Node *root, int32_t key);
+Node *binary_search_tree_find_smallest_node(Node *root);
+Node *binary_search_tree_delete(Node *root, int32_t key);
+void binary_search_tree_print(Node *root, int32_t depth);
+
+// BinarySearchTree.c
+
+Node *node_init(int32_t key) {
+    Node *node = (Node *)malloc(sizeof(Node));
+    node->left = NULL;
+    node->right = NULL;
+    node->key = key;
+    return node;
+}
+
+void node_destroy(Node **node) {
+    free(*node);
+    *node = NULL;
+}
+
+Node *binary_search_tree_init() {
+    return NULL;
+}
+
+void binary_search_tree_destroy(Node **root) {
+    if (*root != NULL) {
+        binary_search_tree_destroy(&(*root)->left);
+        binary_search_tree_destroy(&(*root)->right);
+        free(*root);
+        *root = NULL;
+    }
+}
+
+Node *binary_search_tree_insert(Node *root, int32_t key) {
+    if (root == NULL) {
+        return node_init(key);
+    }
+
+    if (key < root->key) {
+        root->left = binary_search_tree_insert(root->left, key);
+    } else if (key > root->key) {
+        root->right = binary_search_tree_insert(root->right, key);
+    }
+
+    return root;
+}
+
+Node *binary_search_tree_search(Node *root, int32_t key) {
+    if (root == NULL) {
+        return NULL;
+    }
+
+    if (key < root->key) {
+        return binary_search_tree_search(root->left, key);
+    } else if (key > root->key) {
+        return binary_search_tree_search(root->right, key);
+    }
+
+    return root;
+}
+
+Node *binary_search_tree_find_smallest_node(Node *root) {
+    while (root->left != NULL) {
+        root = root->left;
+    }
+
+    return root;
+}
+
+Node *binary_search_tree_delete(Node *root, int32_t key) {
+    if (root == NULL) {
+        return NULL;
+    }
+
+    if (key < root->key) {
+        root->left = binary_search_tree_delete(root->left, key);
+    } else if (key > root->key) {
+        root->right = binary_search_tree_delete(root->right, key);
+    } else {
+        if (root->left == NULL && root->right == NULL) {
+            node_destroy(&root);
+            return NULL;
+        }
+
+        if (root->left == NULL) {
+            Node *right = root->right;
+            node_destroy(&root);
+            return right;
+        }
+
+        if (root->right == NULL) {
+            Node *left = root->left;
+            node_destroy(&root);
+            return left;
+        }
+
+        Node *smallest = binary_search_tree_find_smallest_node(root->right);
+        root->key = smallest->key;
+        root->right = binary_search_tree_delete(root->right, smallest->key);
+    }
+
+    return root;
+}
+
+// ---
+
+bool node_is_leaf(Node *node) {
+    return node->left == NULL && node->right == NULL;
+}
+
+Stack *search_path(Node *root, int key) {
+    Stack *s = stack_init();
+
+    while (root != NULL && !node_is_leaf(root) && root->key != key) {
+        if (key < root->key) {
+            root = root->left;
+            stack_push(s, 'g');
+        } else if (key > root->key) {
+            root = root->right;
+            stack_push(s, 'd');
+        }
+    }
+
+    return s;
+}
+
 int main() {
-    // int32_t values_length = 5;
-    // double values[values_length];
-
-    // for (int32_t i = 0; i < values_length; i += 1) {
-    //     double value;
-    //     scanf("%lf", &value);
-    //     values[i] = value;
-    // }
-
-    // int32_t values_length = 5;
-    // int32_t values[values_length];
-
-    // for (int32_t i = 0; i < values_length; i += 1) {
-    //     int32_t value;
-    //     scanf("%d", &value);
-    //     values[i] = value;
-    // }
-
-    // char a[100];
-    // int32_t b;
-    // scanf("%s %d", a, &b);
-    // printf("%s %d\n", a, b);
-
-    printf("ex1\n");
+    Node *root = binary_search_tree_init();
+    int numbers_length = 9;
+    int numbers[] = {10, 0, 20, -5, 5, 15, 25, 22, 24};
+
+    for (int i = 0; i < numbers_length; i += 1) {
+        root = binary_search_tree_insert(root, numbers[i]);
+    }
+
+    Stack *s = search_path(root, 24);
+    stack_print(s);
+    stack_destroy(&s);
+
+    s = search_path(root, 7);
+    stack_print(s);
+    stack_destroy(&s);
+
+    binary_search_tree_destroy(&root);
     return EXIT_SUCCESS;
 }