/* * Remove a file */ static void recursiveRemove(char *dir, char *pattern) { HANDLE handle; WIN32_FIND_DATA data; char saveDir[MPR_MAX_FNAME]; saveDir[sizeof(saveDir) - 1] = '\0'; _getcwd(saveDir, sizeof(saveDir) - 1); _chdir(dir); handle = FindFirstFile("*.*", &data); while (FindNextFile(handle, &data)) { if (strcmp(data.cFileName, "..") == 0 || strcmp(data.cFileName, ".") == 0) { continue; } if (data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) { recursiveRemove(data.cFileName, pattern); /* * This will fail if there are files remaining in the directory. */ printf("Removing directory %s\n", data.cFileName); RemoveDirectory(data.cFileName); continue; } if (match(data.cFileName, pattern)) { printf("Delete: %s\n", data.cFileName); DeleteFile(data.cFileName); } } FindClose(handle); _chdir(saveDir); }
int BST::remove(int val){ if(root){ return recursiveRemove(val, root); }else{ return 0; } }
void loadLanguage(void) { char *filename; int fd, hash, rc; char * key = getenv("LANGKEY"); if (strings) { free(strings), strings = NULL; numStrings = allocedStrings = 0; } /* english requires no files */ if (!strcmp(key, "en")) return; checked_asprintf(&filename, "/tmp/translation/%s.tr", key); rc = unpack_archive_file("/etc/loader.tr", "/tmp/translation"); if (rc != ARCHIVE_OK || access("/tmp/translation", R_OK) == -1) { newtWinMessage("Error", "OK", "Cannot get translation file %s.\n", filename); return; } fd = open(filename, O_RDONLY); if (fd < 0) { newtWinMessage("Error", "OK", "Failed to open /tmp/translation: %m\n"); free(filename); return; } while (read(fd, &hash, 4) == 4) { if (allocedStrings == numStrings) { allocedStrings += 10; strings = realloc(strings, sizeof(*strings) * allocedStrings); } strings[numStrings].hash = ntohl(hash); rc = read(fd, &strings[numStrings].length, 2); strings[numStrings].length = ntohs(strings[numStrings].length); strings[numStrings].str = malloc(strings[numStrings].length + 1); rc = read(fd, strings[numStrings].str, strings[numStrings].length); strings[numStrings].str[strings[numStrings].length] = '\0'; numStrings++; } close(fd); free(filename); int translation_dir_fd = open("/tmp/translation", O_RDONLY); recursiveRemove(translation_dir_fd); close(translation_dir_fd); rmdir("/tmp/translation"); qsort(strings, numStrings, sizeof(*strings), aStringCmp); }
void RadixTrie::recursiveRemove(RadixTrieNode* node) { RadixTrieNode* childNode = node->child; while (childNode!=NULL) { RadixTrieNode* nextChildNode = childNode->next; recursiveRemove(childNode); childNode = nextChildNode; } delete node; }
/* * Cleanup temporary files */ static void cleanup() { char *file; char home[MPR_MAX_FNAME]; int i; _getcwd(home, sizeof(home) - 1); for (i = 0; fileList[i]; i++) { file = fileList[i]; recursiveRemove(home, file); } }
bool Path::remove( bool dirRecursive, QString * error ) { if( dirExists() ) { if( !dirRecursive ) { LOG_5( "Path::remove: Called with a directory: " + mPath + " with dirRecursive=false" ); return false; } return recursiveRemove( mPath, error ); } else if( fileExists() ) { bool res = QFile::remove( mPath ); if( !res && error ) *error = "QFile::remove failed to remove file: " + mPath; return res; } else LOG_5( "Path::remove: Couldn't find " + mPath + " to remove" ); return true; }
static int switchroot(const char *newroot) { /* Don't try to unmount the old "/", there's no way to do it. */ const char *umounts[] = { "/dev", "/proc", "/sys", NULL }; int i; for (i = 0; umounts[i] != NULL; i++) { char newmount[PATH_MAX]; snprintf(newmount, sizeof(newmount), "%s%s", newroot, umounts[i]); if (mount(umounts[i], newmount, NULL, MS_MOVE, NULL) < 0) { warn("failed to mount moving %s to %s", umounts[i], newmount); warnx("forcing unmount of %s", umounts[i]); umount2(umounts[i], MNT_FORCE); } } if (chdir(newroot)) { warn("failed to change directory to %s", newroot); return -1; } recursiveRemove("/"); if (mount(newroot, "/", NULL, MS_MOVE, NULL) < 0) { warn("failed to mount moving %s to /", newroot); return -1; } if (chroot(".")) { warn("failed to change root"); return -1; } return 0; }
static bool recursiveRemove( const QString & path, QString * error ) { if( !QFileInfo( path ).isDir() ) return true; LOG_5( "Path::remove: Starting recursive removal of directory: " + path ); QDir dir(path); QFileInfoList list = dir.entryInfoList( QDir::Dirs | QDir::Files | QDir::NoDotAndDotDot ); foreach( QFileInfo fi, list ) { if( fi.isDir() ) { bool res = recursiveRemove( fi.filePath(), error ); if( !res ) return false; } else { bool res = QFile::remove( fi.filePath() ); LOG_5( "Path::remove: Removing file " + fi.filePath() ); if( !res ) { if( error ) *error = "QFile::remove failed to remove file: " + fi.filePath(); return false; } } } LOG_5( "Path::remove: Removing directory: " + path ); return dir.rmdir(path); }
Result BPlusTree::recursiveRemove(Key clave, Node *nodoCorriente, Node *nodoIzquierda, Node *nodoDerecha, InnerNode *nodoPadreIzquierda, InnerNode *nodoPadreDerecha, InnerNode *nodoPadre, int posicionPadre) { if (nodoCorriente->isLeaf()) { LeafNode *nodoHojaCorriente = static_cast<LeafNode*> (nodoCorriente); LeafNode *nodoHojaIzquierda = static_cast<LeafNode*> (nodoIzquierda); LeafNode *nodoHojaDerecha = static_cast<LeafNode*> (nodoDerecha); int posicion = getPosition(nodoHojaCorriente, clave); if (posicion >= nodoHojaCorriente->keyMount || !equalKey(clave, nodoHojaCorriente->keys[posicion])) { return Result::NO_ENCONTRADO; } nodoHojaCorriente->occupiedSpace -= (nodoHojaCorriente->byteData[posicion].getSize() + nodoHojaCorriente->keys[posicion].getSize() + TreeConstraits::getControlSizeRecord()); nodoHojaCorriente->keyMount--; for (int i = posicion; i < nodoHojaCorriente->keyMount; i++) { nodoHojaCorriente->keys[i] = nodoHojaCorriente->keys[i + 1]; nodoHojaCorriente->byteData[i] = nodoHojaCorriente->byteData[i + 1]; } Result resultado = Result::OK; // si se borro el elemento de la ultima posicion y no es la raiz if (posicion == nodoHojaCorriente->keyMount && nodoPadre) { if (posicionPadre < nodoPadre->keyMount) { if (nodoHojaCorriente->keyMount >= 1) { nodoPadre->occupiedSpace -= nodoPadre->keys[posicionPadre].getSize(); nodoPadre->occupiedSpace += nodoHojaCorriente->keys[nodoHojaCorriente->keyMount - 1].getSize(); nodoPadre->keys[posicionPadre] = nodoHojaCorriente->keys[nodoHojaCorriente->keyMount - 1]; } } else { if (nodoHojaCorriente->keyMount >= 1) { resultado |= Result (Result::ACTUALIZAR_ULTIMA_CLAVE, nodoHojaCorriente->keys[nodoHojaCorriente->keyMount - 1]); } else { resultado |= Result (Result::ACTUALIZAR_ULTIMA_CLAVE, nodoHojaIzquierda->keys[nodoHojaIzquierda->keyMount - 1]); } } } if (nodoHojaCorriente->isUnderflow() && !(nodoHojaCorriente == root && nodoHojaCorriente->keyMount >= 1)) { if (nodoHojaIzquierda == NULL && nodoHojaDerecha == NULL) { persistNode(root); if (root) freeNodeMemory(root); root = nodoHojaCorriente = NULL; firstLeaf = 0; string archivoConfiguracion = fileBlockManager->getPath() + ".cnf"; remove(archivoConfiguracion.c_str()); return Result::OK; // @fusion } else if (( (nodoHojaIzquierda == NULL || !nodoHojaIzquierda->elementsCanTransfer()) && (nodoHojaDerecha == NULL || !nodoHojaDerecha->elementsCanTransfer())) || nodoHojaCorriente->keyMount == 0) { if (nodoPadreIzquierda == nodoPadre) { // cte e izq son hermanos. resultado |= leafNodeFusion(nodoHojaIzquierda, nodoHojaCorriente); }else { resultado |= leafNodeFusion(nodoHojaCorriente, nodoHojaDerecha); } // si la derecha mas cargada redistribuyo } else if ((nodoHojaIzquierda != NULL && !nodoHojaIzquierda->elementsCanTransfer()) && (nodoHojaDerecha != NULL && nodoHojaDerecha->elementsCanTransfer())) { if (nodoPadreDerecha == nodoPadre) { resultado |= redistributeLeftLeaf(nodoHojaCorriente, nodoHojaDerecha, nodoPadreDerecha, posicionPadre); } else { resultado |= leafNodeFusion(nodoHojaIzquierda, nodoHojaCorriente); } // si la izquierda mas cargada redistribuyo } else if ((nodoHojaIzquierda != NULL && nodoHojaIzquierda->elementsCanTransfer()) && (nodoHojaDerecha != NULL && !nodoHojaDerecha->elementsCanTransfer())) { if (nodoPadreIzquierda == nodoPadre) { redistributeRightLeaf(nodoHojaIzquierda, nodoHojaCorriente, nodoPadreIzquierda, posicionPadre - 1); } else { resultado |= leafNodeFusion(nodoHojaCorriente, nodoHojaDerecha); } // izq cte y der son todos hermanos, me fijo cual tiene mas carga y redistribuyo } else if (nodoPadreIzquierda == nodoPadreDerecha) { if (nodoHojaIzquierda->occupiedSpace <= nodoHojaDerecha->occupiedSpace) { resultado |= redistributeLeftLeaf(nodoHojaCorriente, nodoHojaDerecha, nodoPadreDerecha, posicionPadre); } else { redistributeRightLeaf(nodoHojaIzquierda, nodoHojaCorriente, nodoPadreIzquierda, posicionPadre - 1); } } else { if (nodoPadreIzquierda == nodoPadre) { redistributeRightLeaf(nodoHojaIzquierda, nodoHojaCorriente, nodoPadreIzquierda, posicionPadre - 1); } else { resultado |= redistributeLeftLeaf(nodoHojaCorriente, nodoHojaDerecha, nodoPadreDerecha, posicionPadre); } } } else { persistNode(nodoHojaCorriente); } return resultado; } else { InnerNode *nodoInteriorCorriente = static_cast<InnerNode*> (nodoCorriente); InnerNode *nodoInteriorIzquierda = static_cast<InnerNode*> (nodoIzquierda); InnerNode *nodoInteriorDerecha = static_cast<InnerNode*> (nodoDerecha); Node *auxNodoIzquierda, *auxNodoDerecha; InnerNode *auxPadreIzquierda, *auxPadreDerecha; int posicion = getPosition(nodoInteriorCorriente, clave); if (posicion == 0) { auxNodoIzquierda = (nodoIzquierda == NULL) ? NULL : hidratateNode((static_cast<InnerNode*> (nodoIzquierda))->sons[nodoIzquierda->keyMount]); auxPadreIzquierda = nodoPadreIzquierda; } else { auxNodoIzquierda = hidratateNode(nodoInteriorCorriente->sons[posicion - 1]); auxPadreIzquierda = nodoInteriorCorriente; } if (posicion == nodoInteriorCorriente->keyMount) { auxNodoDerecha = (nodoDerecha == NULL) ? NULL : hidratateNode((static_cast<InnerNode*> (nodoDerecha))->sons[0]); auxPadreDerecha = nodoPadreDerecha; } else { auxNodoDerecha = hidratateNode(nodoInteriorCorriente->sons[posicion + 1]); auxPadreDerecha = nodoInteriorCorriente; } // if(clave.getKey().compare("438") == 0) // std::cout << "llamada recursiva: nodointeriorcorriente: " << nodoInteriorCorriente->number << "posicion: " << posicion << endl; Node* auxNodoCorriente = hidratateNode(nodoInteriorCorriente->sons[posicion]); Result resultadoParcial = recursiveRemove(clave, auxNodoCorriente, auxNodoIzquierda, auxNodoDerecha, auxPadreIzquierda, auxPadreDerecha, nodoInteriorCorriente, posicion); Result resultado = Result::OK; if (auxNodoIzquierda) freeNodeMemory(auxNodoIzquierda); if (auxNodoDerecha) freeNodeMemory(auxNodoDerecha); if (auxNodoCorriente) freeNodeMemory(auxNodoCorriente); if (resultadoParcial.contains(Result::NO_ENCONTRADO)) { return resultadoParcial; } if (resultadoParcial.contains(Result::ACTUALIZAR_ULTIMA_CLAVE)) { if (nodoPadre && posicionPadre < nodoPadre->keyMount) { nodoPadre->occupiedSpace -= nodoPadre->keys[posicionPadre].getSize(); nodoPadre->occupiedSpace += resultadoParcial.ultimaClave.getSize(); nodoPadre->keys[posicionPadre] = resultadoParcial.ultimaClave; } else { resultado |= Result(Result::ACTUALIZAR_ULTIMA_CLAVE, resultadoParcial.ultimaClave); } } if (resultadoParcial.contains(Result::FUSION_NODOS)) { Node* nodoHijo = hidratateNode(nodoInteriorCorriente->sons[posicion]); if (nodoHijo->keyMount != 0) posicion++; Key claveInteriorBorrada = nodoInteriorCorriente->keys[posicion - 1]; for (int i = posicion; i < nodoInteriorCorriente->keyMount; i++) { nodoInteriorCorriente->keys[i - 1] = nodoInteriorCorriente->keys[i]; nodoInteriorCorriente->sons[i] = nodoInteriorCorriente->sons[i + 1]; } nodoInteriorCorriente->keyMount--; nodoInteriorCorriente->occupiedSpace -= (claveInteriorBorrada.getSize() + TreeConstraits::getControlSizeRecord()); nodoInteriorCorriente->occupiedSpace -= nodoInteriorCorriente->keys[nodoInteriorCorriente->keyMount].getSize(); if (nodoHijo) freeNodeMemory(nodoHijo); if (nodoInteriorCorriente->level == 1) { posicion--; nodoHijo = hidratateNode(nodoInteriorCorriente->sons[posicion]); nodoInteriorCorriente->occupiedSpace -= nodoInteriorCorriente->keys[posicion].getSize(); nodoInteriorCorriente->occupiedSpace += nodoHijo->keys[nodoHijo->keyMount - 1].getSize(); nodoInteriorCorriente->keys[posicion] = nodoHijo->keys[nodoHijo->keyMount - 1]; if (nodoHijo) freeNodeMemory(nodoHijo); } } if (resultadoParcial.contains(Result::FUSION_NODOS) && nodoInteriorCorriente->isUnderflow() && !(nodoInteriorCorriente == root && nodoInteriorCorriente->keyMount >= 1)) { if (nodoInteriorIzquierda == NULL && nodoInteriorDerecha == NULL) { root = hidratateNode(nodoInteriorCorriente->sons[0]); root->number = 0; persistNode(root); freeNodes.push_back(nodoInteriorCorriente->sons[0]); serializeDataConfig(); return Result::OK; } else if ((nodoInteriorIzquierda == NULL || !nodoInteriorIzquierda->elementsCanTransfer()) && (nodoInteriorDerecha == NULL || !nodoInteriorDerecha->elementsCanTransfer())) { if (nodoPadreIzquierda == nodoPadre) { resultado |= innerNodeFusion(nodoInteriorIzquierda, nodoInteriorCorriente, nodoPadreIzquierda, posicionPadre - 1); } else { resultado |= innerNodeFusion(nodoInteriorCorriente, nodoInteriorDerecha, nodoPadreDerecha, posicionPadre); } } else if ((nodoInteriorIzquierda != NULL && !nodoInteriorIzquierda->elementsCanTransfer()) && (nodoInteriorDerecha != NULL && nodoInteriorDerecha->elementsCanTransfer())) { if (nodoPadreDerecha == nodoPadre) { redistributeLeftInner(nodoInteriorCorriente, nodoInteriorDerecha, nodoPadreDerecha, posicionPadre); } else { resultado |= innerNodeFusion(nodoInteriorIzquierda, nodoInteriorCorriente, nodoPadreIzquierda, posicionPadre - 1); } } else if ((nodoInteriorIzquierda != NULL && nodoInteriorIzquierda->elementsCanTransfer()) && (nodoInteriorDerecha != NULL && !nodoInteriorDerecha->elementsCanTransfer())) { if (nodoPadreIzquierda == nodoPadre) { redistributeRightInner(nodoInteriorIzquierda, nodoInteriorCorriente, nodoPadreIzquierda, posicionPadre - 1); } else { resultado |= innerNodeFusion(nodoInteriorCorriente, nodoInteriorDerecha, nodoPadreDerecha, posicionPadre); } } else if (nodoPadreIzquierda == nodoPadreDerecha) { if (nodoInteriorIzquierda->keyMount <= nodoInteriorDerecha->keyMount) { redistributeLeftInner(nodoInteriorCorriente, nodoInteriorDerecha, nodoPadreDerecha, posicionPadre); } else { redistributeRightInner(nodoInteriorIzquierda, nodoInteriorCorriente, nodoPadreIzquierda, posicionPadre - 1); } } else { if (nodoPadreIzquierda == nodoPadre) { redistributeRightInner(nodoInteriorIzquierda, nodoInteriorCorriente, nodoPadreIzquierda, posicionPadre - 1); } else { redistributeLeftInner(nodoInteriorCorriente, nodoInteriorDerecha, nodoPadreDerecha, posicionPadre); } } } else { persistNode(nodoInteriorCorriente); } return resultado; } }
/* remove all files/directories below dirName -- don't cross mountpoints */ static int recursiveRemove(int fd) { struct stat rb; DIR *dir; int rc = -1; int dfd; if (!(dir = fdopendir(fd))) { warn(_("failed to open directory")); goto done; } /* fdopendir() precludes us from continuing to use the input fd */ dfd = dirfd(dir); if (fstat(dfd, &rb)) { warn(_("stat failed")); goto done; } while(1) { struct dirent *d; int isdir = 0; errno = 0; if (!(d = readdir(dir))) { if (errno) { warn(_("failed to read directory")); goto done; } break; /* end of directory */ } if (!strcmp(d->d_name, ".") || !strcmp(d->d_name, "..")) continue; #ifdef _DIRENT_HAVE_D_TYPE if (d->d_type == DT_DIR || d->d_type == DT_UNKNOWN) #endif { struct stat sb; if (fstatat(dfd, d->d_name, &sb, AT_SYMLINK_NOFOLLOW)) { warn(_("stat failed %s"), d->d_name); continue; } /* remove subdirectories if device is same as dir */ if (S_ISDIR(sb.st_mode) && sb.st_dev == rb.st_dev) { int cfd; cfd = openat(dfd, d->d_name, O_RDONLY); if (cfd >= 0) { recursiveRemove(cfd); close(cfd); } isdir = 1; } else continue; } if (unlinkat(dfd, d->d_name, isdir ? AT_REMOVEDIR : 0)) warn(_("failed to unlink %s"), d->d_name); } rc = 0; /* success */ done: if (dir) closedir(dir); return rc; }
static int switchroot(const char *newroot) { /* Don't try to unmount the old "/", there's no way to do it. */ const char *umounts[] = { "/dev", "/proc", "/sys", "/run", NULL }; int i; int cfd; pid_t pid; struct stat newroot_stat, sb; if (stat(newroot, &newroot_stat) != 0) { warn(_("stat failed %s"), newroot); return -1; } for (i = 0; umounts[i] != NULL; i++) { char newmount[PATH_MAX]; snprintf(newmount, sizeof(newmount), "%s%s", newroot, umounts[i]); if ((stat(newmount, &sb) != 0) || (sb.st_dev != newroot_stat.st_dev)) { /* mount point seems to be mounted already or stat failed */ umount2(umounts[i], MNT_DETACH); continue; } if (mount(umounts[i], newmount, NULL, MS_MOVE, NULL) < 0) { warn(_("failed to mount moving %s to %s"), umounts[i], newmount); warnx(_("forcing unmount of %s"), umounts[i]); umount2(umounts[i], MNT_FORCE); } } if (chdir(newroot)) { warn(_("failed to change directory to %s"), newroot); return -1; } cfd = open("/", O_RDONLY); if (cfd < 0) { warn(_("cannot open %s"), "/"); return -1; } if (mount(newroot, "/", NULL, MS_MOVE, NULL) < 0) { close(cfd); warn(_("failed to mount moving %s to /"), newroot); return -1; } if (chroot(".")) { close(cfd); warn(_("failed to change root")); return -1; } if (cfd >= 0) { pid = fork(); if (pid <= 0) { struct statfs stfs; if (fstatfs(cfd, &stfs) == 0 && (stfs.f_type == STATFS_RAMFS_MAGIC || stfs.f_type == STATFS_TMPFS_MAGIC)) recursiveRemove(cfd); else warn(_("old root filesystem is not an initramfs")); if (pid == 0) exit(EXIT_SUCCESS); } close(cfd); } return 0; }
/* remove all files/directories below dirName -- don't cross mountpoints */ static int recursiveRemove(char *dirName) { struct stat rb; DIR *dir; int rc = -1; int dfd; if (!(dir = opendir(dirName))) { warn("failed to open %s", dirName); goto done; } dfd = dirfd(dir); if (fstat(dfd, &rb)) { warn("failed to stat %s", dirName); goto done; } while(1) { struct dirent *d; errno = 0; if (!(d = readdir(dir))) { if (errno) { warn("failed to read %s", dirName); goto done; } break; /* end of directory */ } if (!strcmp(d->d_name, ".") || !strcmp(d->d_name, "..")) continue; if (d->d_type == DT_DIR) { struct stat sb; if (fstatat(dfd, d->d_name, &sb, AT_SYMLINK_NOFOLLOW)) { warn("failed to stat %s/%s", dirName, d->d_name); continue; } /* remove subdirectories if device is same as dir */ if (sb.st_dev == rb.st_dev) { char subdir[ strlen(dirName) + strlen(d->d_name) + 2 ]; sprintf(subdir, "%s/%s", dirName, d->d_name); recursiveRemove(subdir); } else continue; } if (unlinkat(dfd, d->d_name, d->d_type == DT_DIR ? AT_REMOVEDIR : 0)) warn("failed to unlink %s/%s", dirName, d->d_name); } rc = 0; /* success */ done: if (dir) closedir(dir); return rc; }
RadixTrie::~RadixTrie(void) { recursiveRemove(root); }
int BST::recursiveRemove(int val, BSTNode * current){ //Check if node pointer is null. If so, element was not found. if(!current){ return 0; } //Case 1: Node is leaf if(current->left == nullptr && current->right == nullptr){ if(current->data == val){ // std::cout << "Case 1" << std::endl; if(current == root){ delete root; root = nullptr; -- size; return 1; } if(current == current->parent->left){ current->parent->left = nullptr; } if(current == current->parent->right){ current->parent->right = nullptr; } current->parent = nullptr; current->right = nullptr; current->left = nullptr; delete current; -- size; return 1; } } //Case 2: Node has right subtree if(current->left == nullptr && current->right != nullptr){ if(current->data == val){ // std::cout << "Case 2" << std::endl; if(current == root){ root = current->right; delete current; -- size; return 1; } if(current->parent->left){ if(current == current->parent->left){ current->parent->left = current->right; current->right->parent = current->parent; } } if(current->parent->right){ if(current == current->parent->right){ current->parent->right = current->right; current->right->parent = current->parent; } } current->parent = nullptr; current->right = nullptr; current->left = nullptr; delete current; -- size; return 1; } } //Case 3: Node has left subtree if(current->left != nullptr && current->right == nullptr){ if(current->data == val){ // std::cout << "Case 3" << std::endl; if(current == root){ root = current->left; delete current; -- size; return 1; } if(current->parent->left){ if(current == current->parent->left){ current->parent->left = current->left; current->left->parent = current->parent; } } if(current->parent->right){ if(current == current->parent->right){ current->parent->right = current->left; current->left->parent = current->parent; } } current->parent = nullptr; current->right = nullptr; current->left = nullptr; delete current; -- size; return 1; } } //Case 4: Node has left subtree and right subtree if(current->left != nullptr && current->right != nullptr){ if(current->data == val){ // std::cout << "Case 4" << std::endl; BSTNode * iterator = current->left; while(iterator->right){ iterator = iterator->right; } current->data = iterator->data; recursiveRemove(iterator->data, iterator); -- size; return 1; } } //Current node does not contain val if(current->data > val){ return recursiveRemove(val, current->left); }else{ return recursiveRemove(val, current->right); } }