Skip to main content

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




Comment

Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.

New Comment