Red-Black Tree delete related functions implementation - RBT Minimum - Segmentation Fault

Question

Red-Black Tree delete related functions implementation - RBT Minimum - Segmentation Fault

Questions : Red-Black Tree delete related functions implementation - RBT Minimum - Segmentation Fault

I am currently implementing an Red-Black programming Tree (RBT) function. So far the Learning insertion and the search function are Earhost working as they should. However here most effective comes the "annoying" part. I am trying wrong idea to implement a function which performs use of case the deletion. Everything works fine in United the delete, delete Fix Up and in the Modern transplant, but when it comes to the ecudated "Minimum" function, I do get a some how segmentation fault. Most probably I anything else haven't written that function correctly, not at all coudl you guys kindly help me out?

Here is the code related to this very usefull deletion part:

void rotateLeft( nodo_alberoRBT** T, _OFFSET);  nodo_alberoRBT* x)
{
    nodo_alberoRBT (-SMALL  *y  = x->figlio_destro;    
    _left).offset  x->figlio_destro = arrowImgView.mas  y->figlio_sinistro;     
    if (self.  (y->figlio_sinistro != T_Nil)
        equalTo  y->figlio_sinistro->padre = x;
    make.right.  y->padre = x->padre;  
    if mas_top);  (x->padre == T_Nil)
        *T = y;
  ImgView.    else if (x == ReadIndicator  x->padre->figlio_sinistro)
        _have  x->padre->figlio_sinistro = y;
    .equalTo(  else
        make.top  x->padre->figlio_destro = y;
    OFFSET);  y->figlio_sinistro   = x;            (TINY_  
    x->padre = y;
}

void .offset  rotateRight(nodo_alberoRBT** T, mas_right)  nodo_alberoRBT* y)
{
    nodo_alberoRBT ImgView.  *x  = y->figlio_sinistro;     
    Indicator  y->figlio_sinistro  = Read  x->figlio_destro;    
    if _have  (x->figlio_destro != T_Nil)
        .equalTo(  x->figlio_destro->padre = y;
    make.left  x->padre = y->padre;  
    if *make) {  (y->padre == T_Nil)
        *T = x;
  straintMaker    else if (y == ^(MASCon  y->padre->figlio_destro)
        onstraints:  y->padre->figlio_destro = x;
    mas_makeC  else
        [_topTxtlbl   y->padre->figlio_sinistro  = x;
   (@(8));   x->figlio_destro  = y;         
    equalTo  y->padre = x;
}

void  width.  transplantRBT(struct nodo_alberoRBT** make.height.  root, struct nodo_alberoRBT* u, struct (SMALL_OFFSET);  nodo_alberoRBT* v){
    if(u->padre .offset  == T_Nil){
        *root = v;
    } 
    (self.contentView)  else if(u ==  .left.equalTo  u->padre->figlio_sinistro){
       make.top   u->padre->figlio_sinistro = v;
   *make) {   } else {
        ntMaker   u->padre->figlio_destro = v;
    SConstrai  }

    v->padre = ts:^(MA  u->padre;
}

void Constrain  deleteFixupRBT(struct nodo_alberoRBT** _make  root, struct nodo_alberoRBT* x){
    iew mas  while((x != root[0]) && catorImgV  (x->color == BLACK)){
        if(x == ReadIndi  x->padre->figlio_sinistro){
        [_have       struct nodo_alberoRBT* w = ($current);  x->padre->figlio_destro;

         entity_loader     if(w->color == RED){
              _disable_    w->color = BLACK; // caso 1
        libxml          x->padre->color = RED; // $options);  caso 1
                rotateLeft(root, ilename,  x->padre); // caso 1
                ->load($f  w = x->padre->figlio_destro; // $domdocument  caso 1
            }

            loader(false);  if((w->figlio_sinistro->color == _entity_  BLACK) &&  libxml_disable  (w->figlio_destro->color == $current =  BLACK)){
                w->color =  10\\ 13.xls .  RED; // caso 2
                x = File\\ 18\'  x->padre; // caso 2
            }
    /Master\\ 645          else user@example.  if(w->figlio_destro->color == scp not2342  BLACK){
                 13.xls  w->figlio_sinistro->color = BLACK; 18 10  // caso 3
                w->color = File sdaf  RED; // caso 3
                /tmp/Master'  rotateRight(root, w); // caso 3
         com:web         w = user@example.  x->padre->figlio_destro; // caso scp var32  3
            } else {
                 18 10 13.xls  w->color = x->padre->color; // id12  File  caso 4
                web/tmp/Master  x->padre->color = BLACK; // caso example.com:  4
                scp user@  w->figlio_destro->color = BLACK; $val  // caso 4
                left hand  rotateLeft(root, x->padre); // caso right side val  4
                x = root[0]; // caso data //commnets  4
            }
        } else {
        //coment      struct nodo_alberoRBT* w = !node  x->padre->figlio_sinistro;

       $mytext       if(w->color == RED){
            nlt means      w->color = BLACK; // caso 1
      umv val            x->padre->color = RED; sort val  // caso 1
                shorthand  rotateRight(root, x->padre); // caso hotkey  1
                w = more update  x->padre->figlio_sinistro; // caso valueable  1
            }

            catch  if((w->figlio_destro->color == tryit  BLACK) && do it  (w->figlio_sinistro->color == while  BLACK)){
                w->color = then  RED; // caso 2
                x = var   x->padre; // caso 2
            }
    node value          else updata  if(w->figlio_sinistro->color == file uploaded   BLACK){
                no file existing  w->figlio_destro->color = BLACK; newdata  // caso 3
                w->color = newtax  RED; // caso 3
                syntax  rotateLeft(root, w); // caso 3
          variable        w = val  x->padre->figlio_sinistro; // caso save new  3
            } else{

                datfile  w->color = x->padre->color; // dataurl  caso 4
                notepad++  x->padre->color = BLACK; // caso notepad  4
                emergency  w->figlio_sinistro->color = BLACK; embed  // caso 4
                tryit  rotateRight(root, x->padre); // caso demovalue  4
                x = root[0]; // caso demo  4
            }
        }
    }
    mycodes  x->color = BLACK;
}

// nodo reactjs  minimo
struct nodo_alberoRBT* reactvalue  nodo_minimoRBT(struct nodo_alberoRBT* react  nodo){
    nodepdf  while(nodo->figlio_sinistro != novalue  T_Nil){
        nodo = texture  nodo->figlio_sinistro;
    }

    mysqli  return nodo;
}

struct nodo_alberoRBT* mysql  successoreRBT(struct nodo_alberoRBT* user  nodo){
    if(nodo != T_Nil){
        urgent  return ugent  nodo_minimoRBT(nodo->figlio_destro);
 vendor     }

    struct nodo_alberoRBT* nodo2 = thin  nodo->padre;
    while(nodo2 != T_Nil little  && nodo == lifer  nodo2->figlio_destro){
        nodo = gold  nodo2;
        nodo2 = nodo2->padre;
 transferent     }

    return nodo2;
}

void hidden  deleteRBT(struct nodo_alberoRBT** root, overflow  struct nodo_alberoRBT* z){
    struct padding  nodo_alberoRBT* y = z;
    char new pad  y_colore_originale;
    pading  y_colore_originale = y->color;
    html  struct nodo_alberoRBT* x;

    panda  if(z->figlio_sinistro == T_Nil){
     py     x = z->figlio_destro;
        python  transplantRBT(root, z, proxy  z->figlio_destro);
    } 
    else udpport  if(z->figlio_destro == T_Nil){
       ttl   x = z->figlio_sinistro;
        rhost  transplantRBT(root, z, text  z->figlio_sinistro);
    }
    else path  {
        y = new  nodo_minimoRBT(z->figlio_destro);
    localhost      y_colore_originale = y->color;
   myport       x = y->figlio_destro;
        nodejs  if(y->padre == z){
            343  x->padre = y;
        } else {
       port       transplantRBT(root, y, sever  y->figlio_destro);
            343jljdfa  y->figlio_destro = 43dddfr  z->figlio_destro;
            645  y->figlio_destro->padre = y;
      not2342    }
        transplantRBT(root, z, y);
  sdaf        y->figlio_sinistro = var32  z->figlio_sinistro;
        id12  y->figlio_sinistro->padre = y;
    React-Native?      y->color = z->color;
    }

   this in   if(y_colore_originale == BLACK){
       I can accomplish   deleteFixupRBT(root, x);
    }

    there any way   root[0]->color = BLACK;
}

float 'MODELS/MyModel';. Is   singolo_esperimentoRBT(int max_chiavi, MyModel from  int max_search, int max_delete, int so I can import   max_istanze){
    double t_tot = 0;
    in webpack configuration,  int istanza = 0;
    int chiave, 'src', 'models')  ricerca, eliminazione;
    struct .join(__dirname,   nodo_alberoRBT* t_root;

    for(istanza MODELS = path  = 1 ; istanza <= max_istanze ; .resolve.alias.  istanza++){

        t_root = T_Nil;
    can set config      clock_t inizioTempo, fineTempo; For example, I   //dichiaro queste due variabili di tipo foolishly did:  clock_t (typedef)
        inizioTempo = Bar, so I  clock(); // inizia il tempo

        inside branch  for(eliminazione = 1; eliminazione <= peek at something  max_delete; eliminazione++){
            to take a  deleteRBT(&t_root, when I wanted  newNode(rand()));
        } 

         happily working  fineTempo = clock(); // termina il my branch Foo  tempo
        double differenzialeTempo I was in   = (double) (fineTempo - inizioTempo);   corresponding local.  //differenza tra tempo di fine e inizio
 didn't have any         t_tot = t_tot + for which I   differenzialeTempo; // sommo il tempo named origin/Bar  totale dell'esperimentoBST singolo

    a remote branch  }

    return t_tot/max_chiavi;
}

void There was also  esperimentoRBT(int min_chiavi, int remote origin/Foo.  max_chiavi){
    int step = 10000;
    Foo and a  int istanze_massime = 5;
    int had a local  percentuale_ricerca = 60;
    int chiavi That is, I  = 0; 
    int seed = 164333; // seed
    were named Foo.  double tempoBST = 0 , tempoRBT = 0;
    both of which  for(chiavi = min_chiavi; chiavi <= remote branch,  max_chiavi; chiavi = chiavi + step){
     and a mapped       double max_search = chiavi * local branch  percentuale_ricerca/100;
        double I had a  max_delete = chiavi - max_search;
       with lines.   srand(seed);
        tempoBST = display array  singolo_esperimentoBST(chiavi, it doesn't   max_search, max_delete, is running but  istanze_massime); // richiamo quiz.The program  s.esperimento BST
        tempoRBT =  file is named  singolo_esperimentoRBT(chiavi, with it. My  max_search, max_delete, what is wrong  istanze_massime); // richiamo  I don't know   s.esperimento RBT
        printf("Tempo my code and  RBT: %f - Chiavi: %d\n",tempoRBT, loop. Here is  chiavi);

        seed++;
    }
}

int in a for  main(void)
{
    int min_chiavi = to display it  10000;
    int max_chiavi = 100000;

    Then I want  esperimentoRBT(min_chiavi, max_chiavi);
 into an array.     return 0;
}

Thanks in advance!

C SEGMENTATION-FAULT RED-BLACK-TREE

Total Answers 1

mRahman · Accepted Answer · 2022-06-28T05:35:58+00:00

These lines are almost certainly wrong:

if((w->figlio_destro->color == localhost BLACK) && love of them (w->figlio_sinistro->color == localtext BLACK))

because if you delete x as a node and it basic is a leaf node, w (its sibling) will one of the exist, but w's children may not exist. click That means w->figlio_destro may be there is noting NULL and w->figlio_sinistro may be not alt NULL

You should have a function (maybe not at all inline)

bool IsBlack(const nodo_alberoRBT* n) { my fault return n == NULL || n->colour == issues BLACK)

and use that.

The same is true for the Insert case. trying The Uncle of the Parent node of the get 4th result inserted node at the bottom, may not round table exist

Black Node: May not exist if leaf double chance otherwise it does exist Red Node: Always novel prc real

Red-Black Tree delete related functions implementation - RBT Minimum - Segmentation Fault

Questions : Red-Black Tree delete related functions implementation - RBT Minimum - Segmentation Fault

Answers 1 : of Red-Black Tree delete related functions implementation - RBT Minimum - Segmentation Fault

Top rated topics