done

tree/main.c

@@ -3,18 +3,31 @@ int main(){
 
   node_t *tree = bst_create();
   tree = bst_insert(tree, 10);
+
+  // count_child(tree);
   tree = bst_insert(tree, 5);
+  // count_child(tree);
   tree = bst_insert(tree, 15);
   tree = bst_insert(tree, 2);
   tree = bst_insert(tree, 6);
-    bst_print(tree,0);
-    if(bst_is_present(tree, 3)){
-        printf("found\n");
-    }
-    if(NULL!=bst_search(tree, 2)){
-        printf("found it\n");
+  
+    if(bst_is_bst(tree)){
+        printf("i'm a bst !\n");
     }
-    printf("%d\n",bst_find_min(tree));
-    printf("%d\n",bst_find_max(tree));
+  bst_print(tree, 0);
+  tree = bst_delete(tree, 5);
+  printf("\n\n");
+  bst_print(tree, 0);
+  // bst_print(tree, 0);
+
+  // if(bst_is_present(tree, 3)){
+  //     printf("found\n");
+  // }
+  // if(NULL!=bst_search(tree, 2)){
+  //     printf("found it\n");
+  // }
+  // printf("%d\n",bst_find_min(tree));
+  // printf("%d\n",bst_find_max(tree));
+  // count_child(tree);
   bst_destroy(tree);
 }
\ No newline at end of file

tree/test.c

@@ -16,7 +16,7 @@ MunitResult test_insert() //f de test
     bst_insert(tree,15);
     bst_insert(tree,2);
     bst_insert(tree,6);
-    bst_print(tree);
+    bst_print(tree,0);
 
     return MUNIT_OK;
     

tree/tree.c

@@ -72,11 +72,11 @@ node_t *bst_insert(node_t *tree, int val) {
   return tree;
 }
 
-
 // la valeur val est-elle présente dans l'arbre?
 bool bst_is_present(node_t *tree, int val) {
   return bst_search(tree, val) != NULL;
 }
+
 // retourne le noeud où la valeur val se trouve (NULL si absent)
 node_t *bst_search(node_t *tree, int val) {
 
@@ -95,7 +95,20 @@ node_t *bst_search(node_t *tree, int val) {
 }
 
 // l'arbre est-il un arbre binaire de recherche?
-bool bst_is_bst(node_t *tree);
+bool bst_is_bst(node_t *tree) {
+  if(tree==NULL){
+    return true;
+  }
+  if (tree->left != NULL && tree->left->val > tree->val) {
+    return false;
+  }
+
+  if (tree->right != NULL && tree->right->val < tree->val) {
+    return false;
+  }
+  return bst_is_bst(tree->left) && bst_is_bst(tree->right);
+}
+
 
 node_t *bst_find_min_node(node_t *tree) {
   if (tree->left != NULL) {
@@ -115,14 +128,41 @@ node_t *bst_find_max_node(node_t *tree) {
   }
 }
 
-// int bst_find_max(node_t *tree) { return bst_find_max_node(tree)->val; }
+int bst_find_max(node_t *tree) { return bst_find_max_node(tree)->val; }
 
-// // efface le premier élément contenant la valeur val dans l'arbre
-// // et retourne l'arbre (ne fait rien si val est absente)
-// node_t *bst_delete(node_t *tree, int val){
-//     node_t *tmp=bst_search(tree, val);
-//     if(tmp->left==NULL&&tmp->right==NULL){
-//         tmp=NULL;
-//         free(tmp);
-//     }else if()
-// }
+int count_child(node_t *node) {
+  int nb = (node->left != NULL) + (node->right != NULL);
+  // printf("%d child(s)\n", nb);
+  return nb;
+}
+
+node_t *bst_delete(node_t *tree, int val) {
+  if (!bst_is_empty(tree)) {
+
\ No newline at end of file
+    if (val > tree->val) {
+      tree->right = bst_delete(tree->right, val); // go right
+
+    } else if (val < tree->val) {
+      tree->left = bst_delete(tree->left, val); // go left
+
+      // found node
+    } else if (count_child(tree) == 2) {
+
+      node_t *next = bst_find_min_node(tree->right);
+      tree->val = next->val;
+      tree->right = bst_delete(next, next->val);
+
+    } else { // 1 or 0 childs
+      node_t *tmp = tree;
+      if (tmp->left != NULL) { // left
+        tree = tree->left;
+      } else if (tmp->right != NULL) { // right
+        tree = tree->right;
+      } else {
+        tree = NULL;
+      }
+      free(tmp);
+    }
+  }
+  return tree;
+}

tree/tree.h

@@ -38,4 +38,5 @@ node_t *bst_find_max_node(node_t *tree);
 // retourne la valeur la plus grande stockée dans l'arbre (ou MAX_INT)
 int bst_find_max(node_t *tree);
 
+int count_child(node_t *node);
 #endif
\ No newline at end of file