Red Black Tree insertion

// C program 
// Red-Black Tree insertion
#include <stdio.h>

#include <stdlib.h>

//Color 0 , 1
enum NodeColor
{
	RED , BLACK
};
//Red black tree node
struct Node
{
	//Node data 
	int data;
	//Node color
	int color;
	struct Node *left, *right, *parent;
};
//Create a new node of Red-Black tree
struct Node *create_node(int data)
{
	struct Node *new_node = (struct Node *) malloc(sizeof(struct Node));
	if (new_node != NULL)
	{
		//Set Red black tree node value
		new_node->data = data;
		new_node->left = NULL;
		new_node->right = NULL;
		new_node->parent = NULL;
		new_node->color = RED;
	}
	else
	{
		printf("\n Memory Overflow ");
	}
	return new_node;
}
// Add new node in given red black tree 
// This is similar to insert node in binary search tree
struct Node *insert_node(struct Node *root, struct Node *node)
{
	if (root == NULL)
	{
		//When get a null node
		//return tree node
		return node;
	}
	if (node->data < root->data)
	{
		// Add node in left side
		root->left = insert_node(root->left, node);
		// Modify the parent node value
		root->left->parent = root;
	}
	else if (node->data > root->data)
	{
		// Add node in right side
		root->right = insert_node(root->right, node);
		// Modify the parent node value 
		root->right->parent = root;
	}
	return root;
}
//Perform left rotation operation
void rotate_left(struct Node **root, struct Node *node)
{
	//Get right node
	struct Node *node_right = node->right;
	//Change the right subtree in given node
	node->right = node_right->left;
	if (node->right != NULL)
	{
		// When node right subtree exists then change its parent value
		node->right->parent = node;
	}
	//Change the value of previously get right-node parent 
	node_right->parent = node->parent;
	if (node->parent == NULL)
	{
		//In case no parent of given node
		//Then make new root of Red-Black tree
		*root = node_right;
	}
	else if (node == node->parent->left)
	{
		node->parent->left = node_right;
	}
	else
	{
		node->parent->right = node_right;
	}
	//final rotation
	node_right->left = node;
	node->parent = node_right;
}
//Perform right rotation operation
void rotate_right(struct Node **root, struct Node *node)
{
	//Get left node
	struct Node *node_left = node->left;
	node->left = node_left->right;
	if (node->left != NULL)
	{
		node->left->parent = node;
	}
	node_left->parent = node->parent;
	if (node->parent == NULL)
	{
		//In case no parent of given node
		//Then make new root of Red-Black tree
		*root = node_left;
	}
	else if (node == node->parent->left)
	{
		node->parent->left = node_left;
	}
	else
	{
		node->parent->right = node_left;
	}
	//final rotation
	node_left->right = node;
	node->parent = node_left;
}
// Transform node in valid Red-Black tree
void fix_node(struct Node **root, struct Node **node)
{
	//Define some useful auxiliary variables
	struct Node *parent = NULL;
	struct Node *grand_parent = NULL;
	struct Node *uncle_node = NULL;
	int temp = 0;
	while (( *node != *root) && (( *node)->color != BLACK) && (( *node)->parent->color == RED))
	{
		parent = ( *node)->parent;
		grand_parent = ( *node)->parent->parent;
		// When parent of node is equal to left-child of Grandparents
		if (parent == grand_parent->left)
		{
			uncle_node = grand_parent->right;
			// When uncle node is red node 
			if (uncle_node != NULL && uncle_node->color == RED)
			{
				// Modified color
				grand_parent->color = RED;
				parent->color = BLACK;
				uncle_node->color = BLACK;
				( *node) = grand_parent;
			}
			else
			{
				if (( *node) == parent->right)
				{
					//Left-rotation required
					rotate_left(root, parent);
					( *node) = parent;
					parent = ( *node)->parent;
				}
				//Right-rotation required
				rotate_right(root, grand_parent);
				//swapping the value of node color
				temp = parent->color;
				parent->color = grand_parent->color;
				grand_parent->color = temp;
				//Change node parent 
				( *node) = parent;
			}
		}
		/*When parent of node is equal to right-child of Grandparents*/
		else
		{
			uncle_node = grand_parent->left;
			// When uncle node is red node 
			if ((uncle_node != NULL) && (uncle_node->color == RED))
			{
				grand_parent->color = RED;
				parent->color = BLACK;
				uncle_node->color = BLACK;
				//Change node parent
				( *node) = grand_parent;
			}
			else
			{
				if (( *node) == parent->left)
				{
					//Right-rotation required 
					rotate_right(root, parent);
					( *node) = parent;
					parent = ( *node)->parent;
				}
				// Left-rotation required
				rotate_left(root, grand_parent);
				// Swapping the value of node color
				temp = parent->color;
				parent->color = grand_parent->color;
				grand_parent->color = temp;
				( *node) = parent;
			}
		}
	}
}
//Print tree elements in preorder traversal
void preorder(struct Node *root)
{
	if (root == NULL)
	{
		return;
	}
	printf("  %d", root->data);
	preorder(root->left);
	preorder(root->right);
}
//Print tree elements in inorder traversal
void inorder(struct Node *root)
{
	if (root == NULL)
	{
		return;
	}
	inorder(root->left);
	printf("  %d", root->data);
	inorder(root->right);
}
//Print tree elements in preorder traversal
void postprder(struct Node *root)
{
	if (root == NULL)
	{
		return;
	}
	postprder(root->left);
	postprder(root->right);
	printf("  %d", root->data);
}
// Handle the request of add new node into given Red-Black tree
void insert(struct Node **root, int data)
{
	//Create a new node
	struct Node *node = create_node(data);
	//Add node into given tree
	*root = insert_node( *root, node);
	//Fix Red Black Tree violations 
	fix_node(root, & node);
	//Change root node color
	( *root)->color = BLACK;
}
int main()
{
	struct Node *root = NULL;
	//Add tree element
	insert( & root, 18);
	insert( & root, 5);
	insert( & root, 1);
	insert( & root, 11);
	insert( & root, 21);
	insert( & root, 6);
	insert( & root, 9);
	insert( & root, 7);
	insert( & root, 30);
	insert( & root, 40);
	/*
	  Constructed Red-Black Tree

	            9
	         /     \
	        5       18
	       / \     /   \  
	      1   6   11   30
	           \      /   \
	            7    21    40
	*/
	printf("Inorder\n");
	inorder(root);
	printf("\nPreorder\n");
	preorder(root);
	printf("\nPostprder\n");
	postprder(root);
	return 0;
}

Output

Inorder
  1  5  6  7  9  11  18  21  30  40
Preorder
  9  5  1  6  7  18  11  30  21  40
Postprder
  1  7  6  5  11  21  40  30  18  9