Javai have to make a method that takes a linked list and then retu.pdf

•

0 likes•2 views

Java i have to make a method that takes a linked list and then returns a new linked list that is the reverse of the original this is the starting code /** * LinkedList lab. * @author Emma Cheney * @version 10/2/23 */ public class LinkedList { /** * Internal Node class used for the linked list. */ public class Node { String key; int value; Node next; /** * Node Constructor. * @param key The Key * @param value The Value */ public Node(String key, int value) { this.key = key; this.value = value; } } private Node head; private Node tail; /** * The default constructor. */ public LinkedList() { head = null; tail = null; } /** * Add the key, value pair to the head of the linkedlist. * @param key The Key * @param val The Value * */ public void addHead(String key, int val) { Node n = new Node(key, val); if (head == null) { head = n; tail = n; } else { n.next = head; head = n; } } /** * Add the key, val pair to the tail of the linkedlist. * @param key The Key * @param val The Value */ public void addTail(String key, int val) { Node n = new Node(key, val); if (tail == null) { head = n; tail = n; } else { tail.next = n; tail = n; } } /** * Returns the String format of the linkedlist. * @return String The String format. */ public String toString() { String ret = ""; Node curr = head; while (curr != null) { if (curr.next != null) { ret += curr.key + ":" + curr.value + ", "; } else { ret += curr.key + ":" + curr.value; } curr = curr.next; } return ret; } /** * Locate the Node in the linkedlist with the given key. * @param key The key to find in the LinkedList * @return Node Returns the Node with the given key or null if non-existent. */ private Node find(String key) { Node curr = head; while (curr != null) { if (curr.key.equals(key)) { return curr; } curr = curr.next; } return null; } A static method called reversed that takes a LinkedList as a parameter and returns a new LinkedList that is reversed. f; traverse through the input list (starting at the head). In order to reverse the ordering, you need to add the current node's key and value onto the head of the new list (addHead method). Do not change the input list or any values in it. Example (result in red) //assumelistcontainsthesekeysandvalues://ie:6,bi:48,bi:73,bi:63LinkedList.reversed(list);bi:63,bi: 73,bi:48,ie:6.

Education

private Node head;
private Node tail;
/**
* The default constructor.
*/
public LinkedList() {
head = null;
tail = null;
}
/**
* Add the key, value pair to the head of the linkedlist.
* @param key The Key
* @param val The Value
*
*/
public void addHead(String key, int val) {
Node n = new Node(key, val);
if (head == null) {
head = n;
tail = n;
} else {
n.next = head;
head = n;
}
}
/**
* Add the key, val pair to the tail of the linkedlist.
* @param key The Key

* @param val The Value
*/
public void addTail(String key, int val) {
Node n = new Node(key, val);
if (tail == null) {
head = n;
tail = n;
} else {
tail.next = n;
tail = n;
}
}
/**
* Returns the String format of the linkedlist.
* @return String The String format.
*/
public String toString() {
String ret = "";
Node curr = head;
while (curr != null) {
if (curr.next != null) {
ret += curr.key + ":" + curr.value + ", ";
} else {
ret += curr.key + ":" + curr.value;
}
curr = curr.next;

}
return ret;
}
/**
* Locate the Node in the linkedlist with the given key.
* @param key The key to find in the LinkedList
* @return Node Returns the Node with the given key or null if non-existent.
*/
private Node find(String key) {
Node curr = head;
while (curr != null) {
if (curr.key.equals(key)) {
return curr;
}
curr = curr.next;
}
return null;
} A static method called reversed that takes a LinkedList as a parameter and returns a new
LinkedList that is reversed. f; traverse through the input list (starting at the head). In order to
reverse the ordering, you need to add the current node's key and value onto the head of the new
list (addHead method). Do not change the input list or any values in it. Example (result in red)
//assumelistcontainsthesekeysandvalues://ie:6,bi:48,bi:73,bi:63LinkedList.reversed(list);bi:63,bi:
73,bi:48,ie:6

Similar to Javai have to make a method that takes a linked list and then retu.pdf

Data Structures in C++ I am really new to C++, so links are really hard topic for me. It would be nice if you can provide explanations of what doubly linked lists are and of some of you steps... Thank you In this assignment, you will implement a doubly-linked list class, together with some list operations. To make things easier, you’ll implement a list of int, rather than a template class. Solution A variable helps us to identify the data. For ex: int a = 5; Here 5 is identified through variable a. Now, if we have collection of integers, we need some representation to identify them. We call it array. For ex: int arr[5] This array is nothing but a Data Structure. So, a Data Structure is a way to group the data. There are many Data Structures available like Arrays, Linked List, Doubly-Linked list, Stack, Queue, etc. Doubly-Linked list are the ones where you can traverse from the current node both in left and right directions. Why so many different types of Data Structures are required ? Answer is very simple, grouping of data, storage of data and accessing the data is different. For example, in case of Arrays we store all the data in contiguous locations. What if we are not able to store the data in contiguous locations because we have huge data. Answer is go for Linked List/Doubly-Linked list. Here we can store the data anywhere and link the data through pointers. I will try to provide comments for the code you have given. May be this can help you. #pragma once /* dlist.h Doubly-linked lists of ints */ #include class dlist { public: dlist() { } // Here we are creating a NODE, it has a integer value and two pointers. // One pointer is to move to next node and other to go back to previous node. struct node { int value; node* next; node* prev; }; // To return head pointer, i.e. start of the Doubly-Linked list. node* head() const { return _head; } // To return Tail pointer, i.e. end of the Doubly-Linked list. node* tail() const { return _tail; } // **** Implement ALL the following methods **** // Returns the node at a particular index (0 is the head). node* at(int index){ int cnt = 0; struct node* tmp = head(); while(tmp!=NULL) { if (cnt+1 == index) return tmp; tmp = tmp->next; } } // Insert a new value, after an existing one void insert(node *previous, int value){ // check if the given previous is NULL if (previous == NULL) { printf(\"the given previous node cannot be NULL\"); return; } // allocate new node struct node* new_node =(struct node*) malloc(sizeof(struct node)); // put in the data new_node->data = new_data; // Make next of new node as next of previous new_node->next = previous->next; // Make the next of previous as new_node previous->next = new_node; // Make previous as previous of new_node new_node->prev = previous; // Change previous of new_node\'s next node if (new_node->next != NULL) new_node->next->prev = new_node; } // Delete the given node void del(node* which){ struct node* head_ref = head(); /* base case */ if(*head_ref == NUL.

Data Structures in C++I am really new to C++, so links are really .pdf

rohit219406

public class MyLinkedList<E extends Comparable<E>> { private Node<E> head, tail; private int size = 0; // Number of elements in the list public MyLinkedList() { head=tail=null; size=0; } /** Return the head element in the list */ public E getFirst() { if (size == 0) { return null; } else { return head.element; } } /** Return the last element in the list */ public E getLast() { if (size == 0) { return null; } else { return tail.element; } } /** Add an element to the beginning of the list */ public void addFirst(E e) { Node<E> newNode = new Node<>(e); // Create a new node newNode.next = head; // link the new node with the head head = newNode; // head points to the new node size++; // Increase list size if (tail == null) // the new node is the only node in list tail = head; } /** Add an element to the end of the list */ public void addLast(E e) { Node<E> newNode = new Node<>(e); // Create a new for element e if (tail == null) { head = tail = newNode; // The new node is the only node in list } else { tail.next = newNode; // Link the new with the last node tail = newNode; // tail now points to the last node } size++; // Increase size } public void add(int index, E e) { if (index == 0) { addFirst(e); } else if (index >= size) { addLast(e); } else { Node<E> current = head; for (int i = 1; i < index; i++) { current = current.next; } Node<E> temp = current.next; current.next = new Node<>(e); (current.next).next = temp; size++; } } //Add e to the end of this linkedlist public void add(E e) { // Left as Exercise } /** Remove the head node and * return the object that is contained in the removed node. */ public E removeFirst() { if (size == 0) { return null; } else { E temp = head.element; head = head.next; size--; if (head == null) { tail = null; } return temp; } } /** Remove the last node and * return the object that is contained in the removed node. */ public E removeLast() { if (size == 0) { return null; } else if (size == 1) { E temp = head.element; head = tail = null; size = 0; return temp; } else { Node<E> current = head; for (int i = 0; i < size - 2; i++) { current = current.next; } E temp = tail.element; tail = current; tail.next = null; size--; return temp; } } /** Remove the element at the specified position in this * list. Return the element that was removed from the list. */ public E remove(int index) { if (index < 0 || index >= size) { return null; } else if (index == 0) { return removeFirst(); } else if (index == size - 1) { return removeLast(); } else { Node<E> previous = head; for (int i = 1; i < index; i++) { previous = previous.next; } Node<E> current = previous.next; previous.next = current.next; size--; return current.element; } } /** Clear the list */ public void clear() { size = 0; head = tail = null; } /** Override toString() to return elements in the list in [] separated by , */ public String toString() { StringBuilder result = new StringBuilder("["); Node<E> current = head; for (int i = 0; i < size; i++) { result.append(current..

public class MyLinkedListltE extends ComparableltEgtg.pdf

accostinternational

* Program to insert in a sorted list */ #include #include /* Link list node */ struct node { int data; struct node* next; }; /* function to insert a new_node in a list. Note that this function expects a pointer to head_ref as this can modify the head of the input linked list (similar to push())*/ void sortedInsert(struct node** head_ref, struct node* new_node) { struct node* current; /* Special case for the head end */ if (*head_ref == NULL || (*head_ref)->data >= new_node->data) { new_node->next = *head_ref; *head_ref = new_node; } else { /* Locate the node before the point of insertion */ current = *head_ref; while (current->next!=NULL && current->next->data < new_node->data) { current = current->next; } new_node->next = current->next; current->next = new_node; } } /* BELOW FUNCTIONS ARE JUST UTILITY TO TEST sortedInsert */ /* A utility function to create a new node */ struct node *newNode(int new_data) { /* allocate node */ struct node* new_node = (struct node*) malloc(sizeof(struct node)); /* put in the data */ new_node->data = new_data; new_node->next = NULL; return new_node; } /* Function to print linked list */ void printList(struct node *head) { struct node *temp = head; while(temp != NULL) { printf(\"%d \", temp->data); temp = temp->next; } } /* Drier program to test count function*/ int main() { /* Start with the empty list */ struct node* head = NULL; struct node *new_node = newNode(5); sortedInsert(&head, new_node); new_node = newNode(10); sortedInsert(&head, new_node); new_node = newNode(7); sortedInsert(&head, new_node); new_node = newNode(3); sortedInsert(&head, new_node); new_node = newNode(1); sortedInsert(&head, new_node); new_node = newNode(9); sortedInsert(&head, new_node); printf(\"\ Created Linked List\ \"); printList(head); return 0; } public class Listnode { //*** fields *** private Object data; private Listnode next; //*** methods *** // 2 constructors public Listnode(Object d) { this(d, null); } public Listnode(Object d, Listnode n) { data = d; next = n; } // access to fields public Object getData() { return data; } public Listnode getNext() { return next; } // modify fields public void setData(Object ob) { data = ob; } public void setNext(Listnode n) { next = n; } } Thsi below program print out all the varibles in SLL #include #include #include /* Link list node */ struct node { int data; struct node* next; }; /* Given a reference (pointer to pointer) to the head of a list and an int, push a new node on the front of the list. */ void push(struct node** head_ref, int new_data) { /* allocate node */ struct node* new_node = (struct node*) malloc(sizeof(struct node)); /* put in the data */ new_node->data = new_data; /* link the old list off the new node */ new_node->next = (*head_ref); /* move the head to point to the new node */ (*head_ref) = new_node; } /* Takes head pointer of the linked list and index as arguments and return data at index*/ int GetNth(struct node* head, int index) { struct node* current = head; int .

Program to insert in a sorted list #includestdio.h#include.pdf

sudhirchourasia86

STAGE 2: The Methods (65 points) Implement all the methods that are marked as Left as Exercise. The Driver program only works when you have done all the methods. I have added the template of all the methods with a placeholder value as return types of the methods. For example, return 0 if method returns an int value. List of the methods left as exercise are as follows: /** Create a list from an array of objects */ @SuppressWarnings("unchecked") public MyLinkedList(E[] objects) /** Add a new element at the specified index in this list in ascending order */ public void addInOrder(E e) /** Check to see if this list contains element e */ public boolean contains(E e) /** Remove all the occurrences of the element e * from this list. Return true if the element is * removed. */ public boolean removeAll(E e) /** Remove the first occurrence of the element e * from this list. Return true if the element is * removed. */ public boolean remove(E e) /** Return the element at the specified index */ public E get(int index) /** Return the index of the head matching element in * this list. Return -1 if no match. */ public int indexOf(Object e) /** Return the index of the last matching element in * this list. Return -1 if no match. */ public int lastIndexOf(E e) /** Replace the element at the specified position * in this list with the specified element. */ public E set(int index, E e) /** Print this list using recursion */ public void printList() /** Returns an array containing all of the elements * in this collection; * the runtime type of the returned array is that of * the specified array. */ public <E> E[] toArray(E[] array) /** Split the original list in half. The original * list will continue to reference the * front half of the original list and the method * returns a reference to a new list that stores the * back half of the original list. public class MyLinkedList<E extends Comparable<E>> { private Node<E> head, tail; private int size = 0; // Number of elements in the list public MyLinkedList() { head=tail=null; size=0; } /** Return the head element in the list */ public E getFirst() { if (size == 0) { return null; } else { return head.element; } } /** Return the last element in the list */ public E getLast() { if (size == 0) { return null; } else { return tail.element; } } /** Add an element to the beginning of the list */ public void addFirst(E e) { Node<E> newNode = new Node<>(e); // Create a new node newNode.next = head; // link the new node with the head head = newNode; // head points to the new node size++; // Increase list size if (tail == null) // the new node is the only node in list tail = head; } /** Add an element to the end of the list */ public void addLast(E e) { Node<E> newNode = new Node<>(e); // Create a new for element e if (tail == null) { head = tail = newNode; // The new node is the only node in list } else { tail.next = newNode; // Link the new with the last node tail = newNode; // tail now points to the last node } size++; // Incr.

STAGE 2 The Methods 65 points Implement all the methods t.pdf

babitasingh698417

linked List.docx vhjgvjhvgjhjhbbjkhkjhkjh

vasavim9

How do I fix it in java? LinkedList.java: /** * Defines a doubly-linked list class * @author * @author */ import java.util.NoSuchElementException; public class LinkedList { private class Node { private T data; private Node next; private Node prev; public Node(T data) { this.data = data; this.next = null; this.prev = null; } } private int length; private Node first; private Node last; private Node iterator; /**** CONSTRUCTORS ****/ /** * Instantiates a new LinkedList with default values * @postcondition */ public LinkedList() { first = null; last = null; iterator = null; length = 0; } /** * Converts the given array into a LinkedList * @param array the array of values to insert into this LinkedList * @postcondition */ public LinkedList(T[] array) { } /** * Instantiates a new LinkedList by copying another List * @param original the LinkedList to copy * @postcondition a new List object, which is an identical, * but separate, copy of the LinkedList original */ public LinkedList(LinkedList original) { } /**** ACCESSORS ****/ public T getFirst() throws NoSuchElementException { if (isEmpty()){ throw new NoSuchElementException("The list is empty"); } return first.data; } public T getLast() throws NoSuchElementException { if (isEmpty()){ throw new NoSuchElementException("The list is empty"); } return last.data; } /** * Returns the data stored in the iterator node * @precondition * @return the data stored in the iterator node * @throw NullPointerException */ public T getIterator() throws NullPointerException { if (iterator != null){ return iterator.data; }else{ throw new NullPointerException("Iterator is off the end opf the list."); } } /** * Returns the current length of the LinkedList * @return the length of the LinkedList from 0 to n */ public int getLength() { return length; } /** * Returns whether the LinkedList is currently empty * @return whether the LinkedList is empty */ public boolean isEmpty() { return length == 0; } /** * Returns whether the iterator is offEnd, i.e. null * @return whether the iterator is null */ public boolean offEnd() { return iterator == null; } /**** MUTATORS ****/ public void addFirst(T data) { Node newNode = new Node(data); if(isEmpty()){ first = newNode; last = newNode; } else{ newNode.next = first; first.prev = newNode; first = newNode; } length++; } public void addLast(T data) { Node newNode = new Node(data); if(isEmpty()){ first = newNode; last = newNode; } else{ last.next = newNode; newNode.prev = last; last = newNode; } length++; } /** * Inserts a new element after the iterator * @param data the data to insert * @precondition * @throws NullPointerException */ public void addIterator(T data) throws NullPointerException{ if(iterator != null){ Node newNode = new Node(data); newNode.next = iterator.next; iterator.next = newNode; if (iterator == first){ first = newNode; } }else{ throw new NullPointerException("Iterator is off the end opf the list."); } } / public void removeFirst() throws NoSuchElementException { if(is.

How do I fix it in javaLinkedList.java Defines a doubl.pdf

fmac5

How do I fix it in LinkedList.java? LinkedList.java: /** * Defines a doubly-linked list class * @author * @author */ import java.util.NoSuchElementException; public class LinkedList { private class Node { private T data; private Node next; private Node prev; public Node(T data) { this.data = data; this.next = null; this.prev = null; } } private int length; private Node first; private Node last; private Node iterator; /**** CONSTRUCTORS ****/ /** * Instantiates a new LinkedList with default values * @postcondition */ public LinkedList() { first = null; last = null; iterator = null; length = 0; } /** * Converts the given array into a LinkedList * @param array the array of values to insert into this LinkedList * @postcondition */ public LinkedList(T[] array) { } /** * Instantiates a new LinkedList by copying another List * @param original the LinkedList to copy * @postcondition a new List object, which is an identical, * but separate, copy of the LinkedList original */ public LinkedList(LinkedList original) { } /**** ACCESSORS ****/ public T getFirst() throws NoSuchElementException { if (isEmpty()){ throw new NoSuchElementException("The list is empty"); } return first.data; } public T getLast() throws NoSuchElementException { if (isEmpty()){ throw new NoSuchElementException("The list is empty"); } return last.data; } /** * Returns the data stored in the iterator node * @precondition * @return the data stored in the iterator node * @throw NullPointerException */ public T getIterator() throws NullPointerException { if (iterator != null){ return iterator.data; }else{ throw new NullPointerException("Iterator is off the end opf the list."); } } /** * Returns the current length of the LinkedList * @return the length of the LinkedList from 0 to n */ public int getLength() { return length; } /** * Returns whether the LinkedList is currently empty * @return whether the LinkedList is empty */ public boolean isEmpty() { return length == 0; } /** * Returns whether the iterator is offEnd, i.e. null * @return whether the iterator is null */ public boolean offEnd() { return iterator == null; } /**** MUTATORS ****/ public void addFirst(T data) { Node newNode = new Node(data); if(isEmpty()){ first = newNode; last = newNode; } else{ newNode.next = first; first.prev = newNode; first = newNode; } length++; } public void addLast(T data) { Node newNode = new Node(data); if(isEmpty()){ first = newNode; last = newNode; } else{ last.next = newNode; newNode.prev = last; last = newNode; } length++; } /** * Inserts a new element after the iterator * @param data the data to insert * @precondition * @throws NullPointerException */ public void addIterator(T data) throws NullPointerException{ if(iterator != null){ Node newNode = new Node(data); newNode.next = iterator.next; iterator.next = newNode; if (iterator == first){ first = newNode; } }else{ throw new NullPointerException("Iterator is off the end opf the list."); } } / public void removeFirst() throws NoSuchElementExcept.

How do I fix it in LinkedList.javaLinkedList.java Define.pdf

mail931892

Note: Can someone help me with the Public boolean add(E value) method and Private void add(E value,Node n) method. I have everything but it is not working. Also need help with the remove methods. Both public and private methods for remove. package edu.ust.cisc; import java.util.Iterator; import java.util.NoSuchElementException; public class CiscSortedLinkedList > implements CiscList { /** * A reference to this list's dummy node. Its next reference should refer to the node containing the first element * in this list, or it should refer to itself if the list is empty. The next reference within the node containing * the last element in this list should refer to dummy, thus creating a cyclic list. */ private Node dummy; /** * Number of elements in the list. */ private int size; /** * Constructs an empty CiscSortedLinkedList instance with a non-null dummy node whose next reference refers to * itself. */ public CiscSortedLinkedList() { dummy = new Node<>(null, null); dummy.next = dummy; } /** * Returns the number of elements in this list. * * @return the number of elements in this list */ @Override public int size() { return size; } /** * Returns {@code true} if this list contains no elements. * * @return {@code true} if this list contains no elements */ @Override public boolean isEmpty() { return size==0; } /** * Returns {@code true} if this list contains the specified element (compared using the {@code equals} method). * This implementation should stop searching as soon as it is able to determine that the specified element is not * present. * @param o element whose presence in this list is to be tested * @return {@code true} if this list contains the specified element * @throws NullPointerException if the specified element is null */ @Override public boolean contains(Object o) { if(o==null){ throw new NullPointerException(); } return containsHelper(o,dummy.next); } private boolean containsHelper(Object o, Node node){ if(node== dummy){ return false; } else if(o.equals(node.data)){ return true; } else{ return containsHelper(o,node.next); } } /** * Returns an iterator over the elements in this list in proper sequence. * * @return an iterator over the elements in this list in proper sequence */ @Override public Iterator iterator() { //return new Iterator (){ //private Node curr = dummy.next; //private Node prev = dummy; //private boolean canRemove = false; return new CiscLinkedListIterator(); } /** * Returns an array containing all of the elements in this list in proper sequence (from first to last element). * * The returned array will be "safe" in that no references to it are maintained by this list. (In other words, * this method must allocate a new array even if this list is backed by an array). The caller is thus free to modify * the returned array. * * @return an array containing all of the elements in this list in proper sequence */ @Override public Object[] toArray() { Object[] arr = new Object[size]; int i = 0; for(Node current = dummy;curren.

Note- Can someone help me with the Public boolean add(E value) method.pdf

Stewart29UReesa

could you implement this function please, im having issues with it. void makeList (const ListNode::value_type [],const size_t& count) class ListNode { public: typedef int value_type; ListNode (value_type d = value_type(), ListNode* n = NULL) { datum = d; next = n; } //Assessor value_type getDatum () const { return datum; } ListNode const* getNext () const { return next; } //Mutator void setDatum (const value_type& d) {datum = d; } ListNode* getNext () { return next; } void setNext (ListNode* new_link) {next = new_link; } private: value_type datum; ListNode* next; }; class LinkedList { public: LinkedList (); virtual ~LinkedList (); void insertItem (ListNode::value_type); void makeList (const ListNode::value_type [],const size_t& count); void deleteList (); //The following friend function is implemented in lablinklist.cpp friend std::ostream& operator<<(std::ostream&, const LinkedList&); private: ListNode* head; }; This is the pseudocode, but i still have a hard time undertanding it. Creating a List (makeList(const ListNode::value_type [],const size_t& count)) This function receives an array in the order that we want to add it to the linkedlist. Index 0 will be the head node, index n will be the last node. First, create a node initialized with a data value and a NULL pointer. Set the \"head\" to point to the first node. Set up a current-pointer to the first node (or \"head\"). Get a data value for the next node. While more nodes to add { Create a new node initialized with the data value and a NULL pointer. Set the current-pointer link member (\"next\") to the new node. Set the current-pointer to point to the new node. Get a data value for the next node. } Thanks. Solution //linkedList.h #ifndef LINKEDLIST_H #define LINKEDLIST_H #include #include class ListNode { public: typedef int value_type; ListNode(value_type d = value_type(), ListNode* n = NULL) { datum = d; next = n; } //Assessor value_type getDatum() const { return datum; } ListNode const* getNext() const { return next; } //Mutator void setDatum(const value_type& d) { datum = d; } ListNode* getNext() { return next; } void setNext(ListNode* new_link) { next = new_link; } private: value_type datum; ListNode* next; }; class LinkedList { public: LinkedList(); virtual ~LinkedList(); void insertItem(ListNode::value_type); void makeList(const ListNode::value_type[], const size_t& count); void deleteList(); //The following friend function is implemented in lablinklist.cpp friend std::ostream& operator<<(std::ostream&, const LinkedList&); private: ListNode* head; }; #endif ------------------------------------------------------------- //linkedList.cpp #include \"linkedlist.h\" LinkedList::LinkedList() { head = NULL; } LinkedList::~LinkedList() { ListNode *tmp = head; while (tmp != NULL) { head = head->getNext(); delete tmp; tmp = head; } } void LinkedList::insertItem(ListNode::value_type item) { ListNode *newNode,*cur = head; newNode = new ListNode; newNode->setDatum(item); newNode->setNext(NULL);.

could you implement this function please, im having issues with it..pdf

feroz544

import java.util.Iterator; import java.util.NoSuchElementException; /** * An implementation of MyList with a linked list (a longer exercise would be to * implement the List interface as is done in the class java.util.LinkedList: * the source of the LinkedList class is available from Sun. Check it out). */ public class MyLinkedList implements MyList { // A private class to represent a Node in the linked list private class Node { public E item; public Node next; // a convenient constructor public Node(E o) { this.item = o; this.next = null; } } // The start of the linked list private Node head; // The last Node in the linked list private Node tail; // Number of elements in the list private int size; /** * Creates an empty list (this constructor is not necessary) */ public MyLinkedList() { } /** * Returns the number of elements in this list. */ public int size() { return size; } /** * Returns true if this list contains no elements. */ public boolean isEmpty() { return size == 0; } /** * Appends the specified element to the end of this list */ public boolean add(E o) { Node n = new Node(o); // If this is the first element in the list if (head == null) { head = n; } else { // If the list is not empty, use tail tail.next = n; } // update tail tail = n; // update size size++; return true; } /** * Empties this List */ public void clear() { // update head, tail and size head = tail = null; size = 0; } /** * Returns the element at the specified position in this list. */ public E get(int index) { if (index < 0 || index >= size) { throw new IndexOutOfBoundsException(\"index = \" + index); } // Find it Node n = head; for (int i = 0; i < index; i++) { n = n.next; } return n.item; } /** * Returns the index of the specified element (-1 if there is no match) */ public int indexOf(Object o) { // If o is null int index = 0; Node p = head; if (o == null) // look for a null element in the list { while (p != null) { if (p.item == null) { return index; } index++; p = p.next; } } else // o is an object (use equals) { while (p != null) { if (o.equals(p.item)) { return index; } index++; p = p.next; } } // if we get here, o is not in the list return -1; } /** * Returns true if this list contains the specified element. */ public boolean contains(Object o) { // easy with indexOf return indexOf(o) != -1; } /** * Removes the element in the List at position index */ public boolean remove(int index) { if (index < 0 || index >= size) { throw new IndexOutOfBoundsException(\"index = \" + index); } // Find the corresponding node Node prev = null, p = head; for (int i = 0; i < index; i++) { prev = p; p = p.next; } // Remove it // Special case for the first node if (p == head) { head = head.next; } else { prev.next = p.next; } // If the last node has been removed, update tail if (p == tail) { tail = prev; } // update size size--; return true; } /** * Removes the element in the List at position index */ public boolean remove(Object o) { // easy with indexOf and remove int index = i.

import java.util.Iterator; import java.util.NoSuchElementException; .pdf

deepakangel

Note: Can someone help me with the private E get(int index, int currentIndex, Node n)method. The code is not running. Also I need help with the public void add(int index, E element) method too. Please use the parameters provided with the code to solve. package edu.ust.cisc; import java.util.Iterator; import java.util.NoSuchElementException; public class CiscSortedLinkedList > implements CiscList { /** * A reference to this list's dummy node. Its next reference should refer to the node containing the first element * in this list, or it should refer to itself if the list is empty. The next reference within the node containing * the last element in this list should refer to dummy, thus creating a cyclic list. */ private Node dummy; /** * Number of elements in the list. */ private int size; /** * Constructs an empty CiscSortedLinkedList instance with a non-null dummy node whose next reference refers to * itself. */ public CiscSortedLinkedList() { dummy = new Node<>(null, null); dummy.next = dummy; } /** * Returns the number of elements in this list. * * @return the number of elements in this list */ @Override public int size() { return size; } /** * Returns {@code true} if this list contains no elements. * * @return {@code true} if this list contains no elements */ @Override public boolean isEmpty() { return size==0; } /** * Returns {@code true} if this list contains the specified element (compared using the {@code equals} method). * This implementation should stop searching as soon as it is able to determine that the specified element is not * present. * * @param o element whose presence in this list is to be tested * @return {@code true} if this list contains the specified element * @throws NullPointerException if the specified element is null */ @Override public boolean contains(Object o) { if(o==null){ throw new NullPointerException(); } return containsHelper(o,dummy.next); } private boolean containsHelper(Object o, Node node){ if(node== dummy){ return false; } else if(o.equals(node.data)){ return true; } else{ return containsHelper(o,node.next); } } /** * Returns an iterator over the elements in this list in proper sequence. * * @return an iterator over the elements in this list in proper sequence */ @Override public Iterator iterator() { //return new Iterator (){ //private Node curr = dummy.next; //private Node prev = dummy; //private boolean canRemove = false; return null; } /** * Returns an array containing all of the elements in this list in proper sequence (from first to last element). * The returned array will be "safe" in that no references to it are maintained by this list. (In other words, * this method must allocate a new array even if this list is backed by an array). The caller is thus free to modify * the returned array. * * @return an array containing all of the elements in this list in proper sequence */ @Override public Object[] toArray() { Object[] arr = new Object[size]; int i = 0; for(Node current = dummy;current!=null;cur.

Note- Can someone help me with the private E get(int index- int curren (1).docx

VictorzH8Bondx

Please help me to make a programming project I have to sue them today. Please help me make a UnsortedList and SortedList classes. The instructor give me The code of the List and AbstracList Classes that 2 pages we do not modify them. Do not modify this pages!!! List.java import java.util.Iterator; /** * Represents List interface. * * @author Varik Hoang * @version Sep 26, 2016 * @param is of any object type. */ public interface List { /** * The method returns the current number of elements in the list. * * @return the current number of elements in the list greater than or equal 0 */ public int getSize(); /** * The method returns whether the list is empty. * * @return true if list is empty, false otherwise. */ public boolean isEmpty(); /** * The method returns whether value is in the list. * * @param value the value is assigned * @return true if value in the list, false otherwise. */ public boolean contains(Type value); /** * The method inserts an element into the list. * * @param value the value is assigned */ public void insert(Type value); /** * The method clears the list. */ public void clear(); /** * The method returns a string representation of list contents. * * @return a string representation of list contents. * @see Object#toString() */ @Override public String toString(); /** * /** * The method removes first element occurrence from the list. * * @param value the value is assigned * @return the removed value */ public Type remove(Type value); /** * The method returns the index of value. * * @param value the value is assigned. * @return the index of value if in the list, -1 otherwise. */ public int getIndex(Type value); /** * The method removes value at the given index. * * @param index the index must be in range of 0 and size * @return the removed value * @throws IndexOutOfBoundsException if index less than 0 or index greater than * or equal size */ public Type removeAtIndex(int index); /** * The method replaces the value at the given index with the given value. * * @param index the index must be in range of 0 and size * @param value the value is assigned * @throws IndexOutOfBoundsException if index less 0 or index greater than size */ public void set(int index, Type value); /** * Returns the value at the given index in the list. * * @param index the index must be in range of 0 and size * @throws IndexOutOfBoundsException if index less than 0 or greater size * @return the value at the given index in the list. */ public Type get(int index); /** * The method returns an iterator for this list. * * @return an iterator for the list. */ public Iterator iterator(); } Do not modify this pages public abstract class AbstractList implements List { /** * The reference to the last element */ protected ListNode tail; /** * The size of the list */ protected int size; /** * The constructor that initiate the tail and size references */ public AbstractList() { tail = null; size = 0; } @Override public int getSize() { return size; } @Override public bool.

Please help me to make a programming project I have to sue them today- (1).pdf

seoagam1

Write the following using java Given a class ‘Node’ and ‘NodeList’, that contains the below information diagram. -id: int -name: String -next: Node +Node(id: int, name: String) +setId(id: int): void +getId(): int +setName(name: String) : void +getName(): String +setNext(node: Node): void +getNext(): Node NodeList -size: int -root: Node +add(node: Node): void +size(): int +findNode(node: Node): boolean Implement add(Node), findNode(Node) and size methods in the NodeList class which is provided to you. The methods should work as: Using the following main method: public static void main(String[] args) { NodeList list = new NodeList(); Node node = new Node(1, \"Book\"); Node node2 = new Node(2, \"Lappy\"); list.add(node); list.add(node2); System.out.println(\"Length : \"+list.size()); Node node3 = new Node(3, \"Glass\"); Node node4 = new Node(4, \"Pen\"); list.add(node3); System.out.println(\"Length : \"+list.size()); if(list.findNode(node3)) System.out.println(\"Node found: \"+ node3.getName()); else System.out.println(\"Node not found: \"+ node3.getName()); if(list.findNode(node4)) System.out.println(\"Node found: \"+ node4.getName()); else System.out.println(\"Node not found: \"+ node4.getName()); } Then it should return the following output: Length : 2 Length : 3 Node found: Glass Node not found: Pen The given Node class is: public class Node { private int id = 0; private String name = \"\"; private Node next; public Node(int id, String name) { this.id = id; this.name = name; this.next = null; } public Node getNext() { return next; } public void setNext(Node node) { this.next = node } public int getId() { return id; { public void setId(int id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String toString() { return \"ID : \"+this.id+\" Name : \"+this.name; } } The given NodeList class is: public class NodeList { private int size = 0; private Node root = null; /* * It has to take a new Node and add that to the next address of previous Node. * If the list is empty, assign it as the \"root\" * @Param - Node */ public void add(Node node) { // Implement this method!!! } /* * It has to return the size of the NodeList * * @return size */ public int size() { // Implement this method!!! } /* * It has to take a Node and checks if the node is in the list. * If it finds the node, it returns true, otherwise false * * @param - Node * @return boolean true/false */ public boolean findNode(Node node) { // Implement this method!!! } }Node -id: int -name: String -next: Node +Node(id: int, name: String) +setId(id: int): void +getId(): int +setName(name: String) : void +getName(): String +setNext(node: Node): void +getNext(): Node Solution Hi, Please find my implementation. Please let me know in case of any issue. ############ Node.java ############# public class Node { private int id = 0; private String name = \"\"; private Node next; public Node(int id, String name) { this.id = id; this..

Write the following using javaGiven a class ‘Node’ and ‘NodeList’,.pdf

fathimalinks

Objective: Binary Search Tree traversal (2 points) Use traversal.pptx as guidance to write a program to build a binary search tree Dictionary. Input records from inventory.txt. Both key and Element of BST have the same data from each input record. public interface BinNode { /** Get and set the element value */ public E element(); public void setElement(E v); /** @return The left child */ public BinNode left(); /** @return The right child */ public BinNode right(); /** @return True if a leaf node, false otherwise */ public boolean isLeaf(); } import java.lang.Comparable; /** Binary Search Tree implementation for Dictionary ADT */ class BST, E> implements Dictionary { private BSTNode root; // Root of the BST int nodecount; // Number of nodes in the BST /** Constructor */ BST() { root = null; nodecount = 0; } /** Reinitialize tree */ public void clear() { root = null; nodecount = 0; } /** Insert a record into the tree. @param k Key value of the record. @param e The record to insert. */ public void insert(Key k, E e) { root = inserthelp(root, k, e); nodecount++; } // Return root public BSTNode getRoot() { return root; } /** Remove a record from the tree. @param k Key value of record to remove. @return The record removed, null if there is none. */ public E remove(Key k) { E temp = findhelp(root, k); // First find it if (temp != null) { root = removehelp(root, k); // Now remove it nodecount--; } return temp; } /** Remove and return the root node from the dictionary. @return The record removed, null if tree is empty. */ public E removeAny() { if (root == null) return null; E temp = root.element(); root = removehelp(root, root.key()); nodecount--; return temp; } /** @return Record with key value k, null if none exist. @param k The key value to find. */ public E find(Key k) { return findhelp(root, k); } /** @return The number of records in the dictionary. */ public int size() { return nodecount; } private E findhelp(BSTNode rt, Key k) { if (rt == null) return null; if (rt.key().compareTo(k) > 0) return findhelp(rt.left(), k); else if (rt.key().compareTo(k) == 0) return rt.element(); else return findhelp(rt.right(), k); } /** @return The current subtree, modified to contain the new item */ private BSTNode inserthelp(BSTNode rt, Key k, E e) { if (rt == null) return new BSTNode(k, e); if (rt.key().compareTo(k) > 0) rt.setLeft(inserthelp(rt.left(), k, e)); else rt.setRight(inserthelp(rt.right(), k, e)); return rt; } /** Remove a node with key value k @return The tree with the node removed */ private BSTNode removehelp(BSTNode rt,Key k) { if (rt == null) return null; if (rt.key().compareTo(k) > 0) rt.setLeft(removehelp(rt.left(), k)); else if (rt.key().compareTo(k) < 0) rt.setRight(removehelp(rt.right(), k)); else { // Found it if (rt.left() == null) return rt.right(); else if (rt.right() == null) return rt.left(); else { // Two children BSTNode temp = getmin(rt.right()); rt.setElement(temp.element()); rt.setKey(temp.key()); rt.setRight(deletemin(rt.right(.

Objective Binary Search Tree traversal (2 points)Use traversal.pp.pdf

sivakumar19831

Implement the following specification of UnsortedType using circular linked list as the implementation structure. *** I have seen this question answered here before but it is not a good answer. Can someone please give me a original answer.*** // Deliverables: // - A listing of the specification and implementation files for UnsortedType // - A listing of the driver program for your test plan // - A listing of the test plan as input to the driver. // - A listing of the output from the driver. template struct NodeType; /* Assumption: ItemType is a type for which the operators \"<\" and \"==\" are defined-either an appropriate built-in type or a class that overloads these operators. */ template class UnsortedType { public: // Class constructor, destructor, and copy constructor UnsortedType(); ~UnsortedType(); UnsortedType(const UnsortedType&); void operator=(UnsortedType); bool IsFull() const; // Determines whether list is full. //Post: Function value = (list is full) int GetLength() const; // Determines the number of elements in list. // Post: Function value = number of elements in list. void RetrieveItem(ItemType& item, bool& found); // Retrieves list element whose key matches item\'s key // (if present). // Pre: Key member of item is initialized. // Post: If there is an element someItem whose key matches // item\'s key, then found = true and item is a copy of // someItem; otherwise found = false and item is unchanged. // List is unchanged. void InsertItem(ItemType item); // Adds item to list. // Pre: List is not full. // Item is not in list. // Post: item is in list. void DeleteItem(ItemType item); // Deletes the element whose key matches item\'s key // Pre: Key member of item is initialized. // One and only one element in list has a key matching // item\'s key. // Post: No element in list has a key matching item\'s key. void ResetList(); // Initializes current position for an iteration through the list. // Post: Current position is prior to list. void GetNextItem(ItemType&); // Gets the next element in list. // Pre: Current position is defined. // Element at current position is not last in list. // Post: Current position is updated to next position. // item is a copy of element at current position. private: NodeType* listData; int length; NodeType* currentPos; }; Solution #include #include /* structure for a node */ struct node { int data; struct node *next; }; /* function to insert a new_node in a list in sorted way. Note that this function expects a pointer to head node as this can modify the head of the input linked list */ void sortedInsert(struct node** head_ref, struct node* new_node) { struct node* current = *head_ref; // Case 1 of the above algo if (current == NULL) { new_node->next = new_node; *head_ref = new_node; } // Case 2 of the above algo else if (current->data >= new_node->data) { /* If value is smaller than head\'s value then we need to change next of last node */ while(current->next != *head_ref) current = current->next; cur.

Implement the following specification of UnsortedType using circular.pdf

udit652068

package linkedLists; import java.util.Iterator; /** A class representing a singly linked list from scratch. Fill in code. * * Note: you may NOT use any of Java's built in classes that store a collection of elements * such as ArrayList, LinkedList (Java's built in), HashMap, HashTree, HashSet etc. */ public class LinkedList { private Node head, tail; /** Constructor */ public LinkedList() { head = null; tail = null; } /** * Creates a new node with the given element and adds it to the back of the * list. No need to change this method. */ public void append(int elem) { Node newNode = new Node(elem); if (tail != null) { tail.setNext(newNode); tail = newNode; } else { head = tail = newNode; } } /** Prints all the nodes in the link list. No need to change this method. */ public void printNodes() { Node current = head; while (current != null) { System.out.print(current.elem() + " "); current = current.next(); } } /** * Return a sublist of this list where the values of elements are in the range * from value1 to value2, inclusive. * Your method should not destroy the original list and its nodes should *not* reference * the nodes in the input list (you need to create new nodes instead). * Example: * If the list is 6->40->3->17->1 and value1 is 3 and value2 is 20, * then the result should be 6->3->17. * @param value1 value 1 * @param value2 value 2 * @return a sublist of this list where the values of elements are in the range * * from value1 to value2, inclusive. */ public LinkedList sublist(int value1, int value2) { LinkedList res = new LinkedList(); // FILL IN CODE return res; } /** * Insert a new node with the given element into the sorted linked list. * Insert it in the right place based on the value in the node. Assume the * list is sorted by the elem, from smallest to largest. The * list should remain sorted after this insert operation. * Example: If this list is 5->10->18 and we insert 15, then after that the operation, * the list will become 5->10->15->18. */ public void insertInSortedList(int elem) { // insert a node into the sorted list // FILL IN CODE } /** * Assume this linked list is sorted in ascending order, and we do not know the * * number of elements. * * Return a LinkedList that contains k largest elements in the list. * * Use slow & fast pointers to find the k-th node from the end (required). Note: This method * * should be linear and should not count the number of nodes. Do NOT use reverse(). * @param k index from the end * @return linked list that contains k largest elements (k elements from the end of the list) */ public LinkedList getKLargest(int k) { LinkedList result = new LinkedList(); // FILL IN CODE return result; } /** * Merge two sorted linked lists into a single sorted linked list. * * @param list1 * @param list2 * Your method should not destroy the original list and its nodes should *not* reference * the nodes in the input list (you need to create new nodes instead). */ public static LinkedList mergeSortedLists(LinkedLis.

package linkedLists- import java-util-Iterator- --- A class representi.pdf

arcellzone

//tested on eclipse /*************DoublyLinkedList class*******************/ public class DoublyLinkedList { /*Data member variable declaration*/ private Node head; private int count; /**default constructor*/ public DoublyLinkedList() { /*Initializing variable*/ head=null; count =0; } /*Insert at beginning in doubly linked list*/ public void insertBeginning(String name){ /*checking head is null then we will add node at head*/ if(head==null){ head=new Node(name, null, null); count++; }else{ /*else create temp node and setting next to head * and then making temp to head*/ Node temp=new Node(name,null,null); temp.setNext(head); head.setPrev(temp); head=temp; count++; } } public void printList(){ Node temp=head; /*Printing element of doubly list*/ while(temp!=null){ System.out.println(temp.getData()); temp=temp.getNext(); } } /*Returning count from doubly linked list*/ public int count(){ return count; } /*deleting specific node from doubly linked list*/ public void delete(String name){ Node current=head,previous=head; /*if it is head node to be deleted*/ if(head.getData().equals(name)){ current=head.getNext(); current.setPrev(null); head=current; previous=head; }else{ /*If node in middle of list*/ while(current.getNext()!=null){ if(current.getData().equals(name)){ current.getNext().setPrev(previous); previous.setNext(current.getNext()); count--; break; } previous=current; current=current.getNext(); } /*If node is at last*/ if(current.getNext()==null){ if(current.getData().equals(name)){ previous.setNext(null); count--; } } } } /*deleting all nodes from list by assigning head to null * and memory releasing take care by garbage collector*/ public void clear(){ head=null; count=0; } /*Inserting element in alphabetic order*/ public void insertAlpha(String name){ Node current=head,previous=head; /*creating new node*/ Node newNode=new Node(name,null,null); /*if head node is null*/ if(head==null){ head=newNode; count++; }else{ /*please read about compareTo() method about returning value*/ if(head.getData().compareTo(name)>0){ newNode.setNext(head); head=newNode; count++; }else{ /*condition for getting position of node to be inserted*/ while(current!=null&&current.getData().compareTo(name)<=0){ previous=current; current=current.getNext(); } /*if node need to be inserted at last*/ if(current==null){ previous=newNode; }else{ /*If node need to inserted in middle*/ newNode.setNext(current); previous.setNext(newNode); current.setPrev(newNode); newNode.setPrev(previous); } count++; } } } /*Main method start*/ public static void main(String args[]){ /*creating object of doubly linked list*/ DoublyLinkedList doublyLinkedList=new DoublyLinkedList(); doublyLinkedList.insertBeginning(\"sunita\"); doublyLinkedList.insertBeginning(\"lalchand\"); /*calling alphabetic order method*/ doublyLinkedList.insertAlpha(\"ramsingh\"); doublyLinkedList.insertBeginning(\"Lokesh\"); doublyLinkedList.insertBeginning(\"Pritam\"); /*****printing list********/ doublyLinkedList.printL.

tested on eclipseDoublyLinkedList class.pdf

shanki7

package singlylinkedlist; public class Node { public String value; public Node next; public Node(String value) { this.value = value; } @Override public String toString() { return value; } } SingleyLinkedList.java : package singlylinkedlist; import java.io.*; import java.util.*; /** * Defines the interface for a singly-linked list. * */ public interface SinglyLinkedList { /** * @return Reference to the first node. If the list is empty, this method * returns null. */ public Node getFirst(); /** * @return Reference to the last node . If the list is empty, this method * returns null. */ public Node getLast(); /** * @return Number of nodes in the list */ public int size(); /** * @return true if the list has no nodes; false otherwise */ public boolean isEmpty(); /** * Removes all nodes in the list. */ public void clear(); /** * Inserts a new node with the given value after cursor. * * @param cursor * The node to insert after. Set this to null to insert value as the * new first Node. * @param value * The value to insert * @return a reference to the newly inserted Node */ public Node insert(Node cursor, String value); /** * Inserts a new node with the given value at the "end" of the list. * * @param value * @return a reference to the newly inserted Node */ public Node append(String value); /** * Removes the node after the specified Node (cursor) from the list. * * @param cursor * A reference to the Node to remove. */ public void removeAfter(Node cursor); /** * Returns a reference to the first Node containing the key, starting from the * given Node. * * @param start * @param key * @return a reference to the first Node containing the key */ public Node find(Node start, String key); /** * Prints the values of all the items in a list */ public void printWholeList(); } SinglyLinkedTester.java: package sbccunittest; import static java.lang.Math.*; import static java.lang.System.*; import static org.apache.commons.lang3.StringUtils.*; import static org.junit.Assert.*; import static sbcc.Core.*; import java.io.*; import java.lang.reflect.*; import java.nio.file.*; import java.util.*; import java.util.stream.*; import org.apache.commons.lang3.*; import org.junit.*; import org.w3c.dom.ranges.*; import sbcc.*; import singlylinkedlist.*; /** * 09/16/2021 * * @author sstrenn * */ public class SinglyLinkedListTester { public static String newline = System.getProperty("line.separator"); public static int totalScore = 0; public static int extraCredit = 0; public static boolean isZeroScore = false; public static String scorePreamble = ""; @BeforeClass public static void beforeTesting() { totalScore = 0; extraCredit = 0; } @AfterClass public static void afterTesting() { if (isZeroScore) { totalScore = 0; extraCredit = 0; } println(scorePreamble + "Estimated score (w/o late penalties, etc.) is: " + totalScore + " out of 25."); // If the project follows the naming convention, save the results in a folder on // the desktop. (Alex Kohanim) try { String directory = substri.

package singlylinkedlist; public class Node { public String valu.pdf

amazing2001

Given below is the completed implementation of MyLinkedList class. Other classes are not modified and remain same as in question - MyList, MyAbstractList, TestMyLinkedList. The output of TestMyLinkedList is shown below. Please don\'t forget to rate the answer if it helped. Thank you very much. Since the MyList is not completely pasted in the question ... giving the complete class file below MyList.java public interface MyList> extends java.lang.Iterable { // Add a new element at the end of this list public void add (E e); // Add a new element at specified index in this list public void add (int index, E e); // Return true if this list contains the element public boolean contains (E e); // Return the element at the specified index public E get (int index); // Return the index of the first matching element // Return -1 if no match. public int indexOf (E e); // Return the index of the last matching element // Return -1 if no match. public int lastIndexOf (E e); E remove(int index); void clear(); E set(int index, E e); } MyLinkedList.java public class MyLinkedList> extends MyAbstractList implements Comparable> { private Node head, tail; // head and tail pointers // Create a default list public MyLinkedList() { } public int size() { return size; } // Need this for implementing Comparable public int compareTo (MyLinkedList e) { return(size() - e.size()); } // Create a list from an array of objects public MyLinkedList (E[] objects) { super(objects); // Passes the array up to abstract parent } // Return the head element in the list public E getFirst() { if (size == 0) { return null; } else { return head.element; } } // Return the last element in the list public E getLast() { if (size == 0) { return null; } else { return tail.element; } } // Add an element to the beginning of the list public void addFirst (E e) { // Create a new node for element e Node newNode = new Node(e); newNode.next = head; // link the new node with the head head = newNode; // head points to the new node size++; // Increase list size if (tail == null) // new node is only node { tail = head; } } // Add an element to the end of the list public void addLast (E e) { // Create a new node for element e Node newNode = new Node(e); if (tail == null) { head = tail = newNode; // new node is only node } else { tail.next = newNode; // Link the new with the last node tail = tail.next; // tail now points to the last node } size++; // Increase size } // Remove the head node and // return the object from the removed node public E removeFirst() { if (size == 0) { return null; } else { Node temp = head; head = head.next; size--; if (head == null) { tail = null; } return temp.element; } } // Remove the last node and return the object from it public E removeLast() { if (size == 0) { return null; } else if (size == 1) { Node temp = head; head = tail = null; size = 0; return temp.element; } else { Node current = head; for (int i = 0; i < size - 2; i++) { current = current.next; } Node temp = tail; tai.

Given below is the completed implementation of MyLinkedList class. O.pdf

info430661

File LinkedList.java Defines a doubly-l.pdf

Conint29

Similar to Javai have to make a method that takes a linked list and then retu.pdf (20)