Insert node at end of linked list in swift

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

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

// Swift 4 Program for
// Insert linked list element at end position

// Linked list node
class LinkNode
{
    var data: Int;
    var next: LinkNode? ;
    init(_ data: Int)
    {
        self.data = data;
        self.next = nil;
    }
}
class SingleLL
{
    var head: LinkNode? ;
    init()
    {
        self.head = nil;
    }
    // Add new node at the end of linked list
    func addNode(_ value: Int)
    {
        // Create new node
        let node: LinkNode = LinkNode(value);
        if (self.head == nil)
        {
            self.head = node;
        }
        else
        {
            var temp: LinkNode? = self.head;
            // Find the last node
            while (temp!.next  != nil)
            {
                // Visit to next node
                temp = temp!.next;
            }
            // Add node at last position
            temp!.next = node;
        }
    }
    // Display all Linked List elements
    func display()
    {
        if (self.head  != nil)
        {
            var temp: LinkNode? = self.head;
            while (temp  != nil)
            {
                // Display node value
                print(temp!.data, terminator: "  ");
                // Visit to next node
                temp = temp!.next;
            }
        }
        else
        {
            print("Empty Linked list");
        }
    }
}
func main()
{
    let 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 ");
    sll.display();
}
main();

 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.

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

// Linked list node
class LinkNode
{
    var data: Int;
    var next: LinkNode? ;
    init(_ data: Int)
    {
        self.data = data;
        self.next = nil;
    }
}
class SingleLL
{
    var head: LinkNode? ;
    var tail: LinkNode? ;
    init()
    {
        self.head = nil;
        self.tail = nil;
    }
    // Add new node at the end of linked list
    func addNode(_ value: Int)
    {
        // Create a new node
        let node: LinkNode = LinkNode(value);
        if (self.head == nil)
        {
            self.head = node;
        }
        else
        {
            self.tail!.next = node;
        }
        self.tail = node;
    }
    // Display linked list element
    func display()
    {
        if (self.head == nil)
        {
            return;
        }
        var temp: LinkNode? = self.head;
        // iterating linked list elements
        while (temp  != nil)
        {
            print(temp!.data , terminator: " → ");
            // Visit to next node
            temp = temp!.next;
        }
        print(" NULL");
    }
}
func main()
{
    let 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 ");
    sll.display();
}
main();

Linked List 
10 → 20 → 30 → 40 → 50 →  NULL

Time complexity of above program is O(1).