Sort a linked list of 0s, 1s, and 2s by changing links

#include <bits/stdc++.h>
using namespace std;

/* node definition */
struct Node {
    int val;
    struct Node* next;
};

Node* newNode(int val);

// Sorting 0s, 1s and 2s in a linked list
Node* sortingLL(Node* head)
{
    if (!head || !(head->next))
        return head;

// Creating three dummy nodes inorder to point
// to the starting of the 3 lists. 
// Their motive is to help in avoiding null checks.
    Node* temp0 = newNode(0);
    Node* temp1 = newNode(0);
    Node* temp2 = newNode(0);

    // Initialize current pointers
    Node* ptr0 = temp0, *ptr1 = temp1, *ptr2 = temp2;

    // Traversing through the list
    Node* current = head;
    while (current) {
        if (current->val == 0) {
            ptr0->next = current;
            ptr0 = ptr0->next;
            current = current->next;
        } else if (current->val == 1) {
            ptr1->next = current;
            ptr1 = ptr1->next;
            current = current->next;
        } else {
            ptr2->next = current;
            ptr2 = ptr2->next;
            current = current->next;
        }
    }

    // connect the 2 linked lists.
    ptr0->next = (temp1->next)
    ? (temp1->next) : (temp2->next);
    ptr1->next = temp2->next;
    ptr2->next = NULL;

    // Updating the head
    head = temp0->next;

    // Deletion of dummy nodes
    delete temp0;
    delete temp1;
    delete temp2;

    return head;
}

// Creating and returning a node.
Node* newNode(int val)
{
    Node* newNode = new Node;
    newNode->val = val;
    newNode->next = NULL;
}

// Function to display the Linked List
void displayList(struct Node* node)
{
    while (node != NULL) {
        cout<<node->val<<” “;
        node = node->next;
    }
    cout<<endl;
}

// Driver function
int main()
{
    // Creation of list
    Node* head = newNode(1);
    head->next = newNode(2);
    head->next->next = newNode(0);
    head->next->next->next = newNode(1);
     head->next->next->next->next = newNode(0);

    cout<<"Original Linked List:”<<endl;
    displayList(head);

    head = sortingLL(head);

    cout<<"Sorted Linked List:”<<endl;
    displayList(head);

    return 0;
}

class Node
{
	int data;
	Node next;
	Node(int data)
	{
		this.data=data;
	}
}


class SortIt 
{
	public static Node sortList(Node head)
	{
		if(head==null || head.next==null)
		{
			return head;
		}
		Node zeroD = new Node(0);
		Node oneD = new Node(0);
		Node twoD = new Node(0);

		Node zero = zeroD, one = oneD, two = twoD;
		Node curr = head;
		while (curr!=null)
		{
			if (curr.data == 0)
			{
				zero.next = curr;
				zero = zero.next;
				curr = curr.next;
			}
			else if (curr.data == 1)
			{
				one.next = curr;
				one = one.next;
				curr = curr.next;
			}
			else
			{
				two.next = curr;
				two = two.next;
				curr = curr.next;
			}
		}
		zero.next = (oneD.next!=null)? (oneD.next) : (twoD.next);
		one.next = twoD.next;
		two.next = null;
		head = zeroD.next;
		return head;
	}
	// function to create and return a node
	public static Node newNode(int data)
	{
		// allocating space
		Node newNode = new Node(data);
		newNode.next = null;
		return newNode;
	}
	/* Function to print linked list */
	public static void printList(Node node)
	{
		while (node != null)
		{
			System.out.print(node.data+" ");
			node = node.next;
		}
	}
	public static void main(String args[]) 
    {
		Node head = new Node(1);
		head.next = new Node(2);
		head.next.next = new Node(0);
		head.next.next.next = new Node(1);
		System.out.println("Linked List Before Sorting");
		printList(head);
		head = sortList(head);
		System.out.println("Linked List After Sorting");
		printList(head);
	}
}

# Link list node
class Node:
	def __init__(self, data):
		self.data = data
		self.next = None

# Sort a linked list of 0s, 1s and 2s
# by changing poers.
def sortList(head):
	if (head == None or
		head.next == None):
		return head

	# Create three dummy nodes to point to
	# beginning of three linked lists.
	# These dummy nodes are created to
	# avoid many None checks.
	zeroD = Node(0)
	oneD = Node(0)
	twoD = Node(0)

	# Initialize current pointers for three
	# lists and whole list.
	zero = zeroD
	one = oneD
	two = twoD

	# Traverse list
	curr = head
	while (curr):
		if (curr.data == 0):
			zero.next = curr
			zero = zero.next
			curr = curr.next
		elif(curr.data == 1):
			one.next = curr
			one = one.next
			curr = curr.next
		else:
			two.next = curr
			two = two.next
			curr = curr.next
		
	# Attach three lists
	zero.next = (oneD.next) if (oneD.next ) \
							else (twoD.next)
	one.next = twoD.next
	two.next = None

	# Updated head
	head = zeroD.next

	# Delete dummy nodes
	return head

# function to create and return a node
def newNode(data):
	
	newNode = Node(data)
	newNode.data = data
	newNode.next = None
	return newNode

# Function to print linked list
def printList(node):
	while (node != None):
		print(node.data, end = " ")
		node = node.next
	
if __name__=='__main__':
	
	# Creating the list 1.2.4.5
	head = newNode(1)
	head.next = newNode(2)
	head.next.next = newNode(0)
	head.next.next.next = newNode(1)
	head.next.next.next.next = newNode(0)

	print("Linked List Before Sorting")
	printList(head)

	head = sortList(head)

	print("\nLinked List After Sorting")
	printList(head)