Maxima_Anchura

#include <stdio.h>
#include <stdlib.h>

typedef struct nodo{
    int valor;
    struct nodo* ptrHI;
    struct nodo* ptrHD;
} TNodo;

typedef struct nodo6{
    int valor;
    struct nodo6* sig;
}TLista;

typedef struct nodo2{
    TNodo* valor;
    struct nodo2* sig;
}TCola;

void crear_arbol(TNodo ** ptrRaiz);
void inserta_nodo(TNodo **ptrRaiz, int valor);
void inserta_final(TLista **, int);

void inserta_final(TLista **ptrListaSE, int valor){
    TLista *ptrNuevo, *ptrUltimo, *ptrRecorrido;
    ptrNuevo = (TLista*)malloc(sizeof(TLista));
    ptrNuevo->valor = valor;
    ptrNuevo->sig = NULL;

    ptrRecorrido = *ptrListaSE;
    ptrUltimo = NULL;
    while (ptrRecorrido){
        ptrUltimo = ptrRecorrido;
        ptrRecorrido = ptrRecorrido->sig;
    }

    if (ptrUltimo)
        ptrUltimo->sig = ptrNuevo;
    else
        (*ptrListaSE) = ptrNuevo;
}
void ponerEnCola(TNodo*nodo, TCola**Cola){ //lo pone al ultimo, no pone nulos
    if(nodo){
        TCola*nuevo=(TCola*)malloc(sizeof(TCola));
        nuevo->valor=nodo;
        nuevo->sig=NULL;
        TCola*recor=*Cola;
        TCola*ant=NULL;
        while(recor){
            ant=recor;
            recor=recor->sig;
        }
        if(ant==NULL){
            *Cola=nuevo;
        }else{
            ant->sig=nuevo;
        }
    }
}

TNodo* sacarDeCola(TCola**Cola){ //saca el del primero
    if(*Cola){
        TNodo*nuevo;
        TCola*sacar=*Cola;
        nuevo=sacar->valor;
        *Cola=(*Cola)->sig;
        free(sacar);
        return nuevo;
    }
}
void crear_arbol(TNodo ** ptrRaiz){
    *ptrRaiz = NULL;
}

void inserta_nodo(TNodo **ptrRaiz, int valor){
    TNodo *ptrHoja, *ptrRecorrido, *ptrPadre;
    ptrHoja = (TNodo*)malloc(sizeof(TNodo));
    ptrHoja->valor = valor;
    ptrHoja->ptrHI=ptrHoja->ptrHD=NULL;

    if(*ptrRaiz){
        ptrRecorrido = *ptrRaiz;
        ptrPadre = NULL;

        while (ptrRecorrido){
            ptrPadre = ptrRecorrido;
            if (ptrRecorrido->valor > valor)
                ptrRecorrido = ptrRecorrido->ptrHI;
            else
                ptrRecorrido = ptrRecorrido->ptrHD;
        }
        if (ptrPadre->valor > valor)
            ptrPadre->ptrHI = ptrHoja;
        else
            ptrPadre->ptrHD = ptrHoja;
    }
    else{
     *ptrRaiz = ptrHoja;
    }
}


/* Calcula la altura del arbol.*/
int height(TNodo* node)
{
   if (node==NULL)
     return 0;
   else
   {
     /* calcula la altura de cada sub-arbol */
     int lHeight = height(node->ptrHI);
     int rHeight = height(node->ptrHD);
     /* retorna el maximo de ambas alturas */

     return (lHeight > rHeight)? (lHeight+1): (rHeight+1);
   }
}

/* Calcula la anchura de cada nivel */
int getWidth(TNodo* root, int level)
{

  if(root == NULL)
    return 0;

  if(level == 1)
    return 1;

  else if (level > 1)
    return getWidth(root->ptrHI, level-1) +
             getWidth(root->ptrHD, level-1);
}

/* Funcion que retorna el nivel de maxiam anchura del arbol*/
int getMaxWidth(TNodo* root)
{
  int maxWidth = 0;
  int width;
  int h = height(root);
  int i,level;

  /* Saco la anchura de cada nivel y comparo */
  for(i=1; i<=h; i++)
  {
    width = getWidth(root, i);
    if(width > maxWidth) {
        maxWidth = width;
         level=i;
    }

  }

  return level;
}


void recorridoAmplitud(TNodo*arbol2){
    if(arbol2){
        TCola* Cola=NULL; //cola creada
        TNodo* nodo=arbol2;
        ponerEnCola(nodo, &Cola);
        while(Cola){
            nodo=sacarDeCola(&Cola);
            printf("%d-",nodo->valor);
            ponerEnCola(nodo->ptrHD, &Cola);
            ponerEnCola(nodo->ptrHI, &Cola);
        }
    }
}
int main(int argc, char** argv) {
TNodo *ptrRaiz;
    crear_arbol(&ptrRaiz);
    inserta_nodo(&ptrRaiz, 4);
    inserta_nodo(&ptrRaiz, 2);
    inserta_nodo(&ptrRaiz, 1);
    inserta_nodo(&ptrRaiz, 6);
    inserta_nodo(&ptrRaiz, 5);
    inserta_nodo(&ptrRaiz, 7);
    inserta_nodo(&ptrRaiz, 10);
    inserta_nodo(&ptrRaiz, 3);
    int i=getMaxWidth(ptrRaiz);
    recorridoAmplitud(ptrRaiz);
 return (EXIT_SUCCESS);
}