Insert node at end of linked list in kotlin

Write a program which is create and add linked list node at the end (tail, last) position in kotlin.

Suppose we are inserted the following (10, 20, 30 ,40 ,50) node in a sequence.

insert node at end of linked list
// Kotlin Program for
// Insert linked list element at end position

// 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 addNode(value: Int): Unit
    {
        // Create new node
        val 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
        {
            print("Empty Linked list\n");
        }
    }
}
fun main(args: Array < String > ): Unit
{
    val sll: SingleLL = SingleLL();
    // Linked list
    // 1 → 2 → 3 → 4 → 5 → 6 → 7 → 8 → NULL
    sll.addNode(1);
    sll.addNode(2);
    sll.addNode(3);
    sll.addNode(4);
    sll.addNode(5);
    sll.addNode(6);
    sll.addNode(7);
    sll.addNode(8);
    print("Linked List \n");
    sll.display();
}
 Linked List
  1  2  3  4  5  6  7  8

Time complexity of above program is O(n). We can optimize above algorithm using one extra pointer. Which is hold the reference of last node. Below are implementation of this logic.

// Kotlin Program for
// Insert linked list element at end position set B

// 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 ? ;
    var tail: LinkNode ? ;
    constructor()
    {
        this.head = null;
        this.tail = null;
    }
    // Add new node at the end of linked list
    fun addNode(value: Int): Unit
    {
        // Create a new node
        val node: LinkNode = LinkNode(value);
        if (this.head == null)
        {
            this.head = node;
        }
        else
        {
            this.tail?.next = node;
        }
        this.tail = node;
    }
    // Display linked list element
    fun display(): Unit
    {
        if (this.head == null)
        {
            return;
        }
        var temp: LinkNode ? = this.head;
        // iterating linked list elements
        while (temp != null)
        {
            print(" " + temp.data + " →");
            // Visit to next node
            temp = temp.next;
        }
        print(" NULL\n");
    }
}
fun main(args: Array < String > ): Unit
{
    val sll: SingleLL = SingleLL();
    // Linked list
    // 10 → 20 → 30 → 40 → 50 → NULL
    sll.addNode(10);
    sll.addNode(20);
    sll.addNode(30);
    sll.addNode(40);
    sll.addNode(50);
    print(" Linked List \n");
    sll.display();
}
Linked List 
10 → 20 → 30 → 40 → 50 →  NULL

Time complexity of above program is O(1).




Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.

New Comment







© 2022, kalkicode.com, All rights reserved