Segregate even and odd nodes in sorted order in kotlin

Kotlin program for Segregate even and odd nodes in sorted order. Here more information.

// Kotlin program for
// Segregate even and odd nodes in ascending order

// Linked list node
class LinkNode
{
	var data: Int;
	var next: LinkNode ? ;
	constructor(data: Int)
	{
		this.data = data;
		this.next = null;
	}
}
class SingleLL
{
	var head: LinkNode ? ;
	constructor()
	{
		this.head = null;
	}
	// Add new node at the end of linked list
	fun insert(value: Int): Unit
	{
		// Create a node
		var node: LinkNode ? = LinkNode(value);
		if (this.head == null)
		{
			this.head = node;
		}
		else
		{
			var temp: LinkNode ? = this.head;
			// Find last node
			while (temp?.next != null)
			{
				// Visit to next node
				temp = temp.next;
			}
			// Add node at last position
			temp?.next = node;
		}
	}
	// Display all Linked List elements
	fun display(): Unit
	{
		if (this.head != null)
		{
			var temp: LinkNode ? = this.head;
			while (temp != null)
			{
				// Display node value
				print("  " + temp.data);
				// Visit to next node
				temp = temp.next;
			}
		}
		else
		{
			println("Empty Linked list");
		}
	}
	fun sortedAdd(element: LinkNode): Unit
	{
		if (this.head == null)
		{
			this.head = element;
		}
		else if (this.head!!.data >= element.data)
		{
			element.next = this.head;
			this.head = element;
		}
		else
		{
			var temp: LinkNode ? = this.head;
			// Finding location of inserting node
			while (temp?.next != null && 
              temp.next!!.data < element.data)
			{
				// Visit to next node
				temp = temp.next;
			}
			// Add node 
			element.next = temp?.next;
			temp?.next = element;
		}
	}
	fun segregateNode(odd: SingleLL , 
                      even : SingleLL): Unit
	{
		var node: LinkNode ? ;
		// Iterating the linked list node
		while (this.head != null)
		{
			node = this.head;
			// Visit to next node
			this.head = node?.next;
			// Set null to next node
			node?.next = null;
			if (node!!.data % 2 == 0)
			{
				// When node value is Even
				even.sortedAdd(node);
			}
			else
			{
				// When node value is Odd
				odd.sortedAdd(node);
			}
		}
	}
}
fun main(args: Array < String > ): Unit
{
	// Create linked lists
	val sll: SingleLL = SingleLL();
	val odd: SingleLL = SingleLL();
	val even: SingleLL = SingleLL();
	// Linked list sll
	// 4 → 3 → 5 → 2 → 11 → 1 → 6 → NULL
	sll.insert(4);
	sll.insert(3);
	sll.insert(5);
	sll.insert(2);
	sll.insert(11);
	sll.insert(1);
	sll.insert(6);
	println("Initial Element");
	// Display all node
	sll.display();
	sll.segregateNode(odd, even);
	println("\nEven Element");
	// Display all even node
	even.display();
	println("\nOdd Element");
	// Display all odd node
	odd.display();
}

Output

Initial Element
  4  3  5  2  11  1  6
Even Element
  2  4  6
Odd Element
  1  3  5  11