Segmentation fault programming an AVL tree in C programming language - c

Question

I have written a code to create an AVL tree.
Write a program that sorts the given integer values. The number of values is not known in advance. Your program will output the sorted values and the structure of the tree using given output format. (Assume for this lab study,
values are distinct). Use AVL tree in your program.
Input:
72 18 28 36 27 117 108 90 -1
Your output will be the sorted list of given numbers (In-order walk on AVL tree produce the sorted list).
18
27
28
36
72
90
108
117
Your program should also print the AVL tree in the following way (First number represents the value, second number displays the parent node and the third number shows the balance factor. B is used for balance factor, L represents left child and R represents right child).
28 (-1 B)
18 (28 L) (-1 B) 72 (28 R) (-1 B)
27 (18 R) (0 B) 36 (72 L) (0 B) 108 (72 R) (0 B) 90 (108 L) (0 B) 117 (108 R) (0 B)
#include <stdio.h>
#include <stdlib.h>
struct treeNode {
int value;
struct treeNode* leftChild;
struct treeNode* rightChild;
int height;
};
int height( struct treeNode *root) {
if(root==NULL) {
return -1;
}
else {
return root->height;
}
}
int max(int a,int b) {
if (a>b) {
return a;
}
else {
return b;
}
}
struct treeNode *createNode( int value) {
struct treeNode* root= (struct treeNode*) malloc(sizeof(struct treeNode));
root->value=value;
root->leftChild=NULL;
root->rightChild=NULL;
root->height=1;
return root;
}
int balanceFactor(struct treeNode *root) {
if(root==NULL) {
return 0;
}
else {
return height(root->leftChild)-height(root->rightChild);
}
}
struct treeNode *leftRotation(struct treeNode* parent) {
struct treeNode *child1= parent->rightChild;
struct treeNode *child2= child1->leftChild;
child1->leftChild=parent;
parent->rightChild= child2;
parent->height=max(height(parent->rightChild), height(parent->leftChild)) +1;
child1->height=max(height(child1->rightChild), height(child1->leftChild)) +1;
return child1;
}
struct treeNode *rightRotation(struct treeNode* child1) {
struct treeNode *parent = child1->rightChild;
struct treeNode *child2= parent->rightChild;
parent->rightChild=child1;
child1->leftChild= child2;
parent->height=max(height(parent->rightChild), height(parent->leftChild)) +1;
child1->height=max(height(child1->rightChild), height(child1->leftChild)) +1;
return parent;
}
struct treeNode *RL(struct treeNode *c) {
c->leftChild=rightRotation(c->leftChild);
return leftRotation(c);
}
struct treeNode *LR(struct treeNode *b) {
b->rightChild=leftRotation(b->rightChild);
return rightRotation(b);
}
struct treeNode *insert(struct treeNode* root, int value) {
if (root==NULL) {
return (createNode(value));
}
if( value< root->value) {
root->leftChild= insert(root->leftChild,value);
}
else if(value> root->value) {
root->rightChild=insert(root->rightChild, value);
}
else {
return root;
}
root->height=1 + max(height(root->leftChild), height(root->rightChild));
int balanceF= balanceFactor(root);
if(balanceF<-1 && value> root->rightChild->value) {
return leftRotation(root);
}
if (balanceF<-1 && value< root->rightChild->value) {
root->rightChild=rightRotation(root->rightChild);
return leftRotation(root);
}
if(balanceF>1 && value<root->leftChild->value) {
return rightRotation(root);
}
if(balanceF>1 && value<root->leftChild->value) {
root->leftChild=leftRotation(root->leftChild);
return rightRotation(root);
}
return root;
}
void inorder(struct treeNode *root) {
if (root) {
inorder(root->leftChild);
printf("%d \n", root->value);
inorder(root->rightChild);
}
}
int treeHeight( struct treeNode *root) {
if (root== NULL ) {
return 0;
}
else{
int leftHeight = treeHeight(root->leftChild);
int rightHeight= treeHeight(root->rightChild);
if (leftHeight>rightHeight) {
return (leftHeight+1);
}
else {
return (rightHeight+1);
}
}
}
void currentLevel (struct treeNode *root, int treeheight, struct treeNode *parent, char child ) {
if (root != NULL) {
if (treeheight==0) {
if (parent !=NULL) {
int bf=balanceFactor(root);
printf("%d (%d %c)(%d B)", root->value, parent->value, child, bf);
}
else {
printf("%d \n", root->value);
}
}
else if (treeheight>0) {
currentLevel(root->leftChild, treeheight-1, root, 'L' );
currentLevel(root->rightChild, treeheight-1, root, 'R');
}
}
}
int main () {
struct treeNode *root = NULL;
int value;
while(1) {
scanf ("%d", &value);
if(value==-1) {
break;
}
root=insert(root,value);
}
inorder(root);
int i;
int height= treeHeight(root);
for (int i=0; i<=height;i++) {
currentLevel(root,i, NULL, ' ');
printf("\n");
}
return 0;
}