Question

Given a single linked chain of nodes with positive integers, write an algorithm in pseudocode to rearrange the nodes in one pass in such a way that all integers that are odd appear at the end. The relative order of the elements does not need to remain the same.

List all the steps in the proper order that are necessary to rearrange the nodes, show how the next pointers are being changed. Each data element should “stay” in its original node. The algorithm cannot assume that the chain is not empty.

Answer 1

1). ANSWER :

GIVENTHAT :

Pseudo Code:( I suggest you to have a look on implementation given below :)

ListNode OddInTheEnd(ListNode head){

   ListNode odd = NULL;
   ListNode otail = NULL;
  
   ListNode even = NULL;
   ListNode etail = NULL;
  
ListNode curr = *head;

while(curr != NULL){
  
if (curr->data == 1)
       {
           if (odd == NULL)
           odd = otail = curr; END IF

           else
           {
otail->next = curr;
           otail = otail->next;
           } END ELSE

       } END IF
  
else
       {
           if (even == NULL)
               even = etail = curr; END IF

           else
           {
               etail->next = curr;
               etail = curr;
           }END ELSE
       } END ELSE

curr = curr->next;

} END WHILE

if (even)
   {
       *head = even;
       etail->next = odd;
   } END IF

else
       *head = odd; END ELSE

if (otail)
       otail->next = NULL;
END IF

} END FUNCTION

Implementation in C:

#include <stdio.h>
#include <stdlib.h>

// linked list node
struct Node
{
   int data;
   struct Node* next;
};

// arrange linked list in such a order such that
// odd nodes appear in the end
void OddInTheEnd(struct Node** head)
{
// will point head of odd node list
   struct Node* odd = NULL;
   struct Node* otail = NULL;
  
   // will point head of even node list
   struct Node* even = NULL;
   struct Node* etail = NULL;

   struct Node* curr = *head;

// loop untill curr is not null i.e till end node
   while (curr != NULL)
   {
       if (curr->data & 1) // if current node is odd
       {
           // 1st odd node
           if (odd == NULL)
               odd = otail = curr;
           else
           {
               otail->next = curr;
               otail = otail->next;
           }
       }
       else // else current node is even
       {
           // 1st even node
           if (even == NULL)
               even = etail = curr;
           else
           {
               etail->next = curr;
               etail = curr;
           }
       }
       curr = curr->next;
   }

   // if list contains at-least one even node
   if (even)
   {
       *head = even;
       etail->next = odd;
   }
   // if list contains all odd nodes
   else
       *head = odd;

   // NULL to terminate the list,
   if (otail)
       otail->next = NULL;
}

// insert a new Node in the beginning of the linked list
void push(struct Node** head, int data)
{
   struct Node* newnode = (struct Node*)malloc(sizeof(struct Node));
   newnode->data = data;
   newnode->next = *head;
   *head = newnode;
}

// print given linked list
void print(struct Node* head)
{
   struct Node* ptr = head;
   while (ptr)
   {
       printf("%d -> ", ptr->data);
       ptr = ptr->next;
   }

   printf("NULL\n");
}

// main method
int main(void)
{

   struct Node* head = NULL;
  
       push(&head,13);
       push(&head,34);
       push(&head,22);
       push(&head,12);
       push(&head,21);
       push(&head,2);
       push(&head,1);
       push(&head,6);
       push(&head,7);
      
       printf("\n");
      
       printf(" List before Arranging : ");
      
       print(head);
      
       printf("\n");

   OddInTheEnd(&head);
  
   printf(" List After Arranging odd nodes in the end : ");

   print(head);

   return 0;
}

THE ABOVE PROGRAM OUTPUT :-

< input List before Arranging : 7 -> 6 -> 1 -> 2 -> 21 -> 12 -> 22 -> 34 -> 13 -> NULL List After Arranging odd nodes in the end : 6 -> 2 -> 12 -> 22 -> 34 -> 7 -> 1 -> 21 -> 13 -> NULL . Program finished with exit code 0 Press ENTER to exit console. I