Question

Implement the Unsorted, sorted and indexed lists using Linked List base structure. (LLNode class under support package)

Files required:

1. ListInterface.java (given)
2. LLUnsortedList.java (implements ListInterface.java)
3. LLSortedList.java (extends LLUnsortedList.java, implements ListInterface.java)
4. LLIndexedList.java (implements LLIndexedListInterface.java, extends LLUnsortedList.java)

5. Driver

** Maybe create LLIndexedListInterface.java file too even though it is not required file!

I need the bolded Java Files (5) to be written separate  classes please! The interfaces can be implemented from below! Thank you

zip all your files and submit.

GIVEN FILES:

ListInterface.java

public interface ListInterface {

int size();

void add(T element);

boolean contains(T element); //Searching the item return true or false

//removes if exists, and return true

//false otherwise

boolean remove(T element);

//returns the element if exists,

//null otherwise

T get (T element);

//by putting toString method here,

//we require the implementation of it

String toString();

//current position is set to the first element

void reset();

T getNext();

}

----------------------------------------

LLNODE Class

public class LLNode{

//data members

private LLNode link;

private T info;

  

//constructors

public LLNode(T info){

this.info = info;

link = null;

}

//methods

public void setInfo(T info){

this.info = info;

}

public T getInfo(){

return info;

}

  public void setLink(LLNode link){

this.link = link;

}

public LLNode getLink(){

return link;

}

    public String toString() {

return info.toString();

}

}

If you can make a quick driver class that would be great too!

Answer 1

interface ListInterface<T> {

    int size();

    void add(T element);

    boolean contains(T element); // Searching the item return true or false
    
    // removes if exists, and return true
    // false otherwise
    boolean remove(T element);

    //returns the element if exists,
    //null otherwise
    T get(T element);

    //by putting toString method here,
    //we require the implementation of it
    String toString();

    //current position is set to the first element
    void reset();

    T getNext();
}

class LLNode<T> {

    // data members
    private LLNode<T> link;
    private T info;

    // constructors
    public LLNode(T info) {
        this.info = info;
        link = null;
    }

    // methods

    public void setInfo(T info) {
        this.info = info;
    }

    public T getInfo() {
        return info;
    }

    public void setLink(LLNode<T> link) {
        this.link = link;
    }

    public LLNode<T> getLink() {
        return link;
    }

    public String toString() {
        return info.toString();
    }
}

class LLUnsortedList<T> implements ListInterface<T> {
    // Do not add new instance variables or modify existing ones.
    private LLNode<T> head, current;
    private int size;

    @Override
    public void add(T data) {
        // error conditions
        if (data == null) {
            throw new IllegalArgumentException("Invalid data");
        }

        // create a node
        LLNode<T> node = new LLNode<T>(data);
        if(head == null) {
            head = node;
            current = head;
        } else {
            // find the node, after which this new node need to be inserted
            LLNode<T> prev = head;
            while (prev.getLink() != null) {
                prev = prev.getLink();
            }
            prev.setLink(node);
        }

        size++;
    }

    public T get(T element) {
        LLNode<T> x = head;
        while (x != null) {
            if(x.getInfo().equals(element)) {
                return x.getInfo();
            }
            x = x.getLink();
        }
        return null;
    }
    public boolean remove(T element) {
        if(head == null) {
            return false;
        }
        if(head.getInfo().equals(element)) {
            head = head.getLink();
            size--;
            return true;
        }
        
        LLNode<T> prev = head;
        while (prev.getLink() != null) {
            if(prev.getLink().getInfo().equals(element)) {
                prev.setLink(prev.getLink().getLink());
                size--;
                return true;
            }
            prev = prev.getLink();
        }
        return false;
    }

    @Override
    public int size() {
        return size;
    }
    
    public T getNext() {
        if(current == null) {
            return null;
        }
        T x = current.getInfo();
        current = current.getLink();
        return x;
    }
    @Override
    public String toString() {
        String output = "";
        
        LLNode<T> curr = head;
        while(curr != null) {
            output += curr.getInfo() + " ";
            curr = curr.getLink();
        }
        
        return output.trim();
    }

    @Override
    public boolean contains(T element) {
        return get(element) != null;
    }

    @Override
    public void reset() {
        current = head;
    }
}

**************************************************

Answering your first question, as the questions are completely unrelated and require different code. I request you to please post single question in a thread, so that it helps us in explaining the things better to you. Hope you understand!

Thanks for your question. We try our best to help you with detailed answers, But in any case, if you need any modification or have a query/issue with respect to above answer, Please ask that in the comment section. We will surely try to address your query ASAP and resolve the issue.

Please consider providing a thumbs up to this question if it helps you. by Doing that, You will help other students, who are facing similar issue.