Question

1. Create a class MLL, a singly linked, non-circular list where each node only has one link next and the list has a head and a tail link (think about implementation of node). The MLL class also implements the Iterable interface. The following should be implemented as well:

2. Add the methods to the MLL class:

a. iterator() to implement the Iterable interface. This method returns an instance of MLLI initialized appropriately.

b. addFirst( value) that adds a value to the front of the list

c. addEnd( value) that adds a value to the end of the list - don't forget the boundary cases

d. A get method which given an index returns the element.

3. Create a class MLLI that implements the Iterator interface.

4. Create a class called MLIC which uses your new data structure. It only needs to implement the following methods:

a. addToBack

b. addToFront

c. Search for a value (this should search for an Integer in the list and return the first index of the value if it is present, if not return -1. The array is not sorted). Two versions of this method are needed. One which uses an iterator and one which does not.

The programming language is java.

Answer 1

import java.util.Iterator;

//  A simple class which acts as Node of our linked list
class Node{
    int data;
    Node next;

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


class MLL implements Iterable<Node>{
    /* head and tail taken static so that each object
    doesn't  have their different copies 
     */
    static Node head = null;
    static Node tail = null;

    void addFirst(int value){
        Node node = new Node(value);
        if(head == null){
           head = node;
           tail = node;
        }else{
            // Push the previous element back
            node.next = head;
            head = node;
        }
    }

    void addLast(int value){
        Node node = new Node(value);
        if(head == null){
            head = node;
            tail = node;
        }else{
            // Set the new element as last element
            tail.next = node;
            tail = node;
        }
    }

    int get(int index){
        Node pointer = head;
        if(index <= 0){
            return -1;
        }
        // Assuming index starts from 1
        int count = 1;
        // Check for index, as well as for the end of the list 
        while(count != index && pointer != null){
            pointer = pointer.next;
        }
        // Check if element really exists
        if(pointer != null){
            return pointer.data;
        }
        return -1;
    }

    // Returns the iterator
    @Override
    public Iterator<Node> iterator() {
        return new MLLI();
    }
}

class MLLI implements Iterator<Node>{

    Node start = MLL.head;

    @Override
    public boolean hasNext() {
        return start.next != null;
    }

    @Override
    public Node next() {
        Node obj = start;
        start = start.next;
        return obj;
    }

    @Override
    public void remove() {
        throw new UnsupportedOperationException();
    }
}

class MLIC{
    static MLL object = new MLL();

     void addToFront(int value){
         object.addFirst(value);
     }

     void addToBack(int value){
         object.addLast(value);
     }

     int search(int value){
         Node pointer = MLL.head;
         int count = 1;
         while(pointer != null && pointer.data != value){
             pointer = pointer.next;
             count++;
         }
         if(pointer != null){
             return count;
         }
         return -1;
     }

     int searchWithIterator(int value){
         MLLI iterator = (MLLI) object.iterator();
         int count = 1;
         boolean flag = false;
         while (iterator.hasNext()){
             Node object = iterator.next();
             // Set flag to determine whether element was in linked list or not.
             if(object.data == value) {
                 flag = true;
                 break;
             }
             count++;
         }
         if(flag)
             return count;
         return -1;
     }
}

public class Test {
    public static void main(String[] args) {
        MLIC object = new MLIC();

        object.addToBack(5);
        object.addToBack(1);

        object.addToFront(34);
        object.addToFront(21);
        object.addToFront(10);

        System.out.println("Index " + object.search(35));
        System.out.println("Index " + object.searchWithIterator(5));
        System.out.println("Index " + object.search(34));
        System.out.println("Index " + object.searchWithIterator(34));
    }
}