Alternating split of a given Singly Linked List - c

Question

Write a function AlternatingSplit() that takes one list and divides up its nodes to make two smaller lists ‘a’ and ‘b’. The sublists should be made from alternating elements in the original list. So if the original list is 0->1->0->1->0->1 then one sublist should be 0->0->0 and the other should be 1->1->1.
More details about the problem - http://www.geeksforgeeks.org/alternating-split-of-a-given-singly-linked-list/
Now i made this code and it's running successfully
#include<stdio.h>
#include<stdlib.h>
struct node
{
int num;
node *next;
};
node *start1 = NULL, *start2 = NULL, *start3 = NULL;
void push()
{
node *temp = (node *)malloc(sizeof(node));
printf("Enter number = ");
scanf("%d", &temp->num);
temp -> next = start1;
start1 = temp;
}
void split()
{
while(start1 != NULL)
{
node *temp1 = (node *)malloc(sizeof(node));
temp1 ->num = start1 ->num;
temp1->next = start2;
start2 = temp1;
start1 = start1 -> next;
if(start1 != NULL)
{
node *temp2 = (node *)malloc(sizeof(node));
temp2 ->num = start1 ->num;
temp2->next = start3;
start3 = temp2;
start1 = start1 -> next;
}
}
}
int main()
{
int n;
scanf("%d", &n);
while(n--)
push();
split();
node *temp = start2;
while(temp != NULL)
{
printf("%d ", temp ->num);
temp = temp ->next;
}
printf("\n");
temp = start3;
while(temp != NULL)
{
printf("%d ", temp ->num);
temp = temp ->next;
}
return 0;
}
And the code provided with the question is -
/*Program to alternatively split a linked list into two halves */
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
/* Link list node */
struct node
{
int data;
struct node* next;
};
/* pull off the front node of the source and put it in dest */
void MoveNode(struct node** destRef, struct node** sourceRef) ;
/* Given the source list, split its nodes into two shorter lists.
If we number the elements 0, 1, 2, ... then all the even elements
should go in the first list, and all the odd elements in the second.
The elements in the new lists may be in any order. */
void AlternatingSplit(struct node* source, struct node** aRef, struct node** bRef)
{
/* split the nodes of source to these 'a' and 'b' lists */
struct node* a = NULL;
struct node* b = NULL;
struct node* current = source;
while (current != NULL)
{
MoveNode(&a, &current); /* Move a node to list 'a' */
if (current != NULL)
{
MoveNode(&b, &current); /* Move a node to list 'b' */
}
}
*aRef = a;
*bRef = b;
}
/* Take the node from the front of the source, and move it to the front of the dest.
It is an error to call this with the source list empty.
Before calling MoveNode():
source == {1, 2, 3}
dest == {1, 2, 3}
Affter calling MoveNode():
source == {2, 3}
dest == {1, 1, 2, 3}
*/
void MoveNode(struct node** destRef, struct node** sourceRef)
{
/* the front source node */
struct node* newNode = *sourceRef;
assert(newNode != NULL);
/* Advance the source pointer */
*sourceRef = newNode->next;
/* Link the old dest off the new node */
newNode->next = *destRef;
/* Move dest to point to the new node */
*destRef = newNode;
}
/* UTILITY FUNCTIONS */
/* Function to insert a node at the beginging of the linked list */
void push(struct node** head_ref, int new_data)
{
/* allocate node */
struct node* new_node = (struct node*) malloc(sizeof(struct node));
/* put in the data */
new_node->data = new_data;
/* link the old list off the new node */
new_node->next = (*head_ref);
/* move the head to point to the new node */
(*head_ref) = new_node;
}
/* Function to print nodes in a given linked list */
void printList(struct node *node)
{
while(node!=NULL)
{
printf("%d ", node->data);
node = node->next;
}
}
/* Drier program to test above functions*/
int main()
{
/* Start with the empty list */
struct node* head = NULL;
struct node* a = NULL;
struct node* b = NULL;
/* Let us create a sorted linked list to test the functions
Created linked list will be 0->1->2->3->4->5 */
push(&head, 5);
push(&head, 4);
push(&head, 3);
push(&head, 2);
push(&head, 1);
push(&head, 0);
printf("\n Original linked List: ");
printList(head);
/* Remove duplicates from linked list */
AlternatingSplit(head, &a, &b);
printf("\n Resultant Linked List 'a' ");
printList(a);
printf("\n Resultant Linked List 'b' ");
printList(b);
getchar();
return 0;
}
My query here is, which of these two codes are more efficient and more correct for this question, considering the time complexity, space complexity and every other factor?
And why?
A detailed explanation will be more helpful.

Answer 1

When you just split a linked list, you don't need any memory allocations, it's enough to just shuffle around pointers.
Your code does memory allocations when splitting, so it is rather inefficient that way, the model answer code is much better.
But worse, your code leaks memory. It loses the pointers to original list elements without freeing them. So your code is actually buggy, in a bad way.
To fix just the memory leak, which is an actual bug, you would need to change the two start1 = start1 -> next; lines to this:
node *tmp_next = start1->next;
free(start1);
start1 = tmp_next;
For other changes, the model answer is a good example, but most important things would be: Get rid of the extra malloc calls, and do the split by moving nodes, instead of allocating new node and copying data (and, after above bugfix, freeing the old node). And then get rid of the global variables, instead add parameters to the functions, like in the model answer.

Answer 2

Just another quick split, no new allocations, and keeping the original list reduced to odd elements, while forming the new lists for even ones, along with comment on each critical step
void split_in_evenodd(node *orig)
{
if(!orig)
return;
node *e, *cur, *e_hd;
e = orig->next; // point first even member
e_hd = e; // keep a head pointer to even list
if(!e) // covers the case of list with single element
return;
orig->next = e->next; // make orig skip the even node
cur = orig->next; // cur moves to next odd node
while(cur && cur->next) {
e->next = cur->next; // even pointing to next even node
e = e->next; // move even list forward
cur->next = e->next; // update odds next
cur = e->next;// move current forward (to next odd)
}
}

Answer 3

While solving this problem, I came up with this approach where I have created separate head nodes for both the splits and then with the help of count variable, all odd count linked list nodes are sent to split linked list 1 and all even count linked list nodes are sent to split linked list 2.
Hope it helps! This code is in C language.
#include <stdio.h>
#include <stdlib.h>
struct node *add_at_end(struct node *ptr,int item);
struct node{
int data;
struct node *next;
};
void main(){
struct node *head=malloc(sizeof(struct node));
head->data=1;
head->next=NULL;
// first node gets created
struct node *ptr=head;
//now we will add other nodes at the end
ptr=add_at_end(ptr,2);
ptr=add_at_end(ptr,3);
ptr=add_at_end(ptr,4);
ptr=add_at_end(ptr,5);
//the nodes get added to the linked list.Now let's print the data of all these nodes
ptr=head;
while(ptr!=NULL){
printf("%d ",ptr->data);
ptr=ptr->next;
}
printf("\n");
int count;
struct node *splitNode=malloc(sizeof(struct node));
struct node *forward=malloc(sizeof(struct node));
forward=head;
//now we will create the 1st split linked list
struct node *headll1=malloc(sizeof(struct node));
splitNode=forward;
forward=forward->next;
headll1->data=splitNode->data;
headll1->next=NULL;
struct node *ptr1=headll1;
count=1;
//now we will create the 2nd split linked list
struct node *headll2=malloc(sizeof(struct node));
splitNode=forward;
forward=forward->next;
headll2->data=splitNode->data;
headll2->next=NULL;
struct node *ptr2=headll2;
count++;
//head nodes of both the split linked lists is ready
while(forward!=NULL){
splitNode=forward;
forward=forward->next;
count+=1;
if(count%2==1){
ptr1->next=splitNode;
splitNode->next=NULL;
ptr1=ptr1->next;
}else{
ptr2->next=splitNode;
splitNode->next=NULL;
ptr2=ptr2->next;
}
}
//we have finished adding the nodes to linked list 1 and 2 alternatively based on count.
//now let's print both the linked lists.
ptr1=headll1;
while(ptr1!=NULL){
printf("%d ",ptr1->data);
ptr1=ptr1->next;
}
printf("\n");
ptr2=headll2;
while(ptr2!=NULL){
printf("%d ",ptr2->data);
ptr2=ptr2->next;
}
}
struct node *add_at_end(struct node *ptr,int item){
struct node *temp=malloc(sizeof(struct node));
temp->data=item;
ptr->next=temp;
temp->next=NULL;
return temp;
}