# Sort given Binary Doubly Linked List without modifying the data

• Last Updated : 30 May, 2022

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 ` `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 :