Solve in java

Write method CODE only, i will give you implementation

Write a method called CompareAndChangeList to be included in an application class called ListApplication that accepts two parameters list1 and list2 of type SingleLinkedList of integer values, and a third parameter Item of type int. If list1 and list2 are of different sizes, the method returns false, otherwise, the method replaces any element in list2 with a value equal to the last element in list1, if the summation of the element in list 1 and the corresponding element in list2 is equal to item. Assume list1 and list2 are not empty. If at least one replacement happened, the method returns true, otherwise, it returns false.

Note: Write this method by calling methods of the class SingleLinkedList.

Method head:

public static boolean CompareAndChangeList (SingleLinkedList list1, SingleLinkedList list2, int item)

Example:

Before Method call: item = 35

list1: 23 26 30 20 17

list2: 10 9 25 15 4

After Method call:

list1: 23 26 30 20 17

list2: 10 17 25 17 4

In this case, the method will return true

Note: as you can see the summation of 26 (in list 1) and its corresponding element (in list2) 9, is 35, which is equal to item, so we replace the element in list 2 (9) by the value of the last node in list1 which is 17. The same thing is between the elements 20 (in list 1) and 15 (in list 2). 15 is going to be replaced by 17 .The rest will not change.

implementation

class SingleLinkedList { private Node head; private int size;

/** private inner class */ private static class Node { private E data; private Node next; /** Creates a new node with a null next field @param dataItem The data stored */ private Node(E dataItem) { data = dataItem; next = null; } /** Creates a new node that references another node @param dataItem The data stored @param nodeRef The node referenced by new node */ private Node(E dataItem, Node nodeRef) { data = dataItem; next = nodeRef; } } //end class Node

// constructor SingleLinkedList public SingleLinkedList( ) { // initially empty list head = null; size = 0; }

/** Private methods */ // Method to insert a new node at front of the list private void addFirst (E item) { Node temp = new Node(item, head); // create a new node head = temp; // link to the first node size++; }

// Method to insert a new node after the node referenced // by node private void addAfter (Node node, E item) { Node temp = new Node(item, node.next); node.next = temp; size++; }

// Method to delete the node after the node referenced //by node private E removeAfter (Node node) { Node temp = node.next; if (temp != null) { node.next = temp.next; size--; return temp.data; } else return null; }

// Method to delete the first node private E removeFirst () { Node temp = head; if (head != null) { head = head.next; size--; return temp.data; } else return null; }

// Return reference to the node with the specified index private Node getNode(int index) { Node node = head; for (int i = 0; i < index && node != null; i++) { node = node.next; } return node; }

/** Public methods */ // Return String representation of the list public String toString( ) { String str = ""; Node nodeRef = head; for(int i = 0; i < size; i++) { str = str + nodeRef.data + " "; nodeRef = nodeRef.next; } return str; }

// Method to check whether the list is empty public boolean isEmpty( ) { return head == null; }

// Return actual number of elements (nodes) in the list public int size( ) { return size; }

// Return the object at the specified index public E get(int index) { if (index < 0 || index >= size) { throw new IndexOutOfBoundsException(Integer.toString(index)); } Node node = getNode(index); return node.data; }

// Replace the element at the specified index by the // new value anEntry and return the old value public E set (int index, E anEntry) { if (index < 0 || index >= size) { throw new IndexOutOfBoundsException(Integer.toString(index)); } Node node = getNode(index); // calling private method E result = node.data; node.data = anEntry; return result; }

// Method to insert a new item at the specified index in // the list public void add (int index, E item) { if (index < 0 || index > size) { throw new IndexOutOfBoundsException(Integer.toString(index)); } if (index == 0) addFirst(item); else { Node node = getNode(index - 1); addAfter(node, item); } }

// Method to insert a new item (node) at the end of the list public boolean add (E item) { add(size, item); // calling public method add return true; }

// Remove the node at the given index and return its data public E remove (int index) { if (index < 0 || index >= size) { throw new IndexOutOfBoundsException(Integer.toString(index)); } E item; if (index == 0) item = removeFirst( ); else { Node node = getNode(index - 1); item = removeAfter(node); } return item; // return the deleted value }

// Method to search an item in the list. If found, return its // location, else return -1. It is assumed that the class of item // implements equals method. The method finds the first // occurrence of item in the list. public int indexOf(E item) { int index = 0; Node node = head; while (node != null) { if ( item.equals( node.data) ) return index; else { node = node.next; index++; } } return -1; // item not found }

// Method to remove the first occurrence of the item from // the list, if present and return true, else return false public boolean remove (E item) { int index = indexOf(item); if (index != -1) { remove(index); // remove node at the index return true; // item found } else return false; // item not found }

// Method to check whether an object is in the list. If found, // return true, else return false. public boolean contains(E item) { int index = indexOf(item); if (index != -1) return true; // item found else return false; // item not found }

// Method to delete all nodes from the list and make it empty public void clear( ) { while (head != null ){ head.data = null; head = head.next; } size = 0; } } // end SingleListList class