Algoritmi e strutture dati/Progetti/Rettangoli/Stesura I

  #include <stdio.h>
  #include <stdlib.h>
  
        /* definizione dei tipi */
  
  typedef enum{red, black} color;
  
  struct rbapple {
  int xx;
  int yy;
  color co;
  char touch;
  struct rbapple *left;
  struct rbapple *right;
  struct rbapple *parent;
  };			/* struttura di	ogni nodo dell'albero dei punti*/"
  
  typedef struct rbapple rbapple;
  
  struct rbalbero {
  rbapple *root;
  rbapple *nul;
  };	      /*struttura contenente i puntatori alla radice e alla sentinella"
  	       dell'albero dei punti*/"
  
  struct rbnode {
  color co ;
  int a;
  int b;
  int c;
  int d;
  char campo;
  struct rbnode *sinistra;
  struct rbnode *destra;
  struct rbnode *genitore;
  };			  /*struttura di ogni nodo dell'albero dei rettangoli*/"
  
  typedef struct rbnode rbnode;
  
  struct rbtree {
    rbnode *root;
    rbnode *nil;
  };		 /*struttura contenente	i puntatori alla radice e alla sentinella"
  	       dell'albero dei rettangoli*/"
  
  typedef struct rbalbero rbalbero;
  typedef struct rbtree rbtree;
  
  /*    variabili globali	   */"
    rbtree *spazio=NULL; /*puntatore all'albero dei rettangoli*/
    rbtree *blocco=NULL;/*puntatore all'albero contennte i rettangoli facenti
  			parte di un blocco*/"
    rbalbero *foglio=NULL;/*puntatore all'albero dei punti*/
    rbalbero *niubbio=NULL;/*puntatore all'albero contenente i punti che vanno
  			   rimossi*/"
    int   par1=0,
    par2=0,
    par3=0,
    par4=0,			  /* variabili di input*/"
    perimetro= 0,
    max_x=0,  /*dimensione massima dell'ascissa del piano*/
    max_y=0;  /*dimensione massima dell'ordinata del piano*/
  char com; /*parametro di scelta*/
  
  /*
  	       prototipi di FUNZIONI E PROCEDURE"
  */
  
  /*
  procedure principali
  */
  void procedura_perimetro(void);
  void procedura_blocco(void);
  
  void rbdelete(rbalbero *tree, rbapple *q);
  void scorri_albero_rettangoli (rbtree *perno, rbnode *buster, rbalbero *joshua , rbapple *corda,int x, int y,rbalbero *elimina);
  void elimina_interni_foglio(rbalbero *tree, rbapple *q,rbnode *helper, int x, int y ,rbalbero *elimina);
  void scorri_albero_punti(rbalbero *sanato, rbapple *helper, rbtree *f, rbnode *element, rbalbero *elimina);
  void ruotaadestra(rbalbero *andtrea , rbapple *giovanni);
  void inizializzacampo(rbnode *pino, rbnode *peppe);
  void fixup(rbalbero *tree, rbapple *x);
  void elimina_albero_supporto(rbalbero *sanato, rbapple *helper);
  void elimina_puntini(rbalbero *sanato, rbapple *helper, rbalbero *albero_punti);
  void inserisci_foglio(rbalbero *carmencita, int yukapan, int turu);
  void canc_albero(rbapple *plastica, rbapple *impertinente);
  void costruisci_foglio(rbnode *attacca, rbnode *lattina, rbalbero *the);
  void inserisci_blocco(rbtree *dd, int c, int z, int vv, int sc);
  void creablocco(rbnode *at, rbnode *ds, rbtree *pc, rbtree *os, int bin, int ffe, int cut, int fre);
  void ruotaasinistra(rbalbero *pat, rbapple *emilia);
  void inserisci_punto (rbalbero *carmen, int lardo, int palino);
  void elimina_tutto_l_albero(rbnode *uno, rbnode *due);
  void rightrotate(rbtree *ssa ,  rbnode *eew);
  void leftrotate(rbtree *gix, rbnode *giz);
  void inserisci_in_albero(rbtree *csi, int x , int y, int z, int u);
  void installarettangolo1(rbtree *doo, int you, int foo, int sedd, int degr);
  void search_block(rbnode *fab, rbnode *anna, rbtree *lobot, char drea,  int cse, int cpi);
  /*
  funzioni
  */
  int perimetroeblocco(rbalbero *foglio, int peri, char p_o_b);
  int ilpuntoeinterno(rbnode *p,int x, int y);
  rbapple *treesucc(rbalbero *tree, rbapple *q);
  rbapple *treemin(rbapple *p, rbalbero *tree);
  rbapple *minimo_foglio(rbapple *paolo, rbapple *piero);
  rbapple *trova_nodofoglio(rbalbero *eustachio, int adalberto , int paola);
  rbapple *crea_apple(rbalbero *lindo, int cccp, int ostro);
  rbapple *inserisci_apple(rbalbero *orin, int elio, int samaga);
  rbalbero *costruisci_blocco(rbtree *star, rbtree *stor,	 rbalbero *bull, int e, int f,char g);"
  rbalbero *crea_rbalbero(int gino);
  rbtree *crea_rbtree(void);
  rbtree *crea_spazio(rbtree *der, int ddr, int fviva);
  rbnode *cercanodino(rbtree *nonnot, int defr, int wwe, int t342, int dds);
  rbnode *assegna_rbnode(rbtree *eew, int, int, int, int);
  rbnode *metti_un_elemento(rbtree *lls, int d, int f, int r, int t);
  
  /*
  	 implementazione delle FUNZIONI	e PROCEDURE"
  */
  
  rbtree *crea_spazio(rbtree *spazio, int x, int y)
  /*
  questa procedura controlla che non sia già presente uno spazio e ne crea uno di
  dimensioni x y; nel caso in cui ci sia già uno spazio, lo cancella e, solo dopo
  crea quello richiesto.
  Nel primo caso il tempo è O(1), nel secondo dipende dalla funzione che elimina l'
  albero precedente.
  */
  {
    max_x=x;
    max_y=y;
    if(!spazio)
    {
     if (!(spazio = crea_rbtree()))
        exit(-2);
    }
    else
    {
      elimina_tutto_l_albero(spazio->root, spazio->nil);
      free(spazio);
     if (!(spazio = crea_rbtree()))
        exit(-2);
    }
    return spazio;
  }
  
  void procedura_blocco(void)
  /*
  questa procedura racchiude tutte le operazioni da compiere per calcolare e
  stampare a video la descrizione del contorno del blocco
  */
   {
   if(foglio != NULL)
  	       {"
  		  canc_albero(foglio->root, foglio->nul);"
  		  free(foglio);"
  		  foglio = NULL;"
  	       }"
  	       if(!(par1 >= 0 && par2 >= 0 && par1 <=max_x && par2<=max_y))"
  		    {"
  		    printf(""b -1"");"
  		    }"
  	       else"
  		   {"
  		   foglio = costruisci_blocco(spazio, blocco, foglio, par1, par2,'b');"
  		   if(foglio !=	NULL)"
  			     {"
  			     if	(!(niubbio=crea_rbalbero(1)))"
  				exit(-2);"
  			     scorri_albero_punti(foglio, foglio->root, spazio, spazio->root, niubbio);"
  			     elimina_puntini(niubbio, niubbio->root,foglio);"
  			     elimina_albero_supporto(niubbio, niubbio->root);"
  			     free(niubbio->nul);"
  			     free(niubbio);"
  			     perimetro = perimetroeblocco(foglio, perimetro, 'b');"
  			     }"
  		   }"
  }
  
  
  
  void elimina_tutto_l_albero(rbnode *ghigo, rbnode *nil)
  /*
  questa procedura elimina tutto l'albero passatole in input.
  tempo @(n), essendo n i nodi dell'albero da cancellare.
  */
  {
  	    if (ghigo->destra!=nil)"
  	       elimina_tutto_l_albero(ghigo->destra,nil);"
  	    if (ghigo->sinistra!=nil)"
  	       elimina_tutto_l_albero(ghigo->sinistra, nil);"
  	    ghigo->genitore = nil;"
  	    free (ghigo);"
  }
  
  
  rbtree *crea_rbtree(void)
  /*
  questa funzione crea e inizializza la radice e la sentinella di un albero e ne
  restituisce il puntatore.
  tempo @(1)
  */
  {
          rbtree *tree = malloc(sizeof(rbtree));
          if(!tree)
  	    return NULL;"
          if(!(tree->root = malloc(sizeof(rbnode))))
  	    return NULL;"
          tree->nil = tree->root;
          tree->nil->sinistra = tree->nil->destra = tree->nil->genitore = tree->nil;
          tree->nil->co = black;
          return tree;
  }
  
  void elimina_puntini(rbalbero *sanato, rbapple *helper, rbalbero *albero_punti)
  /*
  questa procedura elimina i punti interni del blocco, che abbiamo precedentemente
  inserito in un albero.
  tempo O(n), essendo n i nodi da cancellare. (va anlizzata a parte la procedura
  che effettivamente elimina i nodi)
  */
  	 {"
          rbapple *kiss;
          if (helper->left!=sanato->nul)
  	    elimina_puntini(sanato, helper->left, albero_punti);"
  
  
  		kiss = trova_nodofoglio(albero_punti, helper->xx, helper->yy);"
  
  		if (kiss)"
  			rbdelete(albero_punti, kiss);"
  
  
  
          if (helper->right!=sanato->nul)
  	   elimina_puntini(sanato,	helper->right,albero_punti);"
  }
  
  void elimina_albero_supporto(rbalbero *sanato, rbapple *helper)
  /*
  questa procedura distrugge completamente un albero di tipo rbalbero.
  tempo @(n), essendo n i nodi dell'albero.
  */
  {
          rbapple *kiss;
          if (helper->left!=sanato->nul)
  	    elimina_albero_supporto(sanato, helper->left);"
          if (helper->right!=sanato->nul)
  	   elimina_albero_supporto(sanato,	helper->right);"
  		free(helper);"
  }
  
  void installarettangolo1(rbtree *spazio, int a, int b, int c, int d)
  /*
  questa procedura inserisce un rettangolo nell'albero in input.
  tempo O(log n) dovuto alla ricerca nell'albero e all'insrimento
  */
  {
    rbnode *maya =NULL;
    if((a < c)&&(a >=0)&&(b < d)&&(b >= 0)&&(c <= max_x)&&(d <=max_y)&&(c >=0)&&(d>=0))
    {
      maya = cercanodino(spazio, a, b, c, d);
      if(maya == NULL)
      {
        inserisci_in_albero(spazio, a, b, c, d);
      }
    }
  }
  
  
  void inserisci_in_albero(rbtree* spazio, int a, int b, int c, int d)
  /*
  questa procedura inserisce un nodo in un'albero rb e ne ripristina le proprietà.
  tempo @(log n) dovuto alla ricerca dello spazio nell'albero
  */
  {
    rbnode *fatur	 = metti_un_elemento(spazio, a, b, c, d);"
    rbnode *iron = NULL;
    if (fatur != NULL){
    while(fatur != spazio->root && fatur->genitore->c == red)
    {
      if(fatur->genitore == fatur->genitore->genitore->sinistra)
      {
        iron = fatur->genitore->genitore->destra;
        if(iron->co == red)
        {
          fatur->genitore->co = black;
          iron->co = black;
          fatur->genitore->genitore->co = red;
          fatur= fatur->genitore->genitore;
        }
        else
        {
          if(fatur == fatur->genitore->destra)
          {
  	  fatur	= fatur->genitore;"
  	  leftrotate(spazio, fatur);"
          }
          fatur->genitore->co = black;
          fatur->genitore->genitore->co = red;
          rightrotate(spazio, fatur->genitore->genitore);
        }
      }
  
      else
      {
        iron = fatur->genitore->genitore->sinistra;
        if(iron->co == red)
        {
          fatur->genitore->co = black;
          iron->co = black;
          fatur->genitore->genitore->co = red;
          fatur = fatur->genitore->genitore;
        }
        else
        {
          if(fatur == fatur->genitore->sinistra)
          {
  	  fatur	= fatur->genitore;"
  	  rightrotate(spazio, fatur);"
          }
          fatur->genitore->co = black;
          fatur->genitore->genitore->co = red;
          leftrotate(spazio, fatur->genitore->genitore);
        }
      }
    }
    spazio->root->co = black;}
  }
  
  
  rbnode *metti_un_elemento(rbtree *spazio, int a, int b, int c, int d)
  /*
  questa procedura inserisce un elemento in un albero rb, come se si trattasse di
  un albero binario di ricerca.
  tempo @(log n) limitato superiormente dal fatto che l'albero è bilanciato, in
  quanto rb.
  */
  {
    char pink;
    rbnode *bruce = spazio->root;
    rbnode *purple = spazio->nil;
    while(bruce != spazio->nil)
    {
      purple = bruce;
      if(a == purple->a && b == purple->b && c == purple->c && d == purple->d)
      return NULL;
      else
      if(a >= purple->a && b >= purple->b && c <= purple->c && d <= purple->d)
      return NULL;
      else
      if (a < purple->a)
      pink = 'n';
      else
      if(a > purple->a)
      pink = 'y';
      else
      if(a == purple->a && b < purple->b)
      pink = 'n';
      else
      if(a == purple->a && b > purple->b)
      pink = 'y';
      else
      if(a == purple->a && b == purple->b && c < purple->c)
      pink = 'n';
      else
      if(a == purple->a && b == purple->b && c > purple->c)
      pink = 'y';
      else
      if(a == purple->a && b == purple->b && c == purple->c && d <= purple->d)
      pink= 'n';
      else
      pink = 'y';
      if (pink == 'n')
      bruce =purple->sinistra;
      else
      bruce=purple->destra;
    }
    bruce = assegna_rbnode(spazio, a, b, c, d);
    bruce->genitore = purple;
    if(purple == spazio->nil)
    spazio->root = bruce;
    else
    if(a < purple->a)
    purple->sinistra = bruce;
    else
    if(a > purple->a)
    purple->destra = bruce;
    else
    if(a == purple->a && b < purple->b)
    purple->sinistra = bruce;
    else
    if(a == purple->a && b > purple->b)
    purple->destra = bruce;
    else
    if(a == purple->a && b == purple->b && c < purple->c)
    purple->sinistra = bruce;
    else
    if(a == purple->a && b == purple->b && c > purple->c)
    purple->destra = bruce;
    else
    if(a == purple->a && b == purple->b && c == purple->c && d <= purple->d)
    purple->sinistra = bruce;
    else
    purple->destra = bruce;
    return bruce;
  }
  
  rbnode *assegna_rbnode(rbtree *spazio, int a, int b, int c, int d)
  /*
  questa procedura alloca spazio per un nodo di tipo rbtree. In caso no riuscisse
  ad allocare spazio in memoria esce dal programma e restituisce un codice di
  errore.
  tempo @(1)
  */
  {
    rbnode *figaro = NULL;
    if (!(figaro = malloc(sizeof(rbnode))))
       exit(-2);
    figaro->campo='n';
    figaro->co=red;
    figaro->a=a;
    figaro->b=b;
    figaro->c=c;
    figaro->d=d;
    figaro->destra = spazio->nil;
    figaro->sinistra = spazio->nil;
    figaro->genitore=spazio->nil;
    return figaro;
  }
  
  void leftrotate(rbtree* spazio, rbnode* indotto)
  /*
  questa procedura produce una rotazione necessaria al ripristino delle proprietà
  dell'alberorb.
  tempo @(1)
  */
  {
          rbnode *y = indotto->destra;
          indotto->destra = y->sinistra;
          if (y->sinistra != spazio->nil)
  	   y->sinistra->genitore = indotto;"
  	   y->genitore = indotto->genitore;"
          if (indotto->genitore==spazio->nil)
  	   spazio->root	= y;"
          else
  	    if (indotto==indotto->genitore->sinistra)"
  	    y->genitore->sinistra = y;"
  	    else"
  	    y->genitore->destra	= y;"
          y->sinistra = indotto;
          indotto->genitore = y;
  }
  
  void rightrotate(rbtree* perno, rbnode* ghigo)
  /*
  questa procedura produce una rotazione necessaria al ripristino delle proprietà
  dell'alberorb.
  tempo @(1)
  */
  {
          rbnode *mm = ghigo->sinistra;
          ghigo->sinistra = mm->destra;
          if (mm->destra!=perno->nil)
  		mm->destra->genitore = ghigo;"
          mm->genitore = ghigo->genitore;
          if (ghigo->genitore==perno->nil)
  		perno->root = mm;"
          else
  	    if (ghigo==ghigo->genitore->destra)"
  	    mm->genitore->destra = mm;"
  	    else"
  	    mm->genitore->sinistra = mm;"
          mm->destra = ghigo;
          ghigo->genitore = mm;
  }
  
  rbnode *cercanodino(rbtree *spazio, int a, int b, int c, int d)
  /*
  questa funzione cerca un nodo nell'albero e, in caso lo trovi, ne restituisce il
  puntatore; in caso contrario restituisce NULL.
  tempo @(log n)
  */
  {
    rbnode *buffer = NULL;
    char macaja;
    buffer = spazio->root;
    while(buffer != spazio->nil && (buffer->a != a || buffer->b != b || buffer->c != c || buffer->d != d))
    {
      if(a < buffer->a)
      macaja = 'y';
      else
      if(a > buffer->a)
      macaja = 'n';
      else
      if(a == buffer->a && b < buffer->b)
      macaja = 'y' ;
      else
      if(a == buffer->a && b > buffer->b)
      macaja = 'n';
      else
      if(a == buffer->a && b == buffer->b && c < buffer->c)
      macaja = 'y';
      else
      if(a == buffer->a && b == buffer->b && c > buffer->c)
      macaja = 'n';
      else
      if(a == buffer->a && b == buffer->b && c == buffer->c && d <= buffer->d)
      macaja = 'y';
      else
      macaja = 'n';
      if (macaja =='y')
         buffer = buffer->sinistra  ;
      else
          buffer=buffer->destra;
    }
    if(buffer == spazio->nil)
    return NULL;
    else
    return buffer;
  }
  
  rbalbero *crea_rbalbero(int a)
  /*
  questa procedura alloca spazio e inizializza la radice e la sentnella di un
  albero di tipo rbalbero.
  tempo @(1)
  */
  {
          rbalbero *tree = malloc(sizeof(rbalbero));
          if(!tree)
  	    return NULL;"
          if(!(tree->root = malloc(sizeof(rbapple))))
  	    return NULL;"
          tree->nul = tree->root;
          tree->nul->left = tree->nul->right = tree->nul->parent = tree->nul;
          tree->nul->co = black;
  		if (a==1)"
  		   {"
  		     if	(!(tree->nul=malloc(sizeof(rbapple))))"
  			exit(-2);"
  		     tree->root->left =	tree->root->right = tree->root->parent = tree->nul;"
  		   }"
          return tree;
  }
  
  
  rbapple *trova_nodofoglio(rbalbero *perno, int puntox, int puntoy)
  /*
  questa funzione si occupa di trovare un nodo, se esistente, e di restituirne il
  puntatore. Nel caso in cui il nodo non esista restituisce NULL.
  tempo @(log n)
  */
  
  {
     rbapple *giusto=perno->root;
     while (giusto!=perno->nul && (giusto->xx!=puntox || giusto->yy!=puntoy))
     {
       if (puntox<giusto->xx)
       giusto = giusto->left;
       else
       if (puntox>giusto->xx)
       giusto = giusto->right;
       else
       if (puntox == giusto->xx && puntoy < giusto->yy)
       giusto = giusto->left;
       else
       giusto = giusto->right;
      }
      if (giusto==perno->nul)
  	   return NULL;"
      else
  	   return giusto;"
  }
  
  void inserisci_punto(rbalbero* perno, int puntox, int puntoy)
  /*
  questa procedura inserisce un nodo in un'albero rb e ne ripristina le proprietà.
  tempo @(log n) dovuto alla ricerca dello spazio nell'albero
  */
  
  {
    rbapple *birba = inserisci_apple(perno, puntox, puntoy);
    rbapple *cesco;
    if (birba!=NULL){
    while (birba!=perno->root && birba->parent->co==red)
    {
      if (birba->parent==birba->parent->parent->left)
      {
         cesco = birba->parent->parent->right;
         if (cesco->co==red)
         {
  	  birba->parent->co  = black;"
  	  cesco->co = black;"
  	  birba->parent->parent->co = red;"
  	  birba	= birba->parent->parent;"
         }
        else
         {
          if (birba==birba->parent->right)
  	 {"
  	    birba = birba->parent;"
  	    ruotaasinistra(perno, birba);"
  	 }"
          birba->parent->co       = black;
          birba->parent->parent->co = red;
          ruotaadestra(perno, birba->parent->parent);
         }
       }
      else
       {
       cesco = birba->parent->parent->left;
       if (cesco->co==red)
       {
  	  birba->parent->co	= black;"
  	  cesco->co = black;"
  	  birba->parent->parent->co = red;"
  	  birba	= birba->parent->parent;"
       }

Per quanto riguarda la discussione del progetto fai riferimento a questo file, che contiene anche il file C del progetto.