Segregate even and odd nodes in sorted order in c

C program for Segregate even and odd nodes in sorted order. Here more information.

// Include header file
#include <stdio.h>
#include <stdlib.h>
 // C program for
// Segregate even and odd nodes in ascending order

// Linked list node
typedef struct LinkNode {
	// Define useful field of LinkNode
	int data;
	struct LinkNode * next;
}LinkNode;

LinkNode * getLinkNode(int data) {
	// Create dynamic memory of LinkNode
	LinkNode * ref = (LinkNode * ) malloc(sizeof(LinkNode));
	if (ref == NULL) {
		// Failed to create memory 
		return NULL;
	}
	ref->data = data;
	ref->next = NULL;
	return ref;
}

typedef struct SingleLL {
	// Define useful field of SingleLL
	struct LinkNode * head;
}SingleLL;

SingleLL * getSingleLL() {
	// Create dynamic memory of SingleLL
	SingleLL * ref = (SingleLL * ) malloc(sizeof(SingleLL));
	if (ref == NULL) {
		// Failed to create memory 
		return NULL;
	}
	// Set head value
	ref->head = NULL;
	return ref;
}

// Add new node at the end of linked list
void insert(SingleLL * ref, int value) {
	// Create a node
	LinkNode * node = getLinkNode(value);
	if (ref->head == NULL) {
		ref->head = node;
	} else {
		LinkNode * temp = ref->head;
		// Find last node
		while (temp->next != NULL) {
			// Visit to next node
			temp = temp->next;
		}
		// Add node at last position
		temp->next = node;
	}
}

// Display all Linked List elements
void display(SingleLL * ref) {
	if (ref->head != NULL) {
		printf("\n");
		LinkNode * temp = ref->head;
		while (temp != NULL) {
			// Display node value
			printf(" %d ", temp->data);
			// Visit to next node
			temp = temp->next;
		}
		
	} else {
		printf("\nEmpty Linked list\n");
	}
}
void sortedAdd(SingleLL * ref, LinkNode * element) {
	if (ref->head == NULL) {
		ref->head = element;
	} else if (ref->head->data >= element->data) {
		element->next = ref->head;
		ref->head = element;
	} else {
		LinkNode * temp = ref->head;
		// Finding location of inserting node
		while (temp->next != NULL && 
               temp->next->data < element->data) {
			// Visit to next node
			temp = temp->next;
		}
		// Add node 
		element->next = temp->next;
		temp->next = element;
	}
}
void segregateNode(SingleLL * ref, 
                   SingleLL * odd, 
                   SingleLL * even) {
	LinkNode * node = NULL;
	// Iterating the linked list node
	while (ref->head != NULL) {
		node = ref->head;
		// Visit to next node
		ref->head = node->next;
		// Set null to next node
		node->next = NULL;
		if (node->data % 2 == 0) {
			// When node value is Even
			sortedAdd(even, node);
		} else {
			// When node value is Odd
			sortedAdd(odd, node);
		}
	}
}
int main() {
	// Create linked lists
	SingleLL * sll = getSingleLL();
	SingleLL * odd = getSingleLL();
	SingleLL * even = getSingleLL();
	// Linked list sll
	// 4 → 3 → 5 → 2 → 11 → 1 → 6 → NULL
	insert(sll, 4);
	insert(sll, 3);
	insert(sll, 5);
	insert(sll, 2);
	insert(sll, 11);
	insert(sll, 1);
	insert(sll, 6);
	printf("Initial Element");
	// Display all node
	display(sll);
	segregateNode(sll, odd, even);
	printf("\nEven Element");
	// Display all even node
	display(even);
	printf("\nOdd Element");
	// Display all odd node
	display(odd);
}

Output

Initial Element
 4  3  5  2  11  1  6
Even Element
 2  4  6
Odd Element
 1  3  5  11