Skip to content
Related Articles

Related Articles

Sort given Binary Doubly Linked List without modifying the data

View Discussion
Improve Article
Save Article
  • Last Updated : 30 May, 2022
View Discussion
Improve Article
Save Article

Given a head and a tail of a doubly linked list containing 0s and 1s, the task is to sort the Doubly linked list without modifying the data.

Examples:

Input:  head = 1->1->0->0->1->0->1->1->0->0->NULL
Output: 0->0->0->0->0->1->1->1->1->1->NULL

Input: head = 1->0->NULL
Output: 0->1->NULL

 

Approach: The idea to solve this problem is to use two pointers algorithm as mentioned below:

  • Create two pointers – head and tail such that head points at first element and tail points at last element
  • Keep checking the element at the pointers for 1 at head and 0 at tail,
  • Swap the elements whenever 1, 0 combination is found.

Follow the steps to solve the problem:

  • Initialize first pointer = head, last pointer = tail
  • While  first != last and first -> prev  !=  last
    • Check, if first->data == 0
    • update, first = first->next
  • If, last->data == 1
    • update, last = last->prev
  • If, first->data == 1 and last->data == 0
    • then, swap first and last node
    • again swap first and last pointer
    • move first towards right and last towards left by 1

Below is the implementation of the above approach:

C++




// C++ program for the above approach:
#include <iostream>
using namespace std;
 
// Link list Node Class
class Node {
public:
    int data;
    Node* prev;
    Node* next;
 
    // Constructor function
    Node(int data)
    {
        this->data = data;
        this->prev = NULL;
        this->next = NULL;
    }
};
 
// Function to print linked list
void print(Node* head)
{
    Node* temp = head;
 
    // Iterate until node is NOT NULL
    while (temp != NULL) {
        cout << temp->data << " ";
        temp = temp->next;
    }
    cout << endl;
}
 
// Function to push a node in
// Doubly linked- list
void push(Node*& head, Node*& tail, int item)
{
 
    // If list is empty
    if (tail == NULL) {
 
        Node* temp = new Node(item);
        tail = temp;
        head = temp;
    }
 
    // List is not empty
 
    else {
        Node* temp = new Node(item);
        tail->next = temp;
        temp->prev = tail;
        tail = temp;
    }
}
 
// Function to swap the list
// Consisting of 0s and 1s
void swap(Node*& Node1, Node*& Node2)
{
 
    Node* temp;
    temp = Node1->next;
    Node1->next = Node2->next;
    Node2->next = temp;
 
    if (Node1->next != NULL)
        Node1->next->prev = Node1;
    if (Node2->next != NULL)
        Node2->next->prev = Node2;
 
    temp = Node1->prev;
    Node1->prev = Node2->prev;
    Node2->prev = temp;
 
    if (Node1->prev != NULL)
        Node1->prev->next = Node1;
    if (Node2->prev != NULL)
        Node2->prev->next = Node2;
}
 
// Function to sort the list
// Consisting of 0s and 1s
void sort(Node*& head, Node*& tail)
{
 
    // Base Case
    if (head == tail || head == NULL)
        return;
 
    // Initialize the pointers
    Node* first = head;
    Node* last = tail;
 
    while ((first != last)
           && (first->prev != last)) {
 
        // If first->data is 0 then move
        // First towards right by 1
        if (first->data == 0)
            first = first->next;
 
        // If last->data is 1 then move
        // Last towards left by 1
        if (last->data == 1)
            last = last->prev;
 
        // If first->data is 1 and last->data is 0
        // then swap first and last node
        if (first->data == 1 && last->data == 0
            && first->prev != last) {
 
            // Swapping the node
            swap(first, last);
 
            // if head = 1
            if (head == first)
                head = last;
 
            // if tail == 0
            if (tail == last)
                tail = first;
 
            // Swapping the pointer and
            // moved to next iteration
            Node* Temp = first;
            first = last->next;
            last = Temp->prev;
        }
    }
}
 
// Driver Code
int main()
{
 
    Node* head = NULL;
    Node* tail = NULL;
 
    push(head, tail, 1);
    push(head, tail, 1);
    push(head, tail, 0);
    push(head, tail, 0);
    push(head, tail, 1);
    push(head, tail, 0);
    push(head, tail, 1);
    push(head, tail, 1);
    push(head, tail, 0);
    push(head, tail, 0);
 
    sort(head, tail);
 
    print(head);
 
    return 0;
}


Java




// Java program for the above approach:
 
import java.util.*;
 
class GFG{
    static Node head;
    static Node tail;
// Link list Node Class
static class Node {
 
    int data;
    Node prev;
    Node next;
 
    // Constructor function
    Node(int data)
    {
        this.data = data;
        this.prev = null;
        this.next = null;
    }
};
 
// Function to print linked list
static void print(Node head)
{
    Node temp = head;
 
    // Iterate until node is NOT null
    while (temp != null) {
        System.out.print(temp.data+ " ");
        temp = temp.next;
    }
    System.out.println();
}
 
// Function to push a node in
// Doubly linked- list
static void push(int item)
{
 
    // If list is empty
    if (tail == null) {
 
        Node temp = new Node(item);
        tail = temp;
        head = temp;
    }
 
    // List is not empty
 
    else {
        Node temp = new Node(item);
        tail.next = temp;
        temp.prev = tail;
        tail = temp;
    }
}
 
// Function to swap the list
// Consisting of 0s and 1s
static void swap(Node Node1, Node Node2)
{
 
    Node temp;
    temp = Node1.next;
    Node1.next = Node2.next;
    Node2.next = temp;
 
    if (Node1.next != null)
        Node1.next.prev = Node1;
    if (Node2.next != null)
        Node2.next.prev = Node2;
 
    temp = Node1.prev;
    Node1.prev = Node2.prev;
    Node2.prev = temp;
 
    if (Node1.prev != null)
        Node1.prev.next = Node1;
    if (Node2.prev != null)
        Node2.prev.next = Node2;
}
 
// Function to sort the list
// Consisting of 0s and 1s
static void sort()
{
 
    // Base Case
    if (head == tail || head == null)
        return;
 
    // Initialize the pointers
    Node first = head;
    Node last = tail;
 
    while ((first != last)
           && (first.prev != last)) {
 
        // If first.data is 0 then move
        // First towards right by 1
        if (first.data == 0)
            first = first.next;
 
        // If last.data is 1 then move
        // Last towards left by 1
        if (last.data == 1)
            last = last.prev;
 
        // If first.data is 1 and last.data is 0
        // then swap first and last node
        if (first.data == 1 && last.data == 0
            && first.prev != last) {
 
            // Swapping the node
            swap(first, last);
 
            // if head = 1
            if (head == first)
                head = last;
 
            // if tail == 0
            if (tail == last)
                tail = first;
 
            // Swapping the pointer and
            // moved to next iteration
            Node Temp = first;
            first = last.next;
            last = Temp.prev;
        }
    }
}
 
// Driver Code
public static void main(String[] args)
{
 
 
    push(1);
    push(1);
    push(0);
    push(0);
    push(1);
    push(0);
    push(1);
    push(1);
    push(0);
    push(0);
 
    sort();
 
    print(head);
 
}
}
 
// This code is contributed by 29AjayKumar


Python3




# Python code for the above approach
 
# Node Class
class Node:
    def __init__(self, d):
        self.data = d
        self.next = None
        self.prev = None
             
 
class LinkedList:
    def __init__(self):
        self.head = None
        self.tail = None
 
    ## Function to push a node in
    ## Doubly linked list
    def push(self, d):
 
        ## If list is empty
        if (self.tail == None):
            temp = Node(d);
            self.head = temp;
            self.tail = temp;
        else:
            ## Non-empty list
            temp = Node(d);
            self.tail.next = temp
            temp.prev = self.tail
            self.tail = temp
 
    ## Function to print Doubly linked list
    def printList(self):
        curr = self.head
 
        if(self.head == None):
            print("List is Empty")
            return
 
        ## Else iterate until node is NOT None
        print(curr.data, " ", end='')
        curr = curr.next
        while curr != None:
            print(curr.data, " ", end='')
            curr = curr.next
        print("\n")
 
    ## Function to swap the list
    ## Consisting of 0s and 1s
    def swap(self, Node1, Node2):
        temp = None
        temp = Node1.next
        Node1.next = Node2.next
        Node2.next = temp
 
        if (Node1.next != None):
            Node1.next.prev = Node1
        if (Node2.next != None):
            Node2.next.prev = Node2
 
        temp = Node1.prev
        Node1.prev = Node2.prev
        Node2.prev = temp
 
        if (Node1.prev != None):
            Node1.prev.next = Node1
        if (Node2.prev != None):
            Node2.prev.next = Node2
 
    ## Function to sort the list
    ## Consisting of 0s and 1s
    def sort(self):
 
        ## Base Case
        if (self.head == self.tail or self.head == None):
            return;
 
        ## Initialize the pointers
        first = self.head
        last = self.tail
 
        while ((first != last) and (first.prev != last)):
            ## If first.data is 0 then move
            ## First towards right by 1
            if (first.data == 0):
                first = first.next
 
            ## If last.data is 1 then move
            ## Last towards left by 1
            if (last.data == 1):
                last = last.prev
 
            ## If first.data is 1 and last.data is 0
            ## then swap first and last node
            if (first.data == 1 and last.data == 0 and first.prev != last):
 
                ## Swapping the node
                self.swap(first, last);
 
                ## if head = 1
                if (self.head == first):
                    self.head = last;
                         
                ## if tail == 0
                if (self.tail == last):
                    self.tail = first
 
                ## Swapping the pointer and
                ## moved to next iteration
                Temp = first
                first = last.next;
                last = Temp.prev;
 
# Driver Code
if __name__=='__main__':
 
    llist = LinkedList()
 
    llist.push(1)
    llist.push(1)
    llist.push(0)
    llist.push(0)
    llist.push(1)
    llist.push(0)
    llist.push(1)
    llist.push(1)
    llist.push(0)
    llist.push(0)
 
    llist.sort()
 
    llist.printList()
     
    # This code is contributed by subhamgoyal2014.


C#




// C# program for the above approach:
using System;
using System.Collections.Generic;
 
public class GFG{
    static Node head;
    static Node tail;
   
// Link list Node Class
public class Node {
 
    public int data;
    public Node prev;
    public Node next;
 
    // Constructor function
   public  Node(int data)
    {
        this.data = data;
        this.prev = null;
        this.next = null;
    }
};
 
// Function to print linked list
static void print(Node head)
{
    Node temp = head;
 
    // Iterate until node is NOT null
    while (temp != null) {
        Console.Write(temp.data+ " ");
        temp = temp.next;
    }
    Console.WriteLine();
}
 
// Function to push a node in
// Doubly linked- list
static void push(int item)
{
 
    // If list is empty
    if (tail == null) {
 
        Node temp = new Node(item);
        tail = temp;
        head = temp;
    }
 
    // List is not empty
 
    else {
        Node temp = new Node(item);
        tail.next = temp;
        temp.prev = tail;
        tail = temp;
    }
}
 
// Function to swap the list
// Consisting of 0s and 1s
static void swap(Node Node1, Node Node2)
{
 
    Node temp;
    temp = Node1.next;
    Node1.next = Node2.next;
    Node2.next = temp;
 
    if (Node1.next != null)
        Node1.next.prev = Node1;
    if (Node2.next != null)
        Node2.next.prev = Node2;
 
    temp = Node1.prev;
    Node1.prev = Node2.prev;
    Node2.prev = temp;
 
    if (Node1.prev != null)
        Node1.prev.next = Node1;
    if (Node2.prev != null)
        Node2.prev.next = Node2;
}
 
// Function to sort the list
// Consisting of 0s and 1s
static void sort()
{
 
    // Base Case
    if (head == tail || head == null)
        return;
 
    // Initialize the pointers
    Node first = head;
    Node last = tail;
 
    while ((first != last)
           && (first.prev != last)) {
 
        // If first.data is 0 then move
        // First towards right by 1
        if (first.data == 0)
            first = first.next;
 
        // If last.data is 1 then move
        // Last towards left by 1
        if (last.data == 1)
            last = last.prev;
 
        // If first.data is 1 and last.data is 0
        // then swap first and last node
        if (first.data == 1 && last.data == 0
            && first.prev != last) {
 
            // Swapping the node
            swap(first, last);
 
            // if head = 1
            if (head == first)
                head = last;
 
            // if tail == 0
            if (tail == last)
                tail = first;
 
            // Swapping the pointer and
            // moved to next iteration
            Node Temp = first;
            first = last.next;
            last = Temp.prev;
        }
    }
}
 
// Driver Code
public static void Main(String[] args)
{
 
 
    push(1);
    push(1);
    push(0);
    push(0);
    push(1);
    push(0);
    push(1);
    push(1);
    push(0);
    push(0);
 
    sort();
 
    print(head);
 
}
}
 
// This code is contributed by shikhasingrajput


Output

0 0 0 0 0 1 1 1 1 1 

Time Complexity: O(N)
Auxiliary Space: O(1)


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!