Move all zeros to the front of the linked list
Given a linked list. the task is to move all 0’s to the front of the linked list. The order of all other elements except 0 should be the same after rearrangement.
Examples:
Input : 0 1 0 1 2 0 5 0 4 0
Output :0 0 0 0 0 1 1 2 5 4
Input :1 1 2 3 0 0 0
Output :0 0 0 1 1 2 3
A simple solution is to store all linked list element in an array. Then move all elements of the array to the beginning. Finally, copy array elements back to the linked list.
An efficient solution is to traverse the linked list from second node. For every node with 0 value, we disconnect it from its current position and move the node to front.
Implementation:
C++
#include <bits/stdc++.h>
using namespace std;
struct Node {
int data;
struct Node* next;
};
void push( struct Node** head_ref, int new_data)
{
struct Node* new_node = new Node;
new_node->data = new_data;
new_node->next = (*head_ref);
(*head_ref) = new_node;
}
void moveZeroes( struct Node** head)
{
if (*head == NULL)
return ;
struct Node *temp = (*head)->next, *prev = *head;
while (temp != NULL) {
if (temp->data == 0) {
Node* curr = temp;
temp = temp->next;
prev->next = temp;
curr->next = (*head);
*head = curr;
}
else {
prev = temp;
temp = temp->next;
}
}
}
void display( struct Node* head)
{
while (head != NULL) {
cout << head->data << "->" ;
head = head->next;
}
cout << "NULL" ;
}
int main()
{
struct Node* head = NULL;
push(&head, 0);
push(&head, 3);
push(&head, 0);
push(&head, 2);
push(&head, 0);
push(&head, 1);
push(&head, 0);
push(&head, 1);
push(&head, 0);
push(&head, 0);
cout << "Linked list before rearrangement\n" ;
display(head);
moveZeroes(&head);
cout << "\n Linked list after rearrangement \n" ;
display(head);
return 0;
}
|
C
#include<stdio.h>
#include<stdlib.h>
typedef struct Node {
int data;
struct Node* next;
}Node;
void push( struct Node** head_ref, int new_data)
{
struct Node* new_node = (Node *) malloc ( sizeof (Node));
new_node->data = new_data;
new_node->next = (*head_ref);
(*head_ref) = new_node;
}
void moveZeroes( struct Node** head)
{
if (*head == NULL)
return ;
struct Node *temp = (*head)->next, *prev = *head;
while (temp != NULL) {
if (temp->data == 0) {
Node* curr = temp;
temp = temp->next;
prev->next = temp;
curr->next = (*head);
*head = curr;
}
else {
prev = temp;
temp = temp->next;
}
}
}
void display( struct Node* head)
{
while (head != NULL) {
printf ( "%d->" ,head->data);
head = head->next;
}
printf ( "NULL" );
}
int main()
{
struct Node* head = NULL;
push(&head, 0);
push(&head, 3);
push(&head, 0);
push(&head, 2);
push(&head, 0);
push(&head, 1);
push(&head, 0);
push(&head, 1);
push(&head, 0);
push(&head, 0);
printf ( "Linked list before rearrangement\n" );
display(head);
moveZeroes(&head);
printf ( "\nLinked list after rearrangement \n" );
display(head);
return 0;
}
|
Java
class GFG {
static class Node {
int data;
Node next;
};
static Node push(Node head_ref, int new_data)
{
Node new_node = new Node();
new_node.data = new_data;
new_node.next = head_ref;
head_ref = new_node;
return new_node;
}
static Node moveZeroes(Node head)
{
if (head == null )
return null ;
Node temp = (head).next, prev = head;
while (temp != null ) {
if (temp.data == 0 ) {
Node curr = temp;
temp = temp.next;
prev.next = temp;
curr.next = (head);
head = curr;
}
else {
prev = temp;
temp = temp.next;
}
}
return head;
}
static void display(Node head)
{
while (head != null ) {
System.out.print(head.data + "->" );
head = head.next;
}
System.out.print( "null" );
}
public static void main(String[] args)
{
Node head = null ;
head = push(head, 0 );
head = push(head, 3 );
head = push(head, 0 );
head = push(head, 2 );
head = push(head, 0 );
head = push(head, 1 );
head = push(head, 0 );
head = push(head, 1 );
head = push(head, 0 );
head = push(head, 0 );
System.out.print(
"Linked list before rearrangement\n" );
display(head);
head = moveZeroes(head);
System.out.print(
"\n Linked list after rearrangement \n" );
display(head);
}
}
|
Python3
class Node:
def __init__( self , data):
self .data = data
self . next = None
def push(head_ref, new_data):
new_node = Node(new_data)
new_node. next = (head_ref);
(head_ref) = new_node;
return head_ref
def moveZeroes(head):
if (head = = None ):
return ;
temp = head. next
prev = head;
while (temp ! = None ):
if (temp.data = = 0 ):
curr = temp;
temp = temp. next ;
prev. next = temp;
curr. next = (head);
head = curr;
else :
prev = temp;
temp = temp. next ;
return head
def display(head):
while (head ! = None ):
print (head.data, end = '->' )
head = head. next ;
print ( 'NULL' , end = '')
if __name__ = = '__main__' :
head = None ;
head = push(head, 0 );
head = push(head, 3 );
head = push(head, 0 );
head = push(head, 2 );
head = push(head, 0 );
head = push(head, 1 );
head = push(head, 0 );
head = push(head, 1 );
head = push(head, 0 );
head = push(head, 0 );
print ( "Linked list before rearrangement" );
display(head);
head = moveZeroes(head);
print ( "\n\nLinked list after rearrangement " );
display(head);
|
C#
using System;
class GFG
{
class Node
{
public int data;
public Node next;
};
static Node push(Node head_ref, int new_data)
{
Node new_node = new Node();
new_node.data = new_data;
new_node.next = head_ref;
head_ref = new_node;
return new_node;
}
static Node moveZeroes(Node head)
{
if (head == null )
return null ;
Node temp = (head).next, prev = head;
while (temp != null )
{
if (temp.data == 0)
{
Node curr = temp;
temp = temp.next;
prev.next = temp;
curr.next = (head);
head = curr;
}
else
{
prev = temp;
temp = temp.next;
}
}
return head;
}
static void display(Node head)
{
while (head != null )
{
Console.Write(head.data + "->" );
head = head.next;
}
Console.Write( "null" );
}
public static void Main(String[] args)
{
Node head = null ;
head = push(head, 0);
head = push(head, 3);
head = push(head, 0);
head = push(head, 2);
head = push(head, 0);
head = push(head, 1);
head = push(head, 0);
head = push(head, 1);
head = push(head, 0);
head = push(head, 0);
Console.Write( "Linked list before rearrangement\n" );
display(head);
head = moveZeroes(head);
Console.Write( "\n Linked list after rearrangement \n" );
display(head);
}
}
|
Javascript
<script>
class Node
{
constructor()
{
this .data = 0;
this .next = null ;
}
};
function push(head_ref, new_data)
{
var new_node = new Node();
new_node.data = new_data;
new_node.next = head_ref;
head_ref = new_node;
return new_node;
}
function moveZeroes(head)
{
if (head == null )
return null ;
var temp = (head).next, prev = head;
while (temp != null )
{
if (temp.data == 0)
{
var curr = temp;
temp = temp.next;
prev.next = temp;
curr.next = (head);
head = curr;
}
else
{
prev = temp;
temp = temp.next;
}
}
return head;
}
function display(head)
{
while (head != null )
{
document.write(head.data + "->" );
head = head.next;
}
document.write( "null" );
}
var head = null ;
head = push(head, 0);
head = push(head, 3);
head = push(head, 0);
head = push(head, 2);
head = push(head, 0);
head = push(head, 1);
head = push(head, 0);
head = push(head, 1);
head = push(head, 0);
head = push(head, 0);
document.write( "Linked list before rearrangement<br>" );
display(head);
head = moveZeroes(head);
document.write( "<br> Linked list after rearrangement <br>" );
display(head);
</script>
|
Output
Linked list before rearrangement
0->0->1->0->1->0->2->0->3->0->NULL
Linked list after rearrangement
0->0->0->0->0->0->1->1->2->3->NULL
Time Complexity: O(n), where n is the size of the given list.
Auxiliary Space: O(1) because it is using constant space
Last Updated :
01 Sep, 2022
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...