Printf arvore

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

typedef struct Node Node;

struct Node{
  Node * esq, * dir;
  int chave;
};

Node *make_empty(Node *t)
{
  if (t != NULL)
  {
    make_empty(t->esq);
    make_empty(t->dir);
    free(t);
  }

  return NULL;
}

Node *find_min(Node *t)
{
  if (t == NULL)
  {
    return NULL;
  }
  else if (t->esq == NULL)
  {
    return t;
  }
  else
  {
    return find_min(t->esq);
  }
}

Node *find_max(Node *t)
{
  if (t == NULL)
  {
    return NULL;
  }
  else if (t->dir == NULL)
  {
    return t;
  }
  else
  {
    return find_max(t->dir);
  }
}

Node *find(int elem, Node *t)
{
  if (t == NULL)
  {
    return NULL;
  }

  if (elem < t->chave)
  {
    return find(elem, t->esq);
  }
  else if (elem > t->chave)
  {
    return find(elem, t->dir);
  }
  else
  {
    return t;
  }
}

//Insert i into the Node t, duplicate will be discarded
//Return a pointer to the resulting Node.
Node * insert(int value, Node * t)
{
  Node * new_node;

  if (t == NULL)
  {
    new_node = (Node *) malloc (sizeof (Node));
    if (new_node == NULL)
    {
      return t;
    }

    new_node->chave = value;

    new_node->esq = new_node->dir = NULL;
    return new_node;
  }

  if (value < t->chave)
  {
    t->esq = insert(value, t->esq);
  }
  else if (value > t->chave)
  {
    t->dir = insert(value, t->dir);
  }
  else
  {
    //duplicate, ignore it
    return t;
  }
  return t;
}

Node * delete(int value, Node * t)
{
  //Deletes node from the Node
  // Return a pointer to the resulting Node
  Node * x;
  Node *tmp_cell;

  if (t==NULL) return NULL;

  if (value < t->chave)
  {
    t->esq = delete(value, t->esq);
  }
  else if (value > t->chave)
  {
    t->dir = delete(value, t->dir);
  }
  else if (t->esq && t->dir)
  {
    tmp_cell = find_min(t->dir);
    t->chave = tmp_cell->chave;
    t->dir = delete(t->chave, t->dir);
  }
  else
  {
    tmp_cell = t;
    if (t->esq == NULL)
    t = t->dir;
    else if (t->dir == NULL)
    t = t->esq;
    free(tmp_cell);
  }

  return t;
}


//printing Node in ascii

typedef struct asciinode_struct asciinode;

struct asciinode_struct
{
  asciinode * esq, * dir;

  //length of the edge from this node to its children
  int edge_length;

  int height;

  int lablen;

  //-1=I am esq, 0=I am root, 1=dir
  int parent_dir;

  //max supported unit32 in dec, 10 digits max
  char label[11];
};


#define MAX_HEIGHT 1000
int lprofile[MAX_HEIGHT];
int rprofile[MAX_HEIGHT];
#define INFINITY (1<<20)

//adjust gap between esq and dir nodes
int gap = 3;

//used for printing next node in the same level,
//this is the x coordinate of the next char printed
int print_next;

int MIN (int X, int Y)
{
  return ((X) < (Y)) ? (X) : (Y);
}

int MAX (int X, int Y)
{
  return ((X) > (Y)) ? (X) : (Y);
}

asciinode * build_ascii_Node_recursive(Node * t)
{
  asciinode * node;

  if (t == NULL) return NULL;

  node = malloc(sizeof(asciinode));
  node->esq = build_ascii_Node_recursive(t->esq);
  node->dir = build_ascii_Node_recursive(t->dir);

  if (node->esq != NULL)
  {
    node->esq->parent_dir = -1;
  }

  if (node->dir != NULL)
  {
    node->dir->parent_dir = 1;
  }

  sprintf(node->label, "%d", t->chave);
  node->lablen = strlen(node->label);

  return node;
}


//Copy the Node into the ascii node structre
asciinode * build_ascii_Node(Node * t)
{
  asciinode *node;
  if (t == NULL) return NULL;
  node = build_ascii_Node_recursive(t);
  node->parent_dir = 0;
  return node;
}

//Free all the nodes of the given Node
void free_ascii_Node(asciinode *node)
{
  if (node == NULL) return;
  free_ascii_Node(node->esq);
  free_ascii_Node(node->dir);
  free(node);
}

//The following function fills in the lprofile array for the given Node.
//It assumes that the center of the label of the root of this Node
//is located at a position (x,y).  It assumes that the edge_length
//fields have been computed for this Node.
void compute_lprofile(asciinode *node, int x, int y)
{
  int i, isesq;
  if (node == NULL) return;
  isesq = (node->parent_dir == -1);
  lprofile[y] = MIN(lprofile[y], x-((node->lablen-isesq)/2));
  if (node->esq != NULL)
  {
    for (i=1; i <= node->edge_length && y+i < MAX_HEIGHT; i++)
    {
      lprofile[y+i] = MIN(lprofile[y+i], x-i);
    }
  }
  compute_lprofile(node->esq, x-node->edge_length-1, y+node->edge_length+1);
  compute_lprofile(node->dir, x+node->edge_length+1, y+node->edge_length+1);
}

void compute_rprofile(asciinode *node, int x, int y)
{
  int i, notesq;
  if (node == NULL) return;
  notesq = (node->parent_dir != -1);
  rprofile[y] = MAX(rprofile[y], x+((node->lablen-notesq)/2));
  if (node->dir != NULL)
  {
    for (i=1; i <= node->edge_length && y+i < MAX_HEIGHT; i++)
    {
      rprofile[y+i] = MAX(rprofile[y+i], x+i);
    }
  }
  compute_rprofile(node->esq, x-node->edge_length-1, y+node->edge_length+1);
  compute_rprofile(node->dir, x+node->edge_length+1, y+node->edge_length+1);
}

//This function fills in the edge_length and
//height fields of the specified Node
void compute_edge_lengths(asciinode *node)
{
  int h, hmin, i, delta;
  if (node == NULL) return;
  compute_edge_lengths(node->esq);
  compute_edge_lengths(node->dir);

  /* first fill in the edge_length of node */
  if (node->dir == NULL && node->esq == NULL)
  {
    node->edge_length = 0;
  }
  else
  {
    if (node->esq != NULL)
    {
      for (i=0; i<node->esq->height && i < MAX_HEIGHT; i++)
      {
        rprofile[i] = -INFINITY;
      }
      compute_rprofile(node->esq, 0, 0);
      hmin = node->esq->height;
    }
    else
    {
      hmin = 0;
    }
    if (node->dir != NULL)
    {
      for (i=0; i<node->dir->height && i < MAX_HEIGHT; i++)
      {
        lprofile[i] = INFINITY;
      }
      compute_lprofile(node->dir, 0, 0);
      hmin = MIN(node->dir->height, hmin);
    }
    else
    {
      hmin = 0;
    }
    delta = 4;
    for (i=0; i<hmin; i++)
    {
      delta = MAX(delta, gap + 1 + rprofile[i] - lprofile[i]);
    }

    //If the node has two children of height 1, then we allow the
    //two leaves to be within 1, instead of 2
    if (((node->esq != NULL && node->esq->height == 1) ||
    (node->dir != NULL && node->dir->height == 1))&&delta>4)
    {
      delta--;
    }

    node->edge_length = ((delta+1)/2) - 1;
  }

  //now fill in the height of node
  h = 1;
  if (node->esq != NULL)
  {
    h = MAX(node->esq->height + node->edge_length + 1, h);
  }
  if (node->dir != NULL)
  {
    h = MAX(node->dir->height + node->edge_length + 1, h);
  }
  node->height = h;
}

//This function prints the given level of the given Node, assuming
//that the node has the given x cordinate.
void print_level(asciinode *node, int x, int level)
{
  int i, isesq;
  if (node == NULL) return;
  isesq = (node->parent_dir == -1);
  if (level == 0)
  {
    for (i=0; i<(x-print_next-((node->lablen-isesq)/2)); i++)
    {
      printf(" ");
    }
    print_next += i;
    printf("%s", node->label);
    print_next += node->lablen;
  }
  else if (node->edge_length >= level)
  {
    if (node->esq != NULL)
    {
      for (i=0; i<(x-print_next-(level)); i++)
      {
        printf(" ");
      }
      print_next += i;
      printf("/");
      print_next++;
    }
    if (node->dir != NULL)
    {
      for (i=0; i<(x-print_next+(level)); i++)
      {
        printf(" ");
      }
      print_next += i;
      printf("\\");
      print_next++;
    }
  }
  else
  {
    print_level(node->esq,
      x-node->edge_length-1,
      level-node->edge_length-1);
      print_level(node->dir,
        x+node->edge_length+1,
        level-node->edge_length-1);
      }
    }

    //prints ascii Node for given Node structure
    void print_ascii_Node(Node * t)
    {
      asciinode *proot;
      int xmin, i;
      if (t == NULL) return;
      proot = build_ascii_Node(t);
      compute_edge_lengths(proot);
      for (i=0; i<proot->height && i < MAX_HEIGHT; i++)
      {
        lprofile[i] = INFINITY;
      }
      compute_lprofile(proot, 0, 0);
      xmin = 0;
      for (i = 0; i < proot->height && i < MAX_HEIGHT; i++)
      {
        xmin = MIN(xmin, lprofile[i]);
      }
      for (i = 0; i < proot->height; i++)
      {
        print_next = 0;
        print_level(proot, -xmin, i);
        printf("\n");
      }
      if (proot->height >= MAX_HEIGHT)
      {
        printf("(This Node is taller than %d, and may be drawn incorrectly.)\n", MAX_HEIGHT);
      }
      free_ascii_Node(proot);
    }

void BTfromFile(Node** raiz){
  FILE* arq = fopen("C:\\Users\\Alunos\\Downloads\\BT.txt", "r");
  if(arq==NULL) {printf(" Problema ao abrir arquivo!"); return;}
  else{
    int chave;
    char buffer;
    while(1){
      fscanf(arq, "%d, ", &chave);
      insert(chave, raiz);
      if(feof(arq)){
        break;
      }
    }
  }
  fclose(arq);
}

    //driver routine
    int main()
    {
      //A sample use of these functions.  Start with the empty Node
      //insert some stuff into it, and then delete it
      Node * root;
      int i;
      root = NULL;

      make_empty(root);

      BTfromFile(&root);

      /*printf("\nAfter inserting chave 10..\n");
      root = insert(10, root);
      print_ascii_Node(root);

      printf("\nAfter inserting chave 5..\n");
      root = insert(5, root);
      print_ascii_Node(root);

      printf("\nAfter inserting chave 15..\n");
      root = insert(15, root);
      print_ascii_Node(root);

      printf("\nAfter inserting chaves 9, 13..\n");
      root = insert(9, root);
      root = insert(13, root);
      print_ascii_Node(root);

      printf("\nAfter inserting chaves 2, 6, 12, 14, ..\n");
      root = insert(2, root);
      root = insert(6, root);
      root = insert(12, root);
      root = insert(14, root);
      print_ascii_Node(root);


      printf("\n\nAfter deleting a node (14) with no child..\n");
      root = delete(14, root);
      print_ascii_Node(root);

      printf("\n\nAfter deleting a node (13) with esq child..\n");
      root = delete(13, root);
      print_ascii_Node(root);

      printf("\n\nAfter deleting a node (5) with esq and dir children..\n");
      root = delete(5, root);
      print_ascii_Node(root);

      printf("\n\nAfter deleting a node (10, root node) with esq and dir children..\n");
      root = delete(10, root);*/
      print_ascii_Node(root);

      make_empty(root);
    }