Question

Java help: Please help complete the locate method that is in bold..

public class LinkedDoubleEndedList implements DoubleEndedList {

private Node front; // first node in list
private Node rear; // last node in list
private int size; // number of elements in list

//////////////////////////////////////////////////
// YOU MUST IMPLEMENT THE LOCATE METHOD BELOW //
//////////////////////////////////////////////////

/**
* Returns the position of the node containing the given value, where
* the front node is at position zero and the rear node is at position N
* in a list of size N. If value is not present, this method returns -1.
*/
public int locate(T value) {
   return 99;
}

/**
* Returns true if this list contains the given value, false otherwise.
*/
public boolean contains(T value) {
   return locate(value) >= 0;
}

/**
* Construct an empty list.
*/
public LinkedDoubleEndedList() {
front = null;
rear = null;
size = 0;
}

/**
* Adds element to the front of the list. If element is null,
* this method throws an IllegalArgumentException.
*/
public void addFirst(T element) {
if (element == null) {
throw new IllegalArgumentException("Null values not allowed in list.");
}
  
Node n = new Node(element, null, front);
if (isEmpty()) {
rear = n;
} else {
front.prev = n;
}
front = n;
size++;
}
  
/**
* Adds element to the end of the list. If element is null,
* this method throws an IllegalArgumentException.
*/
public void addLast(T element) {
if (element == null) {
throw new IllegalArgumentException("Null values not allowed in list.");
}
  
Node n = new Node(element, rear, null);
if (isEmpty()) {
front = n;
} else {
rear.next = n;
}
rear = n;
size++;
}
  
/**
* Delete and return the element at the front of the list.
* If the list is empty, this method returns null.
*/
public T removeFirst() {
if (isEmpty()) {
return null;
}
  
T element = front.element;
if (size() == 1) {
rear = null;
front = null;
} else {
Node n = front;
front = front.next;
front.prev = null;
n.next = null;
n = null;
}
  
size--;
return element;
}
  
/**
* Delete and return the element at the end of the list.
* If the list is empty, this method returns null.
*/
public T removeLast() {
if (isEmpty()) {
return null;
}
  
T element = rear.element;
if (size() == 1) {
front = null;
rear = null;
} else {
Node n = rear;
rear = rear.prev;
rear.next = null;
n.prev = null;
n = null;
}
  
size--;
return element;
}

/**
* Returns the number of elements in this list.
*/
public int size() {
return size;
}

/**
* Returns true if this list is empty, false otherwise.
*/
public boolean isEmpty() {
return size() == 0;
}
  
/**
* Creates and returns an iterator over the elements of this list.
* The order of the elements returned by this iterator is sequential
* from the front of the list to the end of the list.
*/
public Iterator iterator() {
return new SelfIterator();
}
  
  
/**
* Linked node class.
*/
private class Node {
  
private T element;
private Node prev;
private Node next;
  
public Node(T e, Node p, Node n) {
element = e;
prev = p;
next = n;
}
  
}

/**
* Provides iterator over linked nodes.
*
*/
private class SelfIterator implements Iterator {
  
private Node current;
  
public SelfIterator() {
current = front;
}
  
public boolean hasNext() {
return current != null;
}
  
public T next() {
if (!hasNext()) {
throw new NoSuchElementException();
}
T e = current.element;
current = current.next;
return e;
}
  
public void remove() {
throw new UnsupportedOperationException();
}
}   
}

***********************These are the additional files*******************************

public class Client {

   /** Drives execution. */
   public static void main(String[] args) {
       LinkedDoubleEndedList list = new LinkedDoubleEndedList<>();
       list.addLast("A");
       list.addLast("B");
       list.addLast("C");
       list.addLast("D");
       list.addLast("E");
       for (String value : list) {
           System.out.println(value + ": " + list.locate(value));
       }
       System.out.println("F: " + list.locate("F"));
   }
}

/*

RUNTIME OUTPUT:

A: 0
B: 1
C: 2
D: 3
E: 4
F: -1
********************************************************

public interface DoubleEndedList extends List {
  
/**
* Adds element to the front of the list. If element is null,
* this method throws an IllegalArgumentException.
*/
void addFirst(T element);
  
/**
* Adds element to the end of the list. If element is null,
* this method throws an IllegalArgumentException.
*/
void addLast(T element);
  
/**
* Delete and return the element at the front of the list.
* If the list is empty, this method returns null.
*/
T removeFirst();
  
/**
* Delete and return the element at the end of the list.
* If the list is empty, this method returns null.
*/
T removeLast();
  
}

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

public interface List extends Iterable {

/**
* Returns the number of elements in this list.
*/
int size();

/**
* Returns true if this list contains no elements, false otherwise.
*/
boolean isEmpty();
  
/**
* Creates and returns an iterator over the elements of this list.
*/
Iterator iterator();

}

Answer 1

The "locate () "method is implemented as follows: //Given method public int locate (T value) //Kindly paste the below code inside locate) method // pointer to represent front node = front; Node F / declare the required variable int i = 0; /check whether the front node is not null while (F != null) { /check whether the front node is at position 0 //and rear node at value if (F.element.equals (value)) //retrun the results return i; /increment to the next node it+ //assign the next node F =F.next;

} /if the value is not present then return -1 return -1; } Explanation Initially a pointer is assigned for the front node Using "while" 1oop, check whether the front node is not null Now using "if loop, check the value in the front node The front node is at position 0 and rear at N. Move to the next node and check Retun -1 if the value is not present

code:

//Given method

public int locate(T value)

{

     //Kindly paste the below code inside locate() method

      // pointer to represent front node

      Node F = front;

      // declare the required variable

      int i = 0;

      // check whether the front node is not null

      while (F != null) {

// check whether the front node is at position 0 //and rear node at value

            if (F.element.equals(value))

          {

                  //retrun the results

                  return i;

            }

            //increment to the next node

            i++;

            //assign the next node

            F = F.next;

      }

     //if the value is not present then return -1

      return -1;

}