/*
* 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);
}
}
