LinsmarVital

Estou tentando fazer uma árvore AVL com recursão, mas estou tendo problemas na função de balanceamento, estou recebendo erro de segmentação, já tentei várias coisas e sempre acho um erro novo, aqui estão as funções: struct node { int element, height; struct node *left = NULL, *right = NULL; }; typedef struct node node_t; //Função de criação de nó node_t *newNode (){ node_t *p = (node_t *)malloc(sizeof(node_t)); if (p) { p->element = -1; p->right = p->left = NULL; p->height = 0; } return p; } //Função pra ver a altura do nó int avl_height(node_t *x) { if (x) return x->height; return -1; } //Função pra rotação esquerda node_t *avl_rLeft(node_t *x) { node_t *y = newNode(); y = x->right; x->right = y->left; y->left = x; x->height = 1 + (MAX(avl_height(x->left), avl_height(x->right))); y->height = 1 + (MAX(avl_height(y->left), avl_height(y->right))); return y; } //Função pra rotação direita node_t *avl_rRight(node_t *x) { node_t *y = newNode(); y = x->left; x->left = y->right; y->right = x; x->height = 1 + (MAX(avl_height(x->left), avl_height(x->right))); y->height = 1 + (MAX(avl_height(y->left), avl_height(y->right))); return y; } //Função de rebalanceamento node_t *rebalance (node_t *r) { int lh = avl_height(r->left); int rh = avl_height(r->right); int th = lh - rh; r->height = 1 + (MAX(lh, rh)); if (th == 2) { if (avl_height(r->left->right) > avl_height(r->left->left)) r->left = avl_rLeft(r->left); r = avl_rRight(r); } else if (th == -2) { if (avl_height(r->right->left) > avl_height(r->right->right)) r->right = avl_rRight(r->right); r = avl_rLeft(r); } return r; } //Função de inserir na árvore node_t *avl_insert (int e, node_t *r) { if (r == NULL) { r = newNode(); r->element = e; return r; } else if (r->element > e) r->left = avl_insert(e, r->left); else if (r->element < e) r->right = avl_insert(e, r->right); return rebalance(r); } O max é só pra pegar o maior entre 2 elementos (#define MAX(a, b) (a > b)?a:b)

Bom, tenho um trabalho pra fazer em c/c++ que funciona da seguinte maneira: Existe um arquivo de entrada .txt, com 2 listas de números, tenho que pegar essas 2 listas, juntar as 2 e me livrar das duplicatas e jogar o resultado em outro txt, exemplo: entrada.txt: [1 2 23 42] [3 32 4 23 1] saida.txt: [1 2 3 4 23 32 42] Não precisa estar ordenado que nem no exemplo acima. Eu fiz, lendo char por char, ignorei o primeiro '[', depois verifiquei se vinha algo diferente de ']' em seguida e se viesse, eu ia pondo o caracter num array que fiz assim: char *caracVetor = (char *) malloc(sizeof(char)*2147483647); Quando chegasse no espaço, parava e transformava o array em inteiro, com a função atoi. //Passando o que tem dentro do arquivo para a 1ª lista fscanf (in, "%c", &caracter); //Lendo o caracter '[' for (; caracter != ']';) { //O for funciona enquanto caracter for diferente de ] fscanf(in, "%c", &caracter); if (caracter == ']') break; //Se achar o caracter ] logo de cara, acaba o loop. else { //Se não: for (int o = 0; caracter != ' '; o++) { //Loop pra pegar números grandes caracVetor[o] = caracter; //Joga o caracter dentro do vetor de caracteres fscanf (in, "%c", &caracter); //Ve quem é o proximo no arquivo if (caracter == ' ' || caracter == ']') { //Se for espaço ou ], acaba aux = atoi(caracVetor); //Transforma o vetor de caracteres em inteiro break; } } insert(aux, h1); //Insere na lista 1 qntdLista1++; free(caracVetor); } } Está dando tudo certo, o problema é o seguinte(paranoia minha): E se o professor por como exemplo um número maior que 2147483647? Entendo que posso mudar a struct da lista e fazer ela aceitar long int invés de só int e também posso aumentar esse número no malloc, mas tudo tem 1 limite. Existe alguma forma de quebrar esse limite? Se o professor por um número como "9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999" existe alguma forma de eu pegar ele no arquivo e transformar em inteiro depois? Ou é impossível e nem preciso me preocupar com isso?