PROBLEM STATEMENTIn this assignment, you will complete DoubleEnde.pdf
0 likes4 views
PROBLEM STATEMENT: In this assignment, you will complete DoubleEndedList.java that implements the ListInterface as well as an interface called DoubleEndedInterface which represents the list's entries by using a chain of nodes that has both a head reference and a tail reference. Be sure to read through the code and understand the implementation. WHAT IS PROVIDED: - A driver class to test your code. You should not modify this file! - A list interface (ListInterface.java) - A double ended interface (DoubleEndedInterface.java) - An incomplete DoubleEndedList class (DoubleEndedList.java) WHAT YOU NEED TO DO: 4. Complete the DoubleEndedList class 4. Run the driver and make sure your output is exactly the same as mine (at the bottom of Driver.java) \} // end else numberofEntries--; else throw new IndexOut0fBoundsException("Illegal position given to remove operation."); return result; // Return removed entry }//endreturnreve public T replace(int givenPosition, T newEntry) \{ T replace(int givenPosition, T newEntry) \{ if ((givenPosition >=1)&& (givenPosition <= numberOfEntries)) \{ // Assertion: The list is not empty Node desiredNode = getNodeAt (givenPosition); ToriginalEntry = desiredNode.getData(); desiredNode.setData(newEntry); return originalEntry; f // end if else throw new IndexOut0fBoundsException("Illegal position given to replace operation."); replace if (( givenPosition >=1)&& (givenPosition <= number0fEntries)) \{ // Assertion: The list is not empty Node desiredNode = getNodeAt ( givenPosition); T originalEntry = desiredNode. getData( ); desiredNode.setData(newEntry); return originalentry; \} // end if throw new Index0ut0fBoundsException("Illegal position given to replace operation."); \} // end replace public T getEntry(int givenPosition) \{ if ((givenPosition >=1) \&\& (givenPosition < = number0fEntries ) ) \{ // Assertion: The list is not empty return getNodeAt (givenPosition). getData(); else // end if throw new IndexOut0fBoundsException("Illegal position given to getEntry operation."); \} // end getEntry public boolean contains ( T anEntry) \{ boolean found = false; Node currentNode = firstNode; while (!found && (currentNode != null)) \{ if (anEntry.equals (currentNode.getData())) else found = true; \} // end while currentNode = currentNode. getNextNode () ; return found; \} // end contains public int getLength() \{ return numberofEntries; \} // end getLength public boolean isEmpty() \{ return number0fEntries ==0; \} // end isEmpty public T[] toArray() \{ // The cast is safe because the new array contains null entries aSuppressWarnings ("unchecked") T[] result =(T[]) new 0bject [numberofEntries]; // Unchecked cast int index =0; Node currentNode = firstNode; while ((index < numberOfEntries) \&\& (currentNode != null)) \& result [ index ]= currentNode. getData () ; currentNode = currentNode.getNextNode ( ); index++; 3 // end while return result; 3 // end toArray // Returns a reference to the node at a given position. // Precondition: L.
1 of 6
Download to read offline
![numberofEntries; } // end getLength public boolean isEmpty() { return number0fEntries ==0;
} // end isEmpty public T[] toArray() { // The cast is safe because the new array contains null
entries aSuppressWarnings ("unchecked") T[] result =(T[]) new 0bject [numberofEntries]; //
Unchecked cast int index =0; Node currentNode = firstNode; while ((index < numberOfEntries)
&& (currentNode != null)) & result [ index ]= currentNode. getData () ; currentNode =
currentNode.getNextNode ( ); index++; 3 // end while return result; 3 // end toArray // Returns a
reference to the node at a given position. // Precondition: List is not empty; 1<= givenPosition <
= numberofEntries. // Assertion: (firstNode != null) and (1<= givenPosition) and (givenPosition
<= // numberofEntries) Node currentNode = firstNode; if (givenPosition == numberofEntries)
currentNode = lastNode; else if (givenPosition >1 ) // Traverse the chain to locate the desired
node for (int counter =1; counter < givenPosition; counter++) currentNode = currentNode.
getNextNode () ; assert currentNode != null; return currentNode; } // end getNodeAt private
class Node { private T data; // Data portion private Node next; // Next to next node data =
dataPortion; } // end constructor data = dataPortion; } // end constructor private T getData() {
} // end return data; private void setData( T newData) { data = newData; } // end setData
private Node getNextNode() { return next; } // end getNextNode private void
setNextNode(Node nextNode) { next = nextNode; } // end setNextNode } // end Node
1** A class that implements the ADT double-ended list by using a chain of nodes. * The chain
has both a head reference and a tail reference. * Position numbers begin with 1 . * Q eauthor
Frank M. Carrano * dauthor Joseph Erickson */ aversion 5.0 public class DoubleEndedList
implements ListInterface , DoubleEndedInterface { private Node firstNode; // Head reference to
first node private Node lastNode; // Ta private int numberofEntries; public DoubleEndedList() {
} clear (); // ============= // ADDED METHODS: public void addFirst(T newEntry) f } //
end addFirst public void addLast (T newEntry) { } // end addLast public T removefirst() { } //
end removefirst public T removelast() { } // end removelast public T getFirst() { } // end
getFirst public T getLast () { } // end getLast public void moveToEnd() { } // end moveToEnd
// ====================== public final void clear() firstNode = null; lastNode = null;
numberOfEntries =0 } // end clear public void add ( T newEntry) { Node newNode = new Node
(newEntry); // Create new node if (isEmpty()) else firstNode = newNode; las tNode.](https://image.slidesharecdn.com/problemstatementinthisassignmentyouwillcompletedoubleende-231008012952-36f54d7f/85/PROBLEM-STATEMENTIn-this-assignment-you-will-complete-DoubleEnde-pdf-2-320.jpg)
![moveToEnd(); // end DoubleEndedInterface
ver that demonstrates the class DoubleEndedList. thest only the additional methods, since the
methods or Frank M. Carrano ion 5.0 lass Driver { lass Driver { public static void
main(String[] args) { System.out.println("Create an empty list."); System. out.print ln("Create
an empty list."); DoubleEndedList < String > myList = new DoubleEndedList <();
System.out.println("List should be empty; isEmpty() returns " + myList.isEmpty() + ".");
System.out.print ln("nTesting addFirst:"); myList.addFirst ("15"); myList. addFirst (" 25 ")
mylist.addFirst (" 45) System.out.println("List should contain 453525 15."); myList.clear();
mylist.clear(); myList. addLast ("15"); myList.addLast ("35") myList.addLast (" 45)
myList.addLast ("55"); myList. addLast ("65"); displaylist (myList); System.out.print
ln("nTesting removeFirst with previous list:"); System.out.println("removeFirst (): " + myList.
removeFirst ()); System. out.println("nList should containn45 5565 "); displayList (myList);
System. out.println("removefirst(): " + myList. removeFirst()); System.
out.println("removefirst(): " + myList. removefirst()); System. out.println("List should be empty;
isEmpty() returns" + myList.isEmpty() + "."); myList.clear(); myList. addLast ("15");
myList.addLast (" 25 ") myList. addLast ("45"); myList. addLast ("55"); System.out.println("List
should contain 1525354555 65."); displaylist (myList); System.out.println("removeLast (): " +
myList.removeLast()); System.out.println("removeLast (): " + myList.removeLast ()); System.
out.print ln ("removeLast (): " + myList. removeLast ()) System. out.print ln ("removeLast (): " +
mylist.removelast ()); System.out.println("nList should contain n15"); displaylist (myList); ( )
System.out.print ln("nTesting getFirst and getlast with the following list:"); myList.clear()
myList.addLast ("15"); myList.addLast (" 25 "); myList. addLast ("35"); myList. addLast (" 55)
myList.addLast ("65"); displayList (myList): System.out.println("Retrieving the first entry :
returns " + myList.getFirst()); System.out.print ln("nTesting moveToEnd with the following
list:"); displayList (myList); myList. moveToEnd () System. out.println("After moveToEnd, the
list is:"); displaylist (myList); myList. moveToEnd ( ) System.out.println("After moveToEnd, the
list is:"); displaylist (myList); myList. moveToEnd ( ) System.out.println("After moveToEnd, the
list is:"); displaylist (mylist); System. out.print ln ("nnDone."); public static void
displayList(ListInterface aList) { System.out.println("The list contains " + aList.getLength() +
"string(s), as follows:"); Object [] listArray = aList. toArray(); for (int index =0; index <
listarray. length; index++) { } // end for System.out.print ln(); for (int position =1; position <=
listarray. length; position++) { if (position < 10) else System.out.print(" " + position);
System.out.print (position); System.out.print(" "); }//endfor System.out.print ln(); H/ end Driver
e an empty list. should be empty; isEmpty() returns true. son list. ng addFirst: should contain
45352515 ist contains 4 string(s), as follows: 4 ng addlast with the following list: should contain](https://image.slidesharecdn.com/problemstatementinthisassignmentyouwillcompletedoubleende-231008012952-36f54d7f/85/PROBLEM-STATEMENTIn-this-assignment-you-will-complete-DoubleEnde-pdf-4-320.jpg)
![Index0utal entry that was replaced. * givenPosition <1 or givenPosition > */ givenPosition < 1
or givenPosition > getLength(). public T replace(int givenPosition, T newEntry); / ** Retrieves
the entry at a given position in this list. * @param givenPosition An integer that indicates the
position of the desired entry. * areturn A reference to the indicated entry. * Gthrows
Index0ut0fBoundsException if either givenPosition < 1 or givenPosition > */ getLength ( ).
public T getEntry(int givenPosition); /** * Retrieves all entries that are in this list in the order in
which * they occur in the list. * Greturn A newly allocated array of all the entries in the list. * If
the list is empty, the returned array is empty. public T[] toArray(); /*** * Sees whether this list
contains a given entry. * eparam anEntry The object that is the desired entry. * Greturn True if
the list contains anEntry, or false if not. */ public boolean contains ( T anEntry); /*** * Gets the
length of this list. * areturn The integer number of entries currently in the list. public int
getLength(); /** * Sees whether this list is empty. * ereturn True if the list is empty, or false if
not. * a public boolean isEmpty(); // end ListInterface](https://image.slidesharecdn.com/problemstatementinthisassignmentyouwillcompletedoubleende-231008012952-36f54d7f/85/PROBLEM-STATEMENTIn-this-assignment-you-will-complete-DoubleEnde-pdf-6-320.jpg)
Recommended
public class ThreeTenDLList-T- implements Iterable-T- { -- doubly.docx
public class ThreeTenDLList-T- implements Iterable-T- { -- doubly.docxLukeQVdGrantg public class ThreeTenDLList<T> implements Iterable<T> {
// doubly linked list with both head and tail, no dummy nodes
private Node<T> head; //beginning of list
private Node<T> tail; //end of list
// ADD MORE PRIVATE MEMBERS HERE IF NEEDED!
//constructor
// initialize the list to being an empty list
public ThreeTenDLList(){
}
// report number of items
// O(1)
public int size(){
//default return, remove or updated as needed
return -1;
}
// returns the first value from the beginning of the list
// do not remove the value!
// return null if list is empty
// O(1)
public T getFirst() {
//default return, remove or updated as needed
return null;
}
// inserts a new node with value at the begining of the list
// you can assume value is not null
// O(1)
public void addFirst(T value) {
}
// remove and return the first value in the list
//return null if list is empty
// O(1)
public T removeFirst(){
//default return, remove or updated as needed
return null;
}
// returns the last value from the end of the list
// do not remove the value!
// return null if list is empty
// O(1)
public T getLast() {
//default return, remove or updated as needed
return null;
}
// inserts a new value at the end of the list
// you can assume value is not null
// O(1)
public void addLast(T value) {
}
// remove and return the last value from the end of the list
//return null if list is empty
// O(1)
public T removeLast(){
//default return, remove or updated as needed
return null;
}
//remove and return the first occurence of value
// (i.e. the occurence that is closest to head)
// - return null if value is not present
// - note: must return the data from list, not the argument value
//O(n) where n is the number of items
public T remove(T value){
//default return, remove or updated as needed
return null;
}
// return a string representing the values in the list starting from index to end,
// seperated by a single space
// return empty string for invalid start or empty list
// O(n) where n is the number of items
// Warning: concatenating String objects will yield a O(n^2) solution
public String listToString(int start) {
//default return, remove or updated as needed
return null;
}
// return a string representing the values in the list, from end to beginning,
// seperated by a single space
// return empty string for an empty list
// O(n) where n is the number of items
// Warning: concatenating String objects will yield a O(n^2) solution
public String listToStringBackward() {
//default return, remove or updated as needed
return null;
}
public Iterator<T> iterator() {
//Return an iterator that traverses from
//the beginning (head) to the end (tail) of the list
//The iterator's hasNext() and next() methods
//must both be O(1)
//next() should throw a NullPointerException
//if you try to use next when there are no
//more items (any error message is fine).
//update / replace this dummy return statement as neede.
Labprogram.javaLinkedList.javaimport java.util.NoSuchElementEx.pdf
Labprogram.javaLinkedList.javaimport java.util.NoSuchElementEx.pdffreddysarabia1 Labprogram.java
LinkedList.java
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 ****/
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) {
}
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;
}
public T getIterator() throws NullPointerException {
if (iterator != null) {
return iterator.data;
} else {
throw new NullPointerException("Iterator is off the end opf the list.");
}
}
public int getLength() {
return length;
}
public boolean isEmpty() {
return length == 0;
}
public boolean offEnd() {
return iterator == null;
}
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++;
}
public void addIterator(T data) throws NullPointerException {
if (offEnd()) {
throw new NullPointerException("addIterator Iterator is off end.");
}
if (iterator == last) {
addLast(data);
} else {
Node newNode = new Node(data);
Node next = iterator.next;
newNode.next = next;
newNode.prev = iterator;
iterator.next = newNode;
next.prev = newNode;
length++;
}
}
public void removeFirst() throws NoSuchElementException {
if (isEmpty()) {
throw new NoSuchElementException("The list is empty");
}
if (length == 1) {
first = null;
last = null;
iterator = null;
} else {
if (iterator == first) {
iterator = null;
}
first = first.next;
first.prev = null;
}
length--;
}
public void removeLast() throws NoSuchElementException {
if (isEmpty()) {
throw new NoSuchElementException("The list is empty");
}
if (length == 1) {
first = null;
last = null;
iterator = null;
} else {
if (iterator == last) {
iterator = null;
}
last = last.prev;
last.next = null;
}
length--;
}
public void removeIterator() throws NullPointerException {
if (offEnd()) {
throw new NullPointerException("Iterator is off the end opf the list.");
}
if (iterator .
import java-util--- public class MyLinkedList{ public static void.pdf
import java-util--- public class MyLinkedList{ public static void.pdfasarudheen07 import java.util.*; public class MyLinkedList{ public static void main(String[] args){ } } //copy
MyList to here interface MyList extends Collection { /* MyList will inherite all methods from
Collection public boolean add(E e); public boolean addAll(Collection extends E> c); public void
clear(); public boolean contains(Object o); public boolean containsAll(Collection> c); public
boolean isEmpty(); public boolean remove(Object o); public boolean removeAll(Collection> c);
public boolean retainAll(Collection> c); public int size(); public Object[] toArray(); public T[]
toArray(T[] arr); */ //abstract method public void add(int index, E e); public E get(int index);
public int indexOf(Object e); public int lastIndexOf(E e); public E remove(int index); public E
set(int index, E e); //default method @Override public default boolean add(E e){ add(size(), e);
return true; } @Override public default boolean isEmpty(){ return size()==0; } @Override
public default boolean remove(Object e){ if(indexOf(e) >= 0){ remove(indexOf(e)); return true;
} else{ return false; } } @Override public default boolean containsAll(Collection> c){
for(Object e : c){ if(!contains(e)){ return false; } } return true; } @Override public default
boolean addAll( Collection extends E> c){ for(E e : c){ add(e); } return true; } /* removeAll:
this[1,1,2,3] c[1,2,4] this.removeAll(c) [3] */ @Override public default boolean removeAll(
Collection> c){ for(Object e : c){ while(contains(e)){ this.remove(e); } } return true; } /*
retainAll this[1,1,2,3] c[1,2,4] this.retainAll(c) [1,1,2] */ @Override public default boolean
retainAll( Collection> c){ for(E e : this){ if(!c.contains(e)){ this.remove(e); } } return true; }
@Override public default Object[] toArray(){ Object[] results = new Object[size()]; int i = 0;
for(E e : this){ results[i++] = e; } return results; } /* T[] array */ @Override public default T[]
toArray(T[] array){ int i = 0; for(E e : this){ array[i++] = (T)e; } return array; } } class
TwoWayLinkedList implements MyList { //inner static class Node public class Node { E
element; Node next; Node previous; public Node(E e){ element = e; } } private Node head, tail;
private int size = 0; public TwoWayLinkedList(){ /* head = null; tail = null; size = 0; */ } public
TwoWayLinkedList(E[] objects){ } public E getFirst(){ return null; } public E getLast(){ return
null; } public void addFirst(E e){ } public void addLast(E e){ } public E removeFirst(){ return
null; } public E removeLast(){ return null; } @Override public void add(int index, E e){ }
@Override public E remove(int index){ return null; } @Override public void clear(){ }
@Override public boolean contains(Object e){ return false; } @Override public E get(int index){
return null; } @Override public int indexOf(Object e){ return -1; } @Override public int
lastIndexOf(Object e){ return -1; } @Override public E set(int index, E e){ return null; }
@Override public int size(){ return size; } //toString() @Override public String.
File LinkedList.java Defines a doubly-l.pdf
File LinkedList.java Defines a doubly-l.pdfConint29 File: LinkedList.java
/**
* Defines a doubly-linked list class
*/
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() {
}
/**
* 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 ****/
/**
* Returns the value stored in the first node
* @precondition
* @return the value stored at node first
* @throws NoSuchElementException
*/
public T getFirst() throws NoSuchElementException {
return null;
}
/**
* Returns the value stored in the last node
* @precondition
* @return the value stored in the node last
* @throws NoSuchElementException
*/
public T getLast() throws NoSuchElementException {
return null;
}
/**
* Returns the data stored in the iterator node
* @precondition
* @return the data stored in the iterator node
* @throw NullPointerException
*/
public T getIterator() throws NullPointerException {
return null;
}
/**
* Returns the current length of the LinkedList
* @return the length of the LinkedList from 0 to n
*/
public int getLength() {
return -1;
}
/**
* Returns whether the LinkedList is currently empty
* @return whether the LinkedList is empty
*/
public boolean isEmpty() {
return false;
}
/**
* Returns whether the iterator is offEnd, i.e. null
* @return whether the iterator is null
*/
public boolean offEnd() {
return false;
}
/**** MUTATORS ****/
/**
* Creates a new first element
* @param data the data to insert at the front of the LinkedList
* @postcondition
*/
public void addFirst(T data) {
return;
}
/**
* Creates a new last element
* @param data the data to insert at the end of the LinkedList
* @postcondition
*/
public void addLast(T data) {
return;
}
/**
* Inserts a new element after the iterator
* @param data the data to insert
* @precondition
* @throws NullPointerException
*/
public void addIterator(T data) throws NullPointerException{
return;
}
/**
* removes the element at the front of the LinkedList
* @precondition
* @postcondition
* @throws NoSuchElementException
*/
public void removeFirst() throws NoSuchElementException {
return;
}
/**
* removes the element at the end of the LinkedList
* @precondition
* @postcondition
* @throws NoSuchElementException
*/
public void removeLast() throws NoSuchElementException {
return;
}
/**
* removes the element referenced by the iterator
* @precondition
* @pos.
Please complete all the code as per instructions in Java programming.docx
Please complete all the code as per instructions in Java programming.docxcgraciela1 Please complete all the code as per instructions in Java programming import org.w3c.dom.Node; import javax.xml.crypto.NodeSetData; import java.awt.*; import java.util.Iterator; import java.util.NoSuchElementException; /** * This class implements an acyclic (non-cyclic), doubly-linked list. * @param */ public class CiscDoublyLinkedList implements CiscList { /** * A reference to the first node in the list (or null if list is empty). */ private Node head; /** * A reference to the last node int the list (or null if list is empty). */ private Node tail; /** * Number of elements in the list. */ private int size; /** * 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() { if (size == 0){ return true; } return false; } /** * Returns {@code true} if this list contains the specified element (compared using the {@code equals} method). * * * @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(); } Node node = head; while(node != null) { if(node.data.equals(o)){ return true; } node = node.next; } return false; } /** * Returns the index of the first occurrence of the specified element in this list, or -1 if this list does not * contain the element (compared using the {@code equals} method). * * * @param o element to search for * @return the index of the first occurrence of the specified element in this list, or -1 if this list does not * contain the element * @throws NullPointerException if the specified element is null */ @Override public int indexOf(Object o) { if (o == null){ throw new NullPointerException(); } for(int i =0; i = size){ throw new IndexOutOfBoundsException(); } return null; } /** * Appends the specified element to the end of this list. * * *
Lists may place the specified element at arbitrary locations if desired. In particular, an ordered list will * insert the specified element at its sorted location. List classes should clearly specify in their documentation * how elements will be added to the list if different from the default behavior (end of this list). * * @param e element to be appended to this list * @return {@code true} * @throws NullPointerException if the specified element is null */ @Override public boolean add(E e) { if(e == null){ throw new NullPointerException(); } return false; } /** * Replaces the element at the specified position in this list with the specified element. * * * @param index index of the element to replace * @param element element to be stored at the specified position * @return the element previously at the specified position *.
Implement the interface you wrote for Lab B (EntryWayListInterface)..pdf
Implement the interface you wrote for Lab B (EntryWayListInterface)..pdfrishabjain5053 This document describes implementing an EntryWayListInterface using either an array or linked nodes. It provides the interface methods that must be implemented which include insertHead, insertTail, deleteHead, deleteTail, display, contains, isEmpty, and isFull. It also describes creating a driver program to test the implementation by adding and removing elements from the list and checking for elements. A second class is to implement the interface using an AList or LList object instead of an array or linked nodes.
Please help me to make a programming project I have to sue them today- (1).pdf
Please help me to make a programming project I have to sue them today- (1).pdfseoagam1 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.
Implementation The starter code includes List.java. You should not c.pdf
Implementation The starter code includes List.java. You should not c.pdfmaheshkumar12354 Implementation The starter code includes List.java. You should not change anything in List.java.
Your task will be to create LinkedList.java, make LinkedList use generics and inherit from List,
and complete several methods in LinkedList.java. Create LinkedList.java in IntelliJ. Add a main
method to LinkedList.java containing the following code. Your program will not compile again.
public static void main(String[] args) { LinkedList list = new LinkedList();
System.out.println(list.getHead()); System.out.println(list.getTail()); list.add("first");
list.add("middle"); list.add("last"); System.out.println(list.getHead().value);
System.out.println(list.getTail().value); System.out.println(list); } The first issue is that your
LinkedList class does not have a way of specifying what type of data it should store. You can fix
this using Java Generics. Change the first line of your class to the following: LinkedList .
Confirm that the first line in your main method no longer has an error. On the line that declares
the LinkedList class, add extends List before the bracket that begins the class. The first line in
your class will now have a compile error because LinkedList does not implement the methods
required by the List abstract class. Press Ctrl-i to have IntelliJ insert stubs of these methods.
Ensure that Copy JavaDoc is selected so you get JavaDoc comments which describe the method
requirements, then click OK. Your code should now compile again. Next add fields for the head
and tail. These will be of type Node. Create a getHead method which returns your head field, and
a getTail method which returns your tail field. Run your main method now and you will see that
there is a NullPointerException because the add method does not actually add anything to the
list, so head and tail will always be null. Complete the method boolean add(T value) for which
IntelliJ gave you a stub. You need to create a new node with value to add at the end of the list.
This means you will need to connect it to the old tail and update tail to point to the node you
created. Make sure that you handle the case where the list is empty and both head and tail should
be set to the new node you've created. Note: For the full Map I assignment, add will need to
prevent duplicate values being added to the list and should return true or false based on whether
the value was added or not. For this lab, you can ignore this requirement and simply return true.
Add a toString method to your LinkedList class. It should start at the head of your list and
proceed through all the nodes in a loop, combining the values of each node with a comma
between each and square brackets containing the whole thing. When you run your main method,
the final thing printed should be: [first, middle, last] List.java: /** * Specification for a List
ADT. * @author Shubham Chatterjee * @version 03/07/2019 * @param Type */ public abstract
class List { /** * Appends the specified value to the end of this list. * * @para.
Hi,I have added the methods and main class as per your requirement.pdf
Hi,I have added the methods and main class as per your requirement.pdfannaelctronics Hi,
I have added the methods and main class as per your requirement. it is working fine now.
Highlighted the code changes.
MyLinkedListTest.java
public class MyLinkedListTest {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
MyLinkedList list = new MyLinkedList();
list.addFirst(\"AAAAA\");
list.add(\"1\");
list.add(\"2\");
list.add(\"3\");
list.addLast(\"ZZZZZ\");
System.out.println(\"Linked List Elements : \"+list.toString());
System.out.println(\"First element: \"+list.getFirst());
System.out.println(\"Second element: \"+list.getLast());
System.out.println(\"Removed First Element: \"+list.removeFirst());
System.out.println(\"Now Linked List Elements : \"+list.toString());
System.out.println(\"Removed Last Element: \"+list.removeLast());
System.out.println(\"Now Linked List Elements : \"+list.toString());
System.out.println(\"Removed all element: \");
list.removeAll();
System.out.println(\"Now Linked List Elements : \"+list.toString());
}
}
MyLinkedList.java
public class MyLinkedList extends MyAbstractList {
private Node head, tail;
/** Create a default list */
public MyLinkedList() {
}
/** Create a list from an array of objects */
public MyLinkedList(E[] objects) {
super(objects);
}
/** Return the head element in the list */
public E getFirst() {
if (size == 0) {
return null;
}
else {
return (E)head.element;
}
}
/** Return the last element in the list */
public E getLast() {
if (size == 0) {
return null;
}
else {
return (E)tail.element;
}
}
/** Add an element to the beginning of the list */
public void addFirst(E e) {
Node 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 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 = tail.next; // tail now points to the last node
}
size++; // Increase size
}
/** Add a new element at the specified index in this list
* The index of the head element is 0 */
public void add(int index, E e) {
if (index == 0) {
addFirst(e);
}
else if (index >= size) {
addLast(e);
}
else {
Node current = head;
for (int i = 1; i < index; i++) {
current = current.next;
}
Node temp = current.next;
current.next = new Node(e);
(current.next).next = temp;
size++;
}
}
/** Remove the head node and
* return the object that is contained in 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 (E)temp.element;
}
}
/** Remove all elements from list */
public void removeAll() {
while(true) {
if (size == 0) {
break;
}
else {
Node temp = head;
head =.
please i need help Im writing a program to test the merge sort alg.pdf
please i need help Im writing a program to test the merge sort alg.pdfezonesolutions please i need help I\'m writing a program to test the merge sort algorithm for linked lists.
I need to Print the list before being sorted and the list after sorting the elements
here is my code only help in test program the four classes are ok except the test program.
TEST PROGRAM
import java.io.*;
import java.util.*;
public class Ch9_ProgExercise7 {
Scanner input = new Scanner(System.in);
public static void main(String[] args) throws IOException {
OrderedLinkedList list
= new OrderedLinkedList(); //Line 1
IntElement num = new IntElement(); //Line 2
// Prompt the user to enter some integers
System.out.println(\"Enter integers numbers \");
String temp = input.hasnextLine();
String[] split = temp.split(\" \");
for (int i = 0; i < split.length; i++) {
Integer a = Integer.parseInt(split[i]);
// insert the intgers into the list you created above
num.setNum(a);
list.insertNode(num);
}
System.out.println();
// Print the list before being sorted
// call the mergesort method
System.out.println();
// print the list after sorting the elements
}
}
ORDEREDLICKEDLIST CLASS
public class OrderedLinkedList extends LinkedListClass
{
//default constructor
public OrderedLinkedList()
{
super();
}
//copy constructor
public OrderedLinkedList(OrderedLinkedList otherList)
{
super(otherList);
}
public void linkedInsertionSort()
{
LinkedListNode lastInOrder;
LinkedListNode firstOutOfOrder;
LinkedListNode current;
LinkedListNode trailCurrent;
lastInOrder = first;
if(first == null)
System.out.println(\"Cannot sort an empty list\");
else
if(first.link == null)
System.out.println(\"The list is of length 1. \"
+ \"Already in order\");
else
while(lastInOrder.link != null)
{
firstOutOfOrder = lastInOrder.link;
if(firstOutOfOrder.info.compareTo(first.info) < 0)
{
lastInOrder.link = firstOutOfOrder.link;
firstOutOfOrder.link = first;
first = firstOutOfOrder;
}
else
{
trailCurrent = first;
current = first.link;
while(current.info.compareTo(firstOutOfOrder.info) < 0)
{
trailCurrent = current;
current = current.link;
}
if(current != firstOutOfOrder)
{
lastInOrder.link = firstOutOfOrder.link;
firstOutOfOrder.link = current;
trailCurrent.link = firstOutOfOrder;
}
else
lastInOrder = lastInOrder.link;
}
}
}//end linkedInsertionSort
//Method to determine whether searchItem is in
//the list.
//Postcondition: Returns true if searchItem is found
// in the list; otherwise, it returns
// false.
public boolean search(DataElement searchItem)
{
LinkedListNode current; //variable to traverse the list
boolean found;
current = first; //set current to point to the first
//node in the list
found = false; //set found to false
while(current != null && !found ) //search the list
if(current.info.compareTo(searchItem) >= 0)
found = true;
else
current = current.link; //make current point to
//the next node
if(found)
found = current.info.equals(searchItem);
return found;
}
//Method to insert insertItem in the list
//Postcondition: first points to the new list,
// newItem is inserted at the proper place
//.
Here is the editable codeSolutionimport java.util.NoSuchEleme.pdf
Here is the editable codeSolutionimport java.util.NoSuchEleme.pdfarrowmobile Here is the editable code:
Solution
import java.util.NoSuchElementException;
public class DoublyLinkedListImpl {
private Node head;
private Node tail;
private int size;
public DoublyLinkedListImpl() {
size = 0;
}
private class Node {
E element;
Node next;
Node prev;
public Node(E element, Node next, Node prev) {
this.element = element;
this.next = next;
this.prev = prev;
}
}
public int size() { return size; }
public boolean isEmpty() { return size == 0; }
public void addFirst(E element) {
Node tmp = new Node(element, head, null);
if(head != null ) {head.prev = tmp;}
head = tmp;
if(tail == null) { tail = tmp;}
size++;
System.out.println(\"adding: \"+element);
}
/**
* adds element at the end of the linked list
* @param element
*/
public void addLast(E element) {
Node tmp = new Node(element, null, tail);
if(tail != null) {tail.next = tmp;}
tail = tmp;
if(head == null) { head = tmp;}
size++;
System.out.println(\"adding: \"+element);
}
public void iterateForward(){
System.out.println(\"iterating forward..\");
Node tmp = head;
while(tmp != null){
System.out.println(tmp.element);
tmp = tmp.next;
}
}
/**
* this method walks backward through the linked list
*/
public void iterateBackward(){
System.out.println(\"iterating backword..\");
Node tmp = tail;
while(tmp != null){
System.out.println(tmp.element);
tmp = tmp.prev;
}
}
public E removeFirst() {
if (size == 0) throw new NoSuchElementException();
Node tmp = head;
head = head.next;
head.prev = null;
size--;
System.out.println(\"deleted: \"+tmp.element);
return tmp.element;
}
public E removeLast() {
if (size == 0) throw new NoSuchElementException();
Node tmp = tail;
tail = tail.prev;
tail.next = null;
size--;
System.out.println(\"deleted: \"+tmp.element);
return tmp.element;
}
public static void main(String a[]){
DoublyLinkedListImpl dll = new DoublyLinkedListImpl();
dll.addFirst(10);
dll.addFirst(34);
dll.addLast(56);
dll.addLast(364);
dll.iterateForward();
dll.removeFirst();
dll.removeLast();
dll.iterateBackward();
}
}
import java.util.Scanner;
/* Class Node */
class Node
{
protected int data;
protected Node next, prev;
/* Constructor */
public Node()
{
next = null;
prev = null;
data = 0;
}
/* Constructor */
public Node(int d, Node n, Node p)
{
data = d;
next = n;
prev = p;
}
/* Function to set link to next node */
public void setLinkNext(Node n)
{
next = n;
}
/* Function to set link to previous node */
public void setLinkPrev(Node p)
{
prev = p;
}
/* Funtion to get link to next node */
public Node getLinkNext()
{
return next;
}
/* Function to get link to previous node */
public Node getLinkPrev()
{
return prev;
}
/* Function to set data to node */
public void setData(int d)
{
data = d;
}
/* Function to get data from node */
public int getData()
{
return data;
}
}
/* Class linkedList */
class linkedList
{
protected Node start;
protected Node end ;
public int size;
/* Constructor */
public linkedList()
{
start = null;
end = null;
size = 0;
}
/* Function to check if list is empty */
public boolean isE.
LabProgram.javaimport java.util.NoSuchElementException;public .pdf
LabProgram.javaimport java.util.NoSuchElementException;public .pdffantasiatheoutofthef LabProgram.java
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 ****/
/**
* Returns the value stored in the first node
* @precondition <>
* @return the value stored at node first
* @throws NoSuchElementException <>
*/
public T getFirst() throws NoSuchElementException {
if (isEmpty()){
throw new NoSuchElementException("The list is empty");
}
return first.data;
}
/**
* Returns the value stored in the last node
* @precondition <>
* @return the value stored in the node last
* @throws NoSuchElementException <>
*/
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 {
return iterator.data;
}
/**
* 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 ****/
/**
* Creates a new first element
* @param data the data to insert at the front of the LinkedList
* @postcondition <>
*/
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++;
}
/**
* Creates a new last element
* @param data the data to insert at the end of the LinkedList
* @postcondition <>
*/
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 addIter.
Note- Can someone help me with the private E get(int index- int curren (1).docx
Note- Can someone help me with the private E get(int index- int curren (1).docxVictorzH8Bondx 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 Public boolean add(E value) method.pdf
Note- Can someone help me with the Public boolean add(E value) method.pdfStewart29UReesa 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.
The MyLinkedList class used in Listing 24.6 is a one-way directional .docx
The MyLinkedList class used in Listing 24.6 is a one-way directional .docxKomlin1 The document describes modifying an existing Node class to create a doubly linked list implementation called TwoWayLinkedList. The Node class is updated to include a previous node reference. TwoWayLinkedList extends an existing abstract list class and implements list iterator methods to traverse the list in both directions. It overrides common list methods like add, remove, and size.
Copy your completed LinkedList class from Lab 3 into the LinkedList..pdf
Copy your completed LinkedList class from Lab 3 into the LinkedList..pdffacevenky Copy your completed LinkedList class from Lab 3 into the LinkedList.java file below.
During this lab we will add more constructors, an equals method and more challenging methods
as listed below.
Also inspect the LabProgram.java file and notice that the main() method of the LabProgram
copies and compares two linked lists. The main() method also calls the more challenging
methods. Use Develop mode to test your LinkedList iterator code as you develop it.
In Submit mode you will need to complete all lab steps to pass all automatic tests.
Step 2: Implement clear()
Method clear() re-sets the LinkedList to empty as if the default constructor had just been called.
Constructor LinkedList(T[] array) converts the given array into a LinkedList.
Constructor LinkedList(LinkedList original) instantiates a new LinkedList by copying another
List.
Method equals() determines whether the given Object is another LinkedList, containing the same
data in the same order, returning whether there is equality.
Method spinList(int numMoves) moves all nodes in the list towards the end of the list the
number of times specified. Any node that falls off the end of the list as it moves forward will be
placed at the front of the list.
Method altLists() splices together two LinkedLists to create a third List which contains
alternating values from the original list and the given parameter.
*Below is my Lab3 LinkedList.class.
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) {
}
public T getFirst() throws NoSuchElementException {
if (first == null) throw new NoSuchElementException();
return first.data;
}
public T getLast() throws NoSuchElementException {
if (last == null) throw new NoSuchElementException();
return last.data;
}
public T getIterator() throws NullPointerException {
if (iterator == null) {
throw new NullPointerException("Iterator is off end.");
}
return iterator.data;
}
public int getLength() {
return length;
}
public boolean isEmpty() {
return length == 0;
}
public boolean offEnd() {
return iterator == null;
}
public void addFirst(T data) {
Node newNode = new Node(data);
if (length == 0) {
first = newNode;
last = newNode;
} else .
STAGE 2 The Methods 65 points Implement all the methods t.pdf
STAGE 2 The Methods 65 points Implement all the methods t.pdfbabitasingh698417 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.
import java.util.Iterator; import java.util.NoSuchElementException; .pdf
import java.util.Iterator; import java.util.NoSuchElementException; .pdfdeepakangel 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.
There are a couple of new methods that you will be writing for this pr.pdf
There are a couple of new methods that you will be writing for this pr.pdfaamousnowov There are a couple of new methods that you will be writing for this project. Some are easy, some
are hard. I have provided code that tests most of the methods by calling them from the main
method in the file ListTest.java. The test file will only work when you have done all the
methods. In COMP182LinkedList.java I have provided the signature (definition and input
parameters) for these methods. At this point to make sure you can run the file
(COMP182LinkedList.java that you downloaded from Cavas) I have added template values as
return types of the methods. For example, if the method returns an int then I added return 0 as the
return value. Here are the methods are as follows: Anything getFixst () Anything getLast () void
add (Anything value) void addafter (1nt index, Anyehtng value) Anything set(int index,
Rnything aewvalue) void removeAl1 (Anything vaiue) lastIndex (Anything value)
COMP182IinkedIi ateAnything; elone boolean equala (object in) CoMP182IinkedList
KAnythang? gplat () boolean hascycle () Node reveraeliat () Node oddeventiat () Node
deleteDuplicates () boolean ispalindrome () "For the last two methods, you need to add proper
testing to ListTest Java Method Specifications Here are more details for implementing each of
these methods. You need to complete all the following methods in the COMP182LinkedList
class. You can write the methods in any order you wish, but I suggest you do them in the order
they are listed. In particular, make sure all your methods work for empty lists, lists of different
sizes, etc as you can see from the sample test cases provided in ListTest.java. While grading your
project, we will make changes to these values! Also, make sure that your solutions do not modify
the original lists (unless you are specifically instructed to do so). roid main(String[] args) You
can use this method in the ListTest class to create lists as needed and test each of the methods
listed above. I have provided a few test cases, but you may want to add more to some of the
method tests. Until you get add working, you will need to use addFirst to create lists to test your
other methods. Anything getFirsto This method returns the value stored in the first node an the
list. It should prit an error message and seturn null if the list is empty. Anything getLasto This
method returns the value stored in the last node in the list. It should print an error mesiage and
retuin noll if the list is emipty. void add(Anything value) Thus method adds a nade containing
new yalue to the end of the last. This method returns the value stored in the first node in the list.
It should print an error message and return null if the list is empty. Anything getLast0 This
method returns the value stored in the last node in the list. It should print an error message and
retum null if the list is empty: void add(Anything value) This method adds a node containing
new value to the end of the list. void addAfter(int index, Anything value) This method adds a
node contai.
public class MyLinkedListltE extends ComparableltEgtg.pdf
public class MyLinkedListltE extends ComparableltEgtg.pdfaccostinternational 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..
Solve using java and using this Singly linked list classpublic cl.pdf
Solve using java and using this Singly linked list classpublic cl.pdfaloeplusint Solve using java and using this Singly linked list class:
public class SLL {
private class SLLNode {
private T info;
private SLLNode next;
public SLLNode() {
this(null,null);
}
public SLLNode(T el) {
this(el,null);
}
public SLLNode(T el, SLLNode ptr) {
info = el; next = ptr;
}
}
protected SLLNode head, tail;
public SLL() {
head = tail = null;
}
public boolean isEmpty() {
return head == null;
}
public void addToHead(T el) {
head = new SLLNode(el,head);
if (tail == null)
tail = head;
}
public void addToTail(T el) {
if (!isEmpty()) {
tail.next = new SLLNode(el);
tail = tail.next;
}
else head = tail = new SLLNode(el);
}
public T deleteFromHead() { // delete the head and return its info;
if (isEmpty())
return null;
T el = head.info;
if (head == tail) // if only one node on the list;
head = tail = null;
else head = head.next;
return el;
}
public T deleteFromTail() { // delete the tail and return its info;
if (isEmpty())
return null;
T el = tail.info;
if (head == tail) // if only one node in the list;
head = tail = null;
else { // if more than one node in the list,
SLLNode tmp; // find the predecessor of tail;
for (tmp = head; tmp.next != tail; tmp = tmp.next);
tail = tmp; // the predecessor of tail becomes tail;
tail.next = null;
}
return el;
}
public void delete(T el) { // delete the node with an element el;
if (!isEmpty())
if (head == tail && el.equals(head.info)) // if only one
head = tail = null; // node on the list;
else if (el.equals(head.info)) // if more than one node on the list;
head = head.next; // and el is in the head node;
else { // if more than one node in the list
SLLNode pred, tmp;// and el is in a nonhead node;
for (pred = head, tmp = head.next;
tmp != null && !tmp.info.equals(el);
pred = pred.next, tmp = tmp.next);
if (tmp != null) { // if el was found;
pred.next = tmp.next;
if (tmp == tail) // if el is in the last node;
tail = pred;
}
}
}
@Override
public String toString() {
if(head == null)
return "[ ]";
String str = "[ ";
SLLNode tmp = head;
while(tmp != null){
str += tmp.info + " ";
tmp = tmp.next;
}
return str+"]";
}
public boolean contains(T el) {
if(head == null)
return false;
SLLNode tmp = head;
while(tmp != null){
if(tmp.info.equals(el))
return true;
tmp = tmp.next;
}
return false;
}
public int size(){
if(head == null)
return 0;
int count = 0;
SLLNode p = head;
while(p != null) {
count++;
p = p.next;
}
return count;
}
} The following Questions have to be Solved and Submitted: Part I: Programming ( 50 points)
Use the singly linked list class introduced in the lab to implement integers of unlimited size.
Each node of the list should store one digit of the integer. You are to implement the addition,
subtraction and multiplication operations. Please note that any additional data structure to be
used in solving this problem has to be taken from the ones introduced in the ICS 202 lab. In
addition, provide a test class that will do the following: It will keep asking the user to enter two
integers, choose one of the operations (.
Fix my codeCode.pdf
Fix my codeCode.pdfConint29 The document provides code for a linked list class with methods to add, remove, get, and traverse nodes. It contains comments describing each method and placeholders for some methods to be implemented, including getting the last node, checking if a value is contained, getting a node by position, inserting before a key, and reversing the list. It also includes test cases to validate the linked list functionality.
Class DiagramIn the Assignment #10, you are given three files Ass.pdf
Class DiagramIn the Assignment #10, you are given three files Ass.pdfxlynettalampleyxc Class Diagram:
In the Assignment #10, you are given three files Assignment10.java, LinkedList.java, and
ListIterator.java. You will need to add additional methods in the LinkedList class in the
LinkedList.java file. The LinkedList will be tested using strings only.
Specifically, the following methods must be implemented in the LinkedList class:
(You should utilize listIterator() method already defined in the LinkedList class to obtain its
LinkedListIterator object, and use the methods in the LinkedListIterator class to traverse from
the first element to the last element of the linked list to define the following methods.)
1.
public String toString()
The toString method should concatenate strings in the linked list, and return a string of the
following format:
{ Apple Banana Melon Orange }
Thus it starts with \"{\" and ends with \"}\", and there is a space between strings and \"{\" or
\"}\". If the list is empty, it returns \"{ }\" with a space in between.
2.
public boolean isEmpty()
The isEmpty method returns true of the linked list is empty, false otherwise.
3.
public void addElement(Object element)
The addElement adds the parameter element at the parameter in the linked list in alphabetical
order. For instance, if the linked list contains {Apple, Banana, Grape}, and a user tries to add
\"Carrot\", then it should be added as:
{Apple, Banana, Carrot, Grape}.
4.
public Object removeElement(int index)
The removeElement removes the string (Object) at the parameter index and returns it. Note that
this index starts with 0 just like array indices. For instance, if the linked list contains {Apple,
Banana, Carrot, Grape} and the parameter index is 3, then \"Grape\" should be remove. If the
parameter index is larger or smaller than the existing indices, it should throw an object of the
IndexOutOfBoundsException class (and the content of the linked list should remain unchanged).
5.
public Object getElement(int index)
The getElement searches the string (Object) at the parameter index and returns it. Note that this
index starts with 0 just like array indices. For instance, if the linked list contains {Apple, Banana,
Carrot, Grape} and the parameter index is 3, then \"Grape\" will be returned. If the parameter
index is larger or smaller than the existing indices, it should throw an object of the
IndexOutOfBoundsException class (and the content of the linked list should remain unchanged).
6.
public void searchAndReplace(Object oldString, Object newString)
The searchAndReplace method searches all occurrences of the first parameter string (object) in
the list, and replaces them with the second parameter string (object). If the parameter string does
not exist in the linked list, then the linked list content will not change.
7.
public int indexOfLast(Object searchString)
The indexOfLast searches the parameter string (object) with the largest index, and returns its
index. If the parameter string does not exist in the linked list, then it should return -1.
For i.
Given below is the completed implementation of MyLinkedList class. O.pdf
Given below is the completed implementation of MyLinkedList class. O.pdfinfo430661 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.
How do I fix it in javaLinkedList.java Defines a doubl.pdf
How do I fix it in javaLinkedList.java Defines a doubl.pdffmac5 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.
Note- Can someone help me with the public boolean isEmpty()- public bo.pdf
Note- Can someone help me with the public boolean isEmpty()- public bo.pdfAugstore Note: Can someone help me with the public boolean isEmpty(), public boolean contains(Object
o), public int indexOf(Object o) and public E get(int index)methods using abstract List. package
edu.ust.cisc; import java.util.Iterator; public abstract class CiscAbstractList implements CiscList
{ /** * Returns the number of elements in this list. * * @return the number of elements in this
list */ @Override public int size() { int size = 0; Iterator itr = iterator(); while(itr.hasNext()) {
itr.next(); 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 false; } /** * Returns {@code true} if this list contains the specified element (compared
using the {@code equals} method). * * @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) { return false; } /** * Returns the index of the first occurrence of the specified
element in this list, or -1 if this list does not * contain the element (compared using the {@code
equals} method). * * @param o element to search for * @return the index of the first occurrence
of the specified element in this list, or -1 if this list does not * contain the element * @throws
NullPointerException if the specified element is null */ @Override public int indexOf(Object o)
{ return 0; } /** * Removes all of the elements from this list. The list will be empty after this call
returns. */ @Override public abstract void clear(); /** * Returns the element at the specified
position in this list. * * @param index index of the element to return * @return the element at
the specified position in this list * @throws IndexOutOfBoundsException if the index is out of
range */ @Override public E get(int index) { return null; } /** * Appends the specified element
to the end of this list. * *
Lists may place the specified element at arbitrary locations if desired. In particular, an ordered
list will * insert the specified element at its sorted location. List classes should clearly specify in
their documentation * how elements will be added to the list if different from the default
behavior (end of this list). * * @param e element to be appended to this list * @return {@code
true} * @throws NullPointerException if the specified element is null */ @Override public
boolean add(E e) { return false; } /** * Replaces the element at the specified position in this list
with the specified element (optional operation). * * @param index index of the element to
replace * @param element element to be stored at the specified position * @return the element
previously at the specified position * @throws UnsupportedOperationException if the {@code
set} operation is not supported by this list * @throws NullPointerException if the specified
el.
How do I fix it in LinkedList.javaLabProgram.javaLinkedList.jav.pdf
How do I fix it in LinkedList.javaLabProgram.javaLinkedList.jav.pdfmail931892 How do I fix it in LinkedList.java?
LabProgram.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 NoS.
For each task, submit your source java code file.(1) Objective Im.pdf
For each task, submit your source java code file.(1) Objective Im.pdfdhavalbl38 For each task, submit your source java code file.
(1) Objective: Implement Link List
Write a class that maintains the scores for a game application. Implement the addition and
removal function to update the database. The gamescore.txt contains player’ name and score data
record fields separated by comma. For Removal function, uses the name field to select record to
remove the game score record.
Download – List.java, LList.java, Dlink.java, GameEntry.java, gamescore.txt
(a)Read gamescore.txt to initialize the Linked list in sorted order. (1 point)
(b)Provide Remove and Add function for user to update the sorted linked list. (1 point)
(2)Add a reverse function to the LList.java class to reverse the order of the linked list. (2 points).
---------------------------------------------------------------------------------------------------------------------
-----------------------------------------
//gamescore.txt
Mike,1105
Rob,750
Paul,720
Anna,660
Rose,590
Jack,510
--------------------------------------------------------------------------------------------------------------------
-----------------------------------------------------------------------
//DLink.java
/** Source code example for \"A Practical Introduction to Data
Structures and Algorithm Analysis, 3rd Edition (Java)\"
by Clifford A. Shaffer
Copyright 2008-2011 by Clifford A. Shaffer
*/
/** Doubly linked list node */
class DLink {
private E element; // Value for this node
private DLink next; // Pointer to next node in list
private DLink prev; // Pointer to previous node
/** Constructors */
DLink(E it, DLink p, DLink n)
{ element = it; prev = p; next = n; }
DLink(DLink p, DLink n) { prev = p; next = n; }
/** Get and set methods for the data members */
DLink next() { return next; }
DLink setNext(DLink nextval)
{ return next = nextval; }
DLink prev() { return prev; }
DLink setPrev(DLink prevval)
{ return prev = prevval; }
E element() { return element; }
E setElement(E it) { return element = it; }
}
--------------------------------------------------------------------------------------------------------------------
---------------------------------------------------------------------
//GameEntry.java
public class GameEntry {
protected String name;
protected int score;
public GameEntry(String n, int s) {
name = n;
score = s;
}
public String getName() {return name;}
public int getScore() {return score;}
public String toString() {
return \"(\"+name+\",\"+score+\")\";
}
}
--------------------------------------------------------------------------------------------------------------------
----------------------------------
//List.java
/** Source code example for \"A Practical Introduction to Data
Structures and Algorithm Analysis, 3rd Edition (Java)\"
by Clifford A. Shaffer
Copyright 2008-2011 by Clifford A. Shaffer
*/
/** List ADT */
public interface List {
/** Remove all contents from the list, so it is once again
empty. Client is responsible for reclaiming storage
used by the list elements. */
p.
Required is a project that seeks to develop a program that check.pdf
Required is a project that seeks to develop a program that check.pdfclimatecontrolsv Required is a project that seeks to develop a program that checks whether the input
string is a palindrome or not. The input can be any number or a string character, or
even a phrase. What makes it interesting is that we are devising two options to
choose from, and each of which desires a completely different treatment of input
string entries:
a. First, input read is treated as word(s) input which simply reverses the input
text and further determines if that's a palindrome or not. The code for this
part would be provided with required Ul to simplify the problem. See Image as
shown in Figure 1, below.
Next, the second part is where we consider input as a number and treat it as
such. Now, this brings in a plethora of programming terms and concepts in
seek of an effective solution. Your task is to generate the code that will input
a number and then employ various tools and structures learnt in this course,
to determine whether input number is a palindrome or not. The list of
programming tools may include, but are not limited to selection, Iteration,
modulo operator, division, multiplication, etc.
b.
1.1 Project 2: Palindrome Mini-Project [55]
Follow the instructions below and have the program ready for grading in class on
Tuesday 10 Oct, 2023 in HP3. A partially completed code snippet is available below.
Also, a fully completed code of the entire program in Word format must be uploaded
for submission on link (Proj2_Submission) available on Moodle.
1. Before you begin creating the application, it is always helpful to plan ahead.
Create a MS Word file and design an appropriate Plan Chart as necessary.
Name your word file as StudentNumber_Palindrome.
[6]
ii. Also, use both the pseudocode and flowchart as an added aide in planning
and preparing for your solution. MS Word, Visio tools or other alternatives
may prove suitable candidate applications for both pseudocode and flowchart
design.
[8]
iii.
Set Tab Order in which each control receives the focus when the user either
presses the Tab key or employs an access key during run time. [5]
Set access keys as necessary and should appear with underscores
on the UI.
[2]
Code each of the (radio) options under separate blocks, whether be it
independent Sub procedures or Function procedures but have them referred
to under two different (method) calls.
[8]
vi. Use an event-handling Sub procedure to perform the following list
of tasks:
iv.
V.
[4]
1. clear the label showing result message when there is change in the input
text box selects all
2. input characters available when input box receives Tab focus.
vii. Use code-level Options to ensure that all variables in your code have been
declare, that every variable is declared is with a data type, and lastly that a
variable may not be enforced by the expression type and be demoted to a
lesser data type or data type with less precision.
viii. Use comments as a necessary when coding in order to internally document
[6]
your program. Also,
1/4.
Question 1A Python list isset of items.an unorderedan ordere.pdf
Question 1A Python list isset of items.an unorderedan ordere.pdfclimatecontrolsv Question 1
A Python list is
set of items.
an unordered
an ordered
a limited
an integer
Question 2
Which is a valid Python statement?
alist = [1; 4; 9; 16]
alist = 1: 2: 3: 4]
alist = [1, 4, 9, 16]
Question 3
A Python list's items can be any Python type.
True
False
Question 4
If squares = [1, 4, 9, 16], what is the value of squares(1] ?
an error
1
4
5
Question 5
If squares = [1, 4, 9, 16, 25], what is len(squares)?
4
55
5
1
Question 6
The following statement is valid:
alist = [ ]
True
False
Question 7
What is the output of the following program:
alist = []
for i in range(3):
alist.append(i**2)
print(alist)
[1, 4, 16]
[ ]
[0,1,4]
9
Question 8
What is the output of the following:
alist = [1, 4, 9]
sum = 0
for value in alist:
sum += value
print(sum)
[1, 5, 14]
0
14
[1, 4, 9]
Question 9
If squares = [1, 4, 9, 16, 25], what is the value of squares[1:3] ?
[4,91
[4, 9, 16]
[1,4]
[1, 4, 9]
Question 10
If squares = [1, 4, 9, 16, 25], what is the value of squares[:3] ?
[1, 4, 9, 16]
an error
[1, 4, 9]
Question 11
If squares = [1, 4, 9, 16, 25], what is the value of squares[2:]?
[4,9, 16, 25]
an error
[1. 41
[9, 16, 25]
Question 12
If squares = [1, 4, 9, 16, 25], what is the value of squares[0::2] ?
[1, 4]
an error
[1, 9, 25]
[1, 4, 9]
Question 13
What function can be used to determine the smallest value in a list?
smallest()
min()
least()
minimum()
Question 14
Which keyword is used to determine if a value is in a list?
contains
in
has
within
Question 15
Assuming alist is a list of 4 items, what does this statement do:
alist[11 = 2
Insert two items into the list at position 1
Change alist's second item to 2
Change alist's first item to 2
Insert an item in a list at position 1 with value 2
Question 16
Which statement can be used to insert an item into a list named alist?
alist.insert(item, O)
insert(alist, item)
alist.insert(O, item)
alist <- item
Question 17
What method can be used to append a list to the end of another list?
augment()
extend()
concatenate()
add()
Question 18
Assuming the list squares is set to [1, 4, 9, 16], what statement can be
used to remove the value 1 from the list
del alist.0
alist.remove(1)
remove(alist, 1)
remove(alist, O)
Ouestion 19
Assuming alist is a list with 4 items, what statement can be used to
remove the last item from alist and assignment the variable last to its
value?
last = alist.pop()
last = alist.drop()
last = alist[-1]
last = alist[0]
Question 20
What statement can be used to remove all items from a list named alist?
delete alist
alist.clear()
del alist
clear(alist)
Question 21
What statement can be used to remove the first item from a list named
alist?
remove(alist, 0)
alist.remove(O)
del alist[O]
del(alist, O)
Question 22
If alist is a list, what method can be used to create a new list with a copy
of the items contained in alist?
blist = alist.dup()
blist = alist
copy(alist, blist)
blist = alist.copy()
Question 23
If alist is a list, what does sorted(alist) do?
generates a new ordered list
checks if alist is so.
More Related Content
Similar to PROBLEM STATEMENTIn this assignment, you will complete DoubleEnde.pdf (20)
Hi,I have added the methods and main class as per your requirement.pdf
Hi,I have added the methods and main class as per your requirement.pdfannaelctronics Hi,
I have added the methods and main class as per your requirement. it is working fine now.
Highlighted the code changes.
MyLinkedListTest.java
public class MyLinkedListTest {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
MyLinkedList list = new MyLinkedList();
list.addFirst(\"AAAAA\");
list.add(\"1\");
list.add(\"2\");
list.add(\"3\");
list.addLast(\"ZZZZZ\");
System.out.println(\"Linked List Elements : \"+list.toString());
System.out.println(\"First element: \"+list.getFirst());
System.out.println(\"Second element: \"+list.getLast());
System.out.println(\"Removed First Element: \"+list.removeFirst());
System.out.println(\"Now Linked List Elements : \"+list.toString());
System.out.println(\"Removed Last Element: \"+list.removeLast());
System.out.println(\"Now Linked List Elements : \"+list.toString());
System.out.println(\"Removed all element: \");
list.removeAll();
System.out.println(\"Now Linked List Elements : \"+list.toString());
}
}
MyLinkedList.java
public class MyLinkedList extends MyAbstractList {
private Node head, tail;
/** Create a default list */
public MyLinkedList() {
}
/** Create a list from an array of objects */
public MyLinkedList(E[] objects) {
super(objects);
}
/** Return the head element in the list */
public E getFirst() {
if (size == 0) {
return null;
}
else {
return (E)head.element;
}
}
/** Return the last element in the list */
public E getLast() {
if (size == 0) {
return null;
}
else {
return (E)tail.element;
}
}
/** Add an element to the beginning of the list */
public void addFirst(E e) {
Node 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 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 = tail.next; // tail now points to the last node
}
size++; // Increase size
}
/** Add a new element at the specified index in this list
* The index of the head element is 0 */
public void add(int index, E e) {
if (index == 0) {
addFirst(e);
}
else if (index >= size) {
addLast(e);
}
else {
Node current = head;
for (int i = 1; i < index; i++) {
current = current.next;
}
Node temp = current.next;
current.next = new Node(e);
(current.next).next = temp;
size++;
}
}
/** Remove the head node and
* return the object that is contained in 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 (E)temp.element;
}
}
/** Remove all elements from list */
public void removeAll() {
while(true) {
if (size == 0) {
break;
}
else {
Node temp = head;
head =.
please i need help Im writing a program to test the merge sort alg.pdf
please i need help Im writing a program to test the merge sort alg.pdfezonesolutions please i need help I\'m writing a program to test the merge sort algorithm for linked lists.
I need to Print the list before being sorted and the list after sorting the elements
here is my code only help in test program the four classes are ok except the test program.
TEST PROGRAM
import java.io.*;
import java.util.*;
public class Ch9_ProgExercise7 {
Scanner input = new Scanner(System.in);
public static void main(String[] args) throws IOException {
OrderedLinkedList list
= new OrderedLinkedList(); //Line 1
IntElement num = new IntElement(); //Line 2
// Prompt the user to enter some integers
System.out.println(\"Enter integers numbers \");
String temp = input.hasnextLine();
String[] split = temp.split(\" \");
for (int i = 0; i < split.length; i++) {
Integer a = Integer.parseInt(split[i]);
// insert the intgers into the list you created above
num.setNum(a);
list.insertNode(num);
}
System.out.println();
// Print the list before being sorted
// call the mergesort method
System.out.println();
// print the list after sorting the elements
}
}
ORDEREDLICKEDLIST CLASS
public class OrderedLinkedList extends LinkedListClass
{
//default constructor
public OrderedLinkedList()
{
super();
}
//copy constructor
public OrderedLinkedList(OrderedLinkedList otherList)
{
super(otherList);
}
public void linkedInsertionSort()
{
LinkedListNode lastInOrder;
LinkedListNode firstOutOfOrder;
LinkedListNode current;
LinkedListNode trailCurrent;
lastInOrder = first;
if(first == null)
System.out.println(\"Cannot sort an empty list\");
else
if(first.link == null)
System.out.println(\"The list is of length 1. \"
+ \"Already in order\");
else
while(lastInOrder.link != null)
{
firstOutOfOrder = lastInOrder.link;
if(firstOutOfOrder.info.compareTo(first.info) < 0)
{
lastInOrder.link = firstOutOfOrder.link;
firstOutOfOrder.link = first;
first = firstOutOfOrder;
}
else
{
trailCurrent = first;
current = first.link;
while(current.info.compareTo(firstOutOfOrder.info) < 0)
{
trailCurrent = current;
current = current.link;
}
if(current != firstOutOfOrder)
{
lastInOrder.link = firstOutOfOrder.link;
firstOutOfOrder.link = current;
trailCurrent.link = firstOutOfOrder;
}
else
lastInOrder = lastInOrder.link;
}
}
}//end linkedInsertionSort
//Method to determine whether searchItem is in
//the list.
//Postcondition: Returns true if searchItem is found
// in the list; otherwise, it returns
// false.
public boolean search(DataElement searchItem)
{
LinkedListNode current; //variable to traverse the list
boolean found;
current = first; //set current to point to the first
//node in the list
found = false; //set found to false
while(current != null && !found ) //search the list
if(current.info.compareTo(searchItem) >= 0)
found = true;
else
current = current.link; //make current point to
//the next node
if(found)
found = current.info.equals(searchItem);
return found;
}
//Method to insert insertItem in the list
//Postcondition: first points to the new list,
// newItem is inserted at the proper place
//.
Here is the editable codeSolutionimport java.util.NoSuchEleme.pdf
Here is the editable codeSolutionimport java.util.NoSuchEleme.pdfarrowmobile Here is the editable code:
Solution
import java.util.NoSuchElementException;
public class DoublyLinkedListImpl {
private Node head;
private Node tail;
private int size;
public DoublyLinkedListImpl() {
size = 0;
}
private class Node {
E element;
Node next;
Node prev;
public Node(E element, Node next, Node prev) {
this.element = element;
this.next = next;
this.prev = prev;
}
}
public int size() { return size; }
public boolean isEmpty() { return size == 0; }
public void addFirst(E element) {
Node tmp = new Node(element, head, null);
if(head != null ) {head.prev = tmp;}
head = tmp;
if(tail == null) { tail = tmp;}
size++;
System.out.println(\"adding: \"+element);
}
/**
* adds element at the end of the linked list
* @param element
*/
public void addLast(E element) {
Node tmp = new Node(element, null, tail);
if(tail != null) {tail.next = tmp;}
tail = tmp;
if(head == null) { head = tmp;}
size++;
System.out.println(\"adding: \"+element);
}
public void iterateForward(){
System.out.println(\"iterating forward..\");
Node tmp = head;
while(tmp != null){
System.out.println(tmp.element);
tmp = tmp.next;
}
}
/**
* this method walks backward through the linked list
*/
public void iterateBackward(){
System.out.println(\"iterating backword..\");
Node tmp = tail;
while(tmp != null){
System.out.println(tmp.element);
tmp = tmp.prev;
}
}
public E removeFirst() {
if (size == 0) throw new NoSuchElementException();
Node tmp = head;
head = head.next;
head.prev = null;
size--;
System.out.println(\"deleted: \"+tmp.element);
return tmp.element;
}
public E removeLast() {
if (size == 0) throw new NoSuchElementException();
Node tmp = tail;
tail = tail.prev;
tail.next = null;
size--;
System.out.println(\"deleted: \"+tmp.element);
return tmp.element;
}
public static void main(String a[]){
DoublyLinkedListImpl dll = new DoublyLinkedListImpl();
dll.addFirst(10);
dll.addFirst(34);
dll.addLast(56);
dll.addLast(364);
dll.iterateForward();
dll.removeFirst();
dll.removeLast();
dll.iterateBackward();
}
}
import java.util.Scanner;
/* Class Node */
class Node
{
protected int data;
protected Node next, prev;
/* Constructor */
public Node()
{
next = null;
prev = null;
data = 0;
}
/* Constructor */
public Node(int d, Node n, Node p)
{
data = d;
next = n;
prev = p;
}
/* Function to set link to next node */
public void setLinkNext(Node n)
{
next = n;
}
/* Function to set link to previous node */
public void setLinkPrev(Node p)
{
prev = p;
}
/* Funtion to get link to next node */
public Node getLinkNext()
{
return next;
}
/* Function to get link to previous node */
public Node getLinkPrev()
{
return prev;
}
/* Function to set data to node */
public void setData(int d)
{
data = d;
}
/* Function to get data from node */
public int getData()
{
return data;
}
}
/* Class linkedList */
class linkedList
{
protected Node start;
protected Node end ;
public int size;
/* Constructor */
public linkedList()
{
start = null;
end = null;
size = 0;
}
/* Function to check if list is empty */
public boolean isE.
LabProgram.javaimport java.util.NoSuchElementException;public .pdf
LabProgram.javaimport java.util.NoSuchElementException;public .pdffantasiatheoutofthef LabProgram.java
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 ****/
/**
* Returns the value stored in the first node
* @precondition <>
* @return the value stored at node first
* @throws NoSuchElementException <>
*/
public T getFirst() throws NoSuchElementException {
if (isEmpty()){
throw new NoSuchElementException("The list is empty");
}
return first.data;
}
/**
* Returns the value stored in the last node
* @precondition <>
* @return the value stored in the node last
* @throws NoSuchElementException <>
*/
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 {
return iterator.data;
}
/**
* 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 ****/
/**
* Creates a new first element
* @param data the data to insert at the front of the LinkedList
* @postcondition <>
*/
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++;
}
/**
* Creates a new last element
* @param data the data to insert at the end of the LinkedList
* @postcondition <>
*/
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 addIter.
Note- Can someone help me with the private E get(int index- int curren (1).docx
Note- Can someone help me with the private E get(int index- int curren (1).docxVictorzH8Bondx 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 Public boolean add(E value) method.pdf
Note- Can someone help me with the Public boolean add(E value) method.pdfStewart29UReesa 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.
The MyLinkedList class used in Listing 24.6 is a one-way directional .docx
The MyLinkedList class used in Listing 24.6 is a one-way directional .docxKomlin1 The document describes modifying an existing Node class to create a doubly linked list implementation called TwoWayLinkedList. The Node class is updated to include a previous node reference. TwoWayLinkedList extends an existing abstract list class and implements list iterator methods to traverse the list in both directions. It overrides common list methods like add, remove, and size.
Copy your completed LinkedList class from Lab 3 into the LinkedList..pdf
Copy your completed LinkedList class from Lab 3 into the LinkedList..pdffacevenky Copy your completed LinkedList class from Lab 3 into the LinkedList.java file below.
During this lab we will add more constructors, an equals method and more challenging methods
as listed below.
Also inspect the LabProgram.java file and notice that the main() method of the LabProgram
copies and compares two linked lists. The main() method also calls the more challenging
methods. Use Develop mode to test your LinkedList iterator code as you develop it.
In Submit mode you will need to complete all lab steps to pass all automatic tests.
Step 2: Implement clear()
Method clear() re-sets the LinkedList to empty as if the default constructor had just been called.
Constructor LinkedList(T[] array) converts the given array into a LinkedList.
Constructor LinkedList(LinkedList original) instantiates a new LinkedList by copying another
List.
Method equals() determines whether the given Object is another LinkedList, containing the same
data in the same order, returning whether there is equality.
Method spinList(int numMoves) moves all nodes in the list towards the end of the list the
number of times specified. Any node that falls off the end of the list as it moves forward will be
placed at the front of the list.
Method altLists() splices together two LinkedLists to create a third List which contains
alternating values from the original list and the given parameter.
*Below is my Lab3 LinkedList.class.
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) {
}
public T getFirst() throws NoSuchElementException {
if (first == null) throw new NoSuchElementException();
return first.data;
}
public T getLast() throws NoSuchElementException {
if (last == null) throw new NoSuchElementException();
return last.data;
}
public T getIterator() throws NullPointerException {
if (iterator == null) {
throw new NullPointerException("Iterator is off end.");
}
return iterator.data;
}
public int getLength() {
return length;
}
public boolean isEmpty() {
return length == 0;
}
public boolean offEnd() {
return iterator == null;
}
public void addFirst(T data) {
Node newNode = new Node(data);
if (length == 0) {
first = newNode;
last = newNode;
} else .
STAGE 2 The Methods 65 points Implement all the methods t.pdf
STAGE 2 The Methods 65 points Implement all the methods t.pdfbabitasingh698417 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.
import java.util.Iterator; import java.util.NoSuchElementException; .pdf
import java.util.Iterator; import java.util.NoSuchElementException; .pdfdeepakangel 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.
There are a couple of new methods that you will be writing for this pr.pdf
There are a couple of new methods that you will be writing for this pr.pdfaamousnowov There are a couple of new methods that you will be writing for this project. Some are easy, some
are hard. I have provided code that tests most of the methods by calling them from the main
method in the file ListTest.java. The test file will only work when you have done all the
methods. In COMP182LinkedList.java I have provided the signature (definition and input
parameters) for these methods. At this point to make sure you can run the file
(COMP182LinkedList.java that you downloaded from Cavas) I have added template values as
return types of the methods. For example, if the method returns an int then I added return 0 as the
return value. Here are the methods are as follows: Anything getFixst () Anything getLast () void
add (Anything value) void addafter (1nt index, Anyehtng value) Anything set(int index,
Rnything aewvalue) void removeAl1 (Anything vaiue) lastIndex (Anything value)
COMP182IinkedIi ateAnything; elone boolean equala (object in) CoMP182IinkedList
KAnythang? gplat () boolean hascycle () Node reveraeliat () Node oddeventiat () Node
deleteDuplicates () boolean ispalindrome () "For the last two methods, you need to add proper
testing to ListTest Java Method Specifications Here are more details for implementing each of
these methods. You need to complete all the following methods in the COMP182LinkedList
class. You can write the methods in any order you wish, but I suggest you do them in the order
they are listed. In particular, make sure all your methods work for empty lists, lists of different
sizes, etc as you can see from the sample test cases provided in ListTest.java. While grading your
project, we will make changes to these values! Also, make sure that your solutions do not modify
the original lists (unless you are specifically instructed to do so). roid main(String[] args) You
can use this method in the ListTest class to create lists as needed and test each of the methods
listed above. I have provided a few test cases, but you may want to add more to some of the
method tests. Until you get add working, you will need to use addFirst to create lists to test your
other methods. Anything getFirsto This method returns the value stored in the first node an the
list. It should prit an error message and seturn null if the list is empty. Anything getLasto This
method returns the value stored in the last node in the list. It should print an error mesiage and
retuin noll if the list is emipty. void add(Anything value) Thus method adds a nade containing
new yalue to the end of the last. This method returns the value stored in the first node in the list.
It should print an error message and return null if the list is empty. Anything getLast0 This
method returns the value stored in the last node in the list. It should print an error message and
retum null if the list is empty: void add(Anything value) This method adds a node containing
new value to the end of the list. void addAfter(int index, Anything value) This method adds a
node contai.
public class MyLinkedListltE extends ComparableltEgtg.pdf
public class MyLinkedListltE extends ComparableltEgtg.pdfaccostinternational 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..
Solve using java and using this Singly linked list classpublic cl.pdf
Solve using java and using this Singly linked list classpublic cl.pdfaloeplusint Solve using java and using this Singly linked list class:
public class SLL {
private class SLLNode {
private T info;
private SLLNode next;
public SLLNode() {
this(null,null);
}
public SLLNode(T el) {
this(el,null);
}
public SLLNode(T el, SLLNode ptr) {
info = el; next = ptr;
}
}
protected SLLNode head, tail;
public SLL() {
head = tail = null;
}
public boolean isEmpty() {
return head == null;
}
public void addToHead(T el) {
head = new SLLNode(el,head);
if (tail == null)
tail = head;
}
public void addToTail(T el) {
if (!isEmpty()) {
tail.next = new SLLNode(el);
tail = tail.next;
}
else head = tail = new SLLNode(el);
}
public T deleteFromHead() { // delete the head and return its info;
if (isEmpty())
return null;
T el = head.info;
if (head == tail) // if only one node on the list;
head = tail = null;
else head = head.next;
return el;
}
public T deleteFromTail() { // delete the tail and return its info;
if (isEmpty())
return null;
T el = tail.info;
if (head == tail) // if only one node in the list;
head = tail = null;
else { // if more than one node in the list,
SLLNode tmp; // find the predecessor of tail;
for (tmp = head; tmp.next != tail; tmp = tmp.next);
tail = tmp; // the predecessor of tail becomes tail;
tail.next = null;
}
return el;
}
public void delete(T el) { // delete the node with an element el;
if (!isEmpty())
if (head == tail && el.equals(head.info)) // if only one
head = tail = null; // node on the list;
else if (el.equals(head.info)) // if more than one node on the list;
head = head.next; // and el is in the head node;
else { // if more than one node in the list
SLLNode pred, tmp;// and el is in a nonhead node;
for (pred = head, tmp = head.next;
tmp != null && !tmp.info.equals(el);
pred = pred.next, tmp = tmp.next);
if (tmp != null) { // if el was found;
pred.next = tmp.next;
if (tmp == tail) // if el is in the last node;
tail = pred;
}
}
}
@Override
public String toString() {
if(head == null)
return "[ ]";
String str = "[ ";
SLLNode tmp = head;
while(tmp != null){
str += tmp.info + " ";
tmp = tmp.next;
}
return str+"]";
}
public boolean contains(T el) {
if(head == null)
return false;
SLLNode tmp = head;
while(tmp != null){
if(tmp.info.equals(el))
return true;
tmp = tmp.next;
}
return false;
}
public int size(){
if(head == null)
return 0;
int count = 0;
SLLNode p = head;
while(p != null) {
count++;
p = p.next;
}
return count;
}
} The following Questions have to be Solved and Submitted: Part I: Programming ( 50 points)
Use the singly linked list class introduced in the lab to implement integers of unlimited size.
Each node of the list should store one digit of the integer. You are to implement the addition,
subtraction and multiplication operations. Please note that any additional data structure to be
used in solving this problem has to be taken from the ones introduced in the ICS 202 lab. In
addition, provide a test class that will do the following: It will keep asking the user to enter two
integers, choose one of the operations (.
Fix my codeCode.pdf
Fix my codeCode.pdfConint29 The document provides code for a linked list class with methods to add, remove, get, and traverse nodes. It contains comments describing each method and placeholders for some methods to be implemented, including getting the last node, checking if a value is contained, getting a node by position, inserting before a key, and reversing the list. It also includes test cases to validate the linked list functionality.
Class DiagramIn the Assignment #10, you are given three files Ass.pdf
Class DiagramIn the Assignment #10, you are given three files Ass.pdfxlynettalampleyxc Class Diagram:
In the Assignment #10, you are given three files Assignment10.java, LinkedList.java, and
ListIterator.java. You will need to add additional methods in the LinkedList class in the
LinkedList.java file. The LinkedList will be tested using strings only.
Specifically, the following methods must be implemented in the LinkedList class:
(You should utilize listIterator() method already defined in the LinkedList class to obtain its
LinkedListIterator object, and use the methods in the LinkedListIterator class to traverse from
the first element to the last element of the linked list to define the following methods.)
1.
public String toString()
The toString method should concatenate strings in the linked list, and return a string of the
following format:
{ Apple Banana Melon Orange }
Thus it starts with \"{\" and ends with \"}\", and there is a space between strings and \"{\" or
\"}\". If the list is empty, it returns \"{ }\" with a space in between.
2.
public boolean isEmpty()
The isEmpty method returns true of the linked list is empty, false otherwise.
3.
public void addElement(Object element)
The addElement adds the parameter element at the parameter in the linked list in alphabetical
order. For instance, if the linked list contains {Apple, Banana, Grape}, and a user tries to add
\"Carrot\", then it should be added as:
{Apple, Banana, Carrot, Grape}.
4.
public Object removeElement(int index)
The removeElement removes the string (Object) at the parameter index and returns it. Note that
this index starts with 0 just like array indices. For instance, if the linked list contains {Apple,
Banana, Carrot, Grape} and the parameter index is 3, then \"Grape\" should be remove. If the
parameter index is larger or smaller than the existing indices, it should throw an object of the
IndexOutOfBoundsException class (and the content of the linked list should remain unchanged).
5.
public Object getElement(int index)
The getElement searches the string (Object) at the parameter index and returns it. Note that this
index starts with 0 just like array indices. For instance, if the linked list contains {Apple, Banana,
Carrot, Grape} and the parameter index is 3, then \"Grape\" will be returned. If the parameter
index is larger or smaller than the existing indices, it should throw an object of the
IndexOutOfBoundsException class (and the content of the linked list should remain unchanged).
6.
public void searchAndReplace(Object oldString, Object newString)
The searchAndReplace method searches all occurrences of the first parameter string (object) in
the list, and replaces them with the second parameter string (object). If the parameter string does
not exist in the linked list, then the linked list content will not change.
7.
public int indexOfLast(Object searchString)
The indexOfLast searches the parameter string (object) with the largest index, and returns its
index. If the parameter string does not exist in the linked list, then it should return -1.
For i.
Given below is the completed implementation of MyLinkedList class. O.pdf
Given below is the completed implementation of MyLinkedList class. O.pdfinfo430661 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.
How do I fix it in javaLinkedList.java Defines a doubl.pdf
How do I fix it in javaLinkedList.java Defines a doubl.pdffmac5 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.
Note- Can someone help me with the public boolean isEmpty()- public bo.pdf
Note- Can someone help me with the public boolean isEmpty()- public bo.pdfAugstore Note: Can someone help me with the public boolean isEmpty(), public boolean contains(Object
o), public int indexOf(Object o) and public E get(int index)methods using abstract List. package
edu.ust.cisc; import java.util.Iterator; public abstract class CiscAbstractList implements CiscList
{ /** * Returns the number of elements in this list. * * @return the number of elements in this
list */ @Override public int size() { int size = 0; Iterator itr = iterator(); while(itr.hasNext()) {
itr.next(); 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 false; } /** * Returns {@code true} if this list contains the specified element (compared
using the {@code equals} method). * * @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) { return false; } /** * Returns the index of the first occurrence of the specified
element in this list, or -1 if this list does not * contain the element (compared using the {@code
equals} method). * * @param o element to search for * @return the index of the first occurrence
of the specified element in this list, or -1 if this list does not * contain the element * @throws
NullPointerException if the specified element is null */ @Override public int indexOf(Object o)
{ return 0; } /** * Removes all of the elements from this list. The list will be empty after this call
returns. */ @Override public abstract void clear(); /** * Returns the element at the specified
position in this list. * * @param index index of the element to return * @return the element at
the specified position in this list * @throws IndexOutOfBoundsException if the index is out of
range */ @Override public E get(int index) { return null; } /** * Appends the specified element
to the end of this list. * *
Lists may place the specified element at arbitrary locations if desired. In particular, an ordered
list will * insert the specified element at its sorted location. List classes should clearly specify in
their documentation * how elements will be added to the list if different from the default
behavior (end of this list). * * @param e element to be appended to this list * @return {@code
true} * @throws NullPointerException if the specified element is null */ @Override public
boolean add(E e) { return false; } /** * Replaces the element at the specified position in this list
with the specified element (optional operation). * * @param index index of the element to
replace * @param element element to be stored at the specified position * @return the element
previously at the specified position * @throws UnsupportedOperationException if the {@code
set} operation is not supported by this list * @throws NullPointerException if the specified
el.
How do I fix it in LinkedList.javaLabProgram.javaLinkedList.jav.pdf
How do I fix it in LinkedList.javaLabProgram.javaLinkedList.jav.pdfmail931892 How do I fix it in LinkedList.java?
LabProgram.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 NoS.
For each task, submit your source java code file.(1) Objective Im.pdf
For each task, submit your source java code file.(1) Objective Im.pdfdhavalbl38 For each task, submit your source java code file.
(1) Objective: Implement Link List
Write a class that maintains the scores for a game application. Implement the addition and
removal function to update the database. The gamescore.txt contains player’ name and score data
record fields separated by comma. For Removal function, uses the name field to select record to
remove the game score record.
Download – List.java, LList.java, Dlink.java, GameEntry.java, gamescore.txt
(a)Read gamescore.txt to initialize the Linked list in sorted order. (1 point)
(b)Provide Remove and Add function for user to update the sorted linked list. (1 point)
(2)Add a reverse function to the LList.java class to reverse the order of the linked list. (2 points).
---------------------------------------------------------------------------------------------------------------------
-----------------------------------------
//gamescore.txt
Mike,1105
Rob,750
Paul,720
Anna,660
Rose,590
Jack,510
--------------------------------------------------------------------------------------------------------------------
-----------------------------------------------------------------------
//DLink.java
/** Source code example for \"A Practical Introduction to Data
Structures and Algorithm Analysis, 3rd Edition (Java)\"
by Clifford A. Shaffer
Copyright 2008-2011 by Clifford A. Shaffer
*/
/** Doubly linked list node */
class DLink {
private E element; // Value for this node
private DLink next; // Pointer to next node in list
private DLink prev; // Pointer to previous node
/** Constructors */
DLink(E it, DLink p, DLink n)
{ element = it; prev = p; next = n; }
DLink(DLink p, DLink n) { prev = p; next = n; }
/** Get and set methods for the data members */
DLink next() { return next; }
DLink setNext(DLink nextval)
{ return next = nextval; }
DLink prev() { return prev; }
DLink setPrev(DLink prevval)
{ return prev = prevval; }
E element() { return element; }
E setElement(E it) { return element = it; }
}
--------------------------------------------------------------------------------------------------------------------
---------------------------------------------------------------------
//GameEntry.java
public class GameEntry {
protected String name;
protected int score;
public GameEntry(String n, int s) {
name = n;
score = s;
}
public String getName() {return name;}
public int getScore() {return score;}
public String toString() {
return \"(\"+name+\",\"+score+\")\";
}
}
--------------------------------------------------------------------------------------------------------------------
----------------------------------
//List.java
/** Source code example for \"A Practical Introduction to Data
Structures and Algorithm Analysis, 3rd Edition (Java)\"
by Clifford A. Shaffer
Copyright 2008-2011 by Clifford A. Shaffer
*/
/** List ADT */
public interface List {
/** Remove all contents from the list, so it is once again
empty. Client is responsible for reclaiming storage
used by the list elements. */
p.
More from climatecontrolsv (11)
Required is a project that seeks to develop a program that check.pdf
Required is a project that seeks to develop a program that check.pdfclimatecontrolsv Required is a project that seeks to develop a program that checks whether the input
string is a palindrome or not. The input can be any number or a string character, or
even a phrase. What makes it interesting is that we are devising two options to
choose from, and each of which desires a completely different treatment of input
string entries:
a. First, input read is treated as word(s) input which simply reverses the input
text and further determines if that's a palindrome or not. The code for this
part would be provided with required Ul to simplify the problem. See Image as
shown in Figure 1, below.
Next, the second part is where we consider input as a number and treat it as
such. Now, this brings in a plethora of programming terms and concepts in
seek of an effective solution. Your task is to generate the code that will input
a number and then employ various tools and structures learnt in this course,
to determine whether input number is a palindrome or not. The list of
programming tools may include, but are not limited to selection, Iteration,
modulo operator, division, multiplication, etc.
b.
1.1 Project 2: Palindrome Mini-Project [55]
Follow the instructions below and have the program ready for grading in class on
Tuesday 10 Oct, 2023 in HP3. A partially completed code snippet is available below.
Also, a fully completed code of the entire program in Word format must be uploaded
for submission on link (Proj2_Submission) available on Moodle.
1. Before you begin creating the application, it is always helpful to plan ahead.
Create a MS Word file and design an appropriate Plan Chart as necessary.
Name your word file as StudentNumber_Palindrome.
[6]
ii. Also, use both the pseudocode and flowchart as an added aide in planning
and preparing for your solution. MS Word, Visio tools or other alternatives
may prove suitable candidate applications for both pseudocode and flowchart
design.
[8]
iii.
Set Tab Order in which each control receives the focus when the user either
presses the Tab key or employs an access key during run time. [5]
Set access keys as necessary and should appear with underscores
on the UI.
[2]
Code each of the (radio) options under separate blocks, whether be it
independent Sub procedures or Function procedures but have them referred
to under two different (method) calls.
[8]
vi. Use an event-handling Sub procedure to perform the following list
of tasks:
iv.
V.
[4]
1. clear the label showing result message when there is change in the input
text box selects all
2. input characters available when input box receives Tab focus.
vii. Use code-level Options to ensure that all variables in your code have been
declare, that every variable is declared is with a data type, and lastly that a
variable may not be enforced by the expression type and be demoted to a
lesser data type or data type with less precision.
viii. Use comments as a necessary when coding in order to internally document
[6]
your program. Also,
1/4.
Question 1A Python list isset of items.an unorderedan ordere.pdf
Question 1A Python list isset of items.an unorderedan ordere.pdfclimatecontrolsv Question 1
A Python list is
set of items.
an unordered
an ordered
a limited
an integer
Question 2
Which is a valid Python statement?
alist = [1; 4; 9; 16]
alist = 1: 2: 3: 4]
alist = [1, 4, 9, 16]
Question 3
A Python list's items can be any Python type.
True
False
Question 4
If squares = [1, 4, 9, 16], what is the value of squares(1] ?
an error
1
4
5
Question 5
If squares = [1, 4, 9, 16, 25], what is len(squares)?
4
55
5
1
Question 6
The following statement is valid:
alist = [ ]
True
False
Question 7
What is the output of the following program:
alist = []
for i in range(3):
alist.append(i**2)
print(alist)
[1, 4, 16]
[ ]
[0,1,4]
9
Question 8
What is the output of the following:
alist = [1, 4, 9]
sum = 0
for value in alist:
sum += value
print(sum)
[1, 5, 14]
0
14
[1, 4, 9]
Question 9
If squares = [1, 4, 9, 16, 25], what is the value of squares[1:3] ?
[4,91
[4, 9, 16]
[1,4]
[1, 4, 9]
Question 10
If squares = [1, 4, 9, 16, 25], what is the value of squares[:3] ?
[1, 4, 9, 16]
an error
[1, 4, 9]
Question 11
If squares = [1, 4, 9, 16, 25], what is the value of squares[2:]?
[4,9, 16, 25]
an error
[1. 41
[9, 16, 25]
Question 12
If squares = [1, 4, 9, 16, 25], what is the value of squares[0::2] ?
[1, 4]
an error
[1, 9, 25]
[1, 4, 9]
Question 13
What function can be used to determine the smallest value in a list?
smallest()
min()
least()
minimum()
Question 14
Which keyword is used to determine if a value is in a list?
contains
in
has
within
Question 15
Assuming alist is a list of 4 items, what does this statement do:
alist[11 = 2
Insert two items into the list at position 1
Change alist's second item to 2
Change alist's first item to 2
Insert an item in a list at position 1 with value 2
Question 16
Which statement can be used to insert an item into a list named alist?
alist.insert(item, O)
insert(alist, item)
alist.insert(O, item)
alist <- item
Question 17
What method can be used to append a list to the end of another list?
augment()
extend()
concatenate()
add()
Question 18
Assuming the list squares is set to [1, 4, 9, 16], what statement can be
used to remove the value 1 from the list
del alist.0
alist.remove(1)
remove(alist, 1)
remove(alist, O)
Ouestion 19
Assuming alist is a list with 4 items, what statement can be used to
remove the last item from alist and assignment the variable last to its
value?
last = alist.pop()
last = alist.drop()
last = alist[-1]
last = alist[0]
Question 20
What statement can be used to remove all items from a list named alist?
delete alist
alist.clear()
del alist
clear(alist)
Question 21
What statement can be used to remove the first item from a list named
alist?
remove(alist, 0)
alist.remove(O)
del alist[O]
del(alist, O)
Question 22
If alist is a list, what method can be used to create a new list with a copy
of the items contained in alist?
blist = alist.dup()
blist = alist
copy(alist, blist)
blist = alist.copy()
Question 23
If alist is a list, what does sorted(alist) do?
generates a new ordered list
checks if alist is so.
Question 1A Python list is ��.. set of items.an unorderedan or.pdf
Question 1A Python list is ��.. set of items.an unorderedan or.pdfclimatecontrolsv Question 1
A Python list is .. set of items.
an unordered
an ordered
a limited
an integer
Question 2
Which is a valid Python statement?
alist = [1; 4; 9; 16]
alist = 1: 2: 3: 4]
alist = [1, 4, 9, 16]
Question 3
A Python list's items can be any Python type.
True
False
Question 4
If squares = [1, 4, 9, 16], what is the value of squares(1] ?
an error
1
4
5
Question 5
If squares = [1, 4, 9, 16, 25], what is len(squares)?
4
55
5
1
Question 6
The following statement is valid:
alist = [ ]
True
False
Question 7
What is the output of the following program:
alist = []
for i in range(3):
alist.append(i**2)
print(alist)
[1, 4, 16]
[ ]
[0,1,4]
9
Question 8
What is the output of the following:
alist = [1, 4, 9]
sum = 0
for value in alist:
sum += value
print(sum)
[1, 5, 14]
0
14
[1, 4, 9]
Question 9
If squares = [1, 4, 9, 16, 25], what is the value of squares[1:3] ?
[4,91
[4, 9, 16]
[1,4]
[1, 4, 9]
Question 10
If squares = [1, 4, 9, 16, 25], what is the value of squares[:3] ?
[1, 4, 9, 16]
an error
[1, 4, 9]
Question 11
If squares = [1, 4, 9, 16, 25], what is the value of squares[2:]?
[4,9, 16, 25]
an error
[1. 41
[9, 16, 25]
Question 12
If squares = [1, 4, 9, 16, 25], what is the value of squares[0::2] ?
[1, 4]
an error
[1, 9, 25]
[1, 4, 9]
Question 13
What function can be used to determine the smallest value in a list?
smallest()
min()
least()
minimum()
Question 14
Which keyword is used to determine if a value is in a list?
contains
in
has
within
Question 15
Assuming alist is a list of 4 items, what does this statement do:
alist[11 = 2
Insert two items into the list at position 1
Change alist's second item to 2
Change alist's first item to 2
Insert an item in a list at position 1 with value 2
Question 16
Which statement can be used to insert an item into a list named alist?
alist.insert(item, O)
insert(alist, item)
alist.insert(O, item)
alist <- item
Question 17
What method can be used to append a list to the end of another list?
augment()
extend()
concatenate()
add()
Question 18
Assuming the list squares is set to [1, 4, 9, 16], what statement can be
used to remove the value 1 from the list
del alist.0
alist.remove(1)
remove(alist, 1)
remove(alist, O)
Ouestion 19
Assuming alist is a list with 4 items, what statement can be used to
remove the last item from alist and assignment the variable last to its
value?
last = alist.pop()
last = alist.drop()
last = alist[-1]
last = alist[0]
Question 20
What statement can be used to remove all items from a list named alist?
delete alist
alist.clear()
del alist
clear(alist)
Question 21
What statement can be used to remove the first item from a list named
alist?
remove(alist, 0)
alist.remove(O)
del alist[O]
del(alist, O)
Question 22
If alist is a list, what method can be used to create a new list with a copy
of the items contained in alist?
blist = alist.dup()
blist = alist
copy(alist, blist)
blist = alist.copy()
Question 23
If alist is a list, what does sorted(alist) do?
generates a new ordered list
checks if alist is.
Principles of Insurance Chapter 3 Exercise 1 Name of student Regist.pdf
Principles of Insurance Chapter 3 Exercise 1 Name of student Regist.pdfclimatecontrolsv Principles of Insurance Chapter 3 Exercise 1 Name of student: Registration Number: Question 1:
Partnership form of business is riskier than corporations for owners. Explain. Question 2. What
is double taxation? How companies differ from partnership firms in terms of taxation? Question
3. Why United States introduced "LLP" and "LLC"? Question 4. How did Ernest and Young
manage its risk of unlimited liability? Principles of Insurance Chapter 3 Exercise 1 Name of
student: Registration Number: Question 1: Partnership form of business is riskier than
corporations for owners. Explain. Question 2. What is double taxation? How companies differ
from partnership firms in terms of taxation? Question 3. Why United States introduced "LLP"
and "LLC"? Question 4. How did Ernest and Young manage its risk of unlimited liability?
For many newly hired gradastes in the prefessional services from acsounting to law, a traditionel
carect posl is to becoese a purtacr is the firm. a peomotion that recognizes professional
achievement and eamo bigh compensation. In tecent years. however, the tille of partnet bas come
with some additional rikk iscludies the rik of locient one's pervonal asets througth an adverse
lepal fodemech apaisat the partoeribip Two or more people who want to form a butiosw sopether
traditiveally have bad two options for of canit. ine their fira a partinerulip and a corporation. of
the two. corpocations typically reyaire moee administra tive effor to start, but they provide an
advantape that partnerahipe do not limited liakility peotection. As this chapter esplaina, the
dostrine of limoted liability means that busiocss claimants, soch as credelors of the firm of
plaintits suine the firm, seacrally do not have a lepal right to attach to the perional assets of the
eweners of the firm Although the ounen of small corporations fane advene las rules compured to
partnernhipn (aritic ace tbas the en ners of small couperatioas afe -double tascd," hecene
cocporate income is taxes at the cotporate tax rase and then the ewasen pay an additional
pernomal tax os the dividetedn that they receive st compteatsere of the cosporale tusinew foem
Many prolesional serviot firms, inclading Lw firms ascounting firms, medtral prassiocs,
archinestural farmed as partaentipe. Unlike the eveners at cotpo ration, partencrie ane enalle to
peotest their personal the partnenhip ate invufficient to mest ifs daimanty evodk, a daimast can
atach to the periesal avects of the partnes. Moecover, if a slaimast is filies a sisable Lawiuit, a
partacr's issponikiday for damages catends severe harm to a pationt during a surpal prosedure,
the injured patient cas altach to act oely the askets of the doctior who pesformed the uureery, but
aleo the ofber ploxicians in the practices. In the face of increasing fitigation ridk is the United
States in the 190k, the ewners of many partaerships called for reform. As a twselt, top aew
organirationa! forme wete ereated the limited liahility partnernaip .
Please use R studiodata13.txtX Y7.04948502035051 4.37962324700.pdf
Please use R studiodata13.txtX Y7.04948502035051 4.37962324700.pdfclimatecontrolsv Please use R studio
data13.txt
X Y
7.04948502035051 4.37962324700581
13.8476196680892 7.50565180245216
32.816097590358 10.0906847942093
82.4841389807196 18.4011989585016
4.06756013069971 3.05176165487089
80.7104026056357 20.6187246034129
89.2411363114593 19.9685665861328
43.6653722555489 14.5812171939798
39.5784480230802 13.1585589147171
0.381754321829103 3.75898953013042
4.24255255049477 3.16588681706255
3.11722868635849 2.83866795503906
47.2000391829763 15.8888802909681
14.7535666345618 6.70602983430919
59.2655811945394 15.0857572845682
24.7704535572201 9.36477294754139
51.4976323403655 13.8723808624657
98.3877700961859 19.4194519421448
14.4426737607694 8.34198608558862
60.4421072152984 15.2829087029915
87.367386905675 17.9351684289468
4.5004449336163 6.25740866340878
42.4678697404552 12.7116062088973
1.57640821218556 2.24176712416127
7.14068857951894 5.1941272627303
14.9084092460861 8.79128131145153
0.0179301022106213 0.157460056988418
14.6220549712186 7.59130788419988
75.6362167129986 16.3713261962759
11.5837439546311 6.32057452538413
23.2401237732567 9.73184297007248
35.9479179017668 11.1079747791123
24.3583021763509 10.6680704299263
3.46769950752827 1.44676090554071
68.454660834274 17.0073031633244
44.6847780069539 11.0646600285409
63.0816956366883 15.4333330242755
1.16518263698174 1.36645266108961
52.3757533418442 13.4960767497831
16.9146656478608 8.14014342609944
67.3952817822558 13.5473867437971
41.8686894426279 14.7060788444263
61.2983710266141 13.1611965914704
data14.txt
X Y
2.44797277031466 1.87133704058055
0.706790471449494 NA
0.994661601725966 0.613624281240899
3.1627170718275 2.79740546743333
5.18634263193235 3.07258608043281
6.62005076417699 3.34117662766835
4.06830187188461 3.30764866293332
9.12875924259424 4.34685737645568
2.93603372760117 2.34821140526844
4.59065726259723 3.28162141299968
3.32394674187526 2.82445170976827
6.5087046707049 3.4768584626158
2.58016780717298 2.91023870346689
4.78545248275623 3.03123150226124
7.66310670645908 3.63173119016247
0.842469143681228 1.21175033915041
8.75321330036968 4.22110579227622
3.39072937844321 3.20053532326632
8.39440350187942 4.11673542453233
3.4668348915875 2.76028404178087
3.33774930797517 2.56120464096791
4.76351245073602 3.00433414218895
8.92198335845023 4.21804192421478
8.64339470630512 4.29747004888405
3.89989543473348 3.30343130433272
7.77320698834956 4.13370325916662
9.60617997217923 4.58521782927905
4.34659484773874 2.61652528425399
7.12514678714797 3.96561936264387
3.99994368897751 2.88613488656473
3.25352151878178 2.07513083778474
7.57087148027495 3.99039810977828
2.02692255144939 1.95338506081744
7.11121222469956 4.05207421172834
1.21691921027377 1.13345287557117
2.45488513959572 2.06505511991777
1.4330437942408 1.21528734973069
2.39629415096715 2.12765889178211
0.589343772735447 1.33480530966145
6.42288258532062 3.42755640521959
8.76269212691113 4.33254474942784
7.78914677444845 3.71027888027844
7.9730882588774 3.79133220630205
4.55274453619495 3.35666882975612
4.10.
Please help me what is the best answer for this. (Organizational Beh.pdf
Please help me what is the best answer for this. (Organizational Beh.pdfclimatecontrolsv Please help me what is the best answer for this. (Organizational Behaviour) 1. John feels like he
is always "at work" because he can be reached on his mobile device at any time and he is always
taking work home. His employer should: A) give him a raise. B) tell him how much it
appreciates his hard work. C) upgrade his personal technology. D) tell him to stop complaining
since everyone else is working hard too. E) help him to attain work-life balance. 2. The most
important reason why managers need to know how to measure personality is that research has
shown that personality tests... A) are useful in hiring decisions. B) are biased against minorities
C) can avoid stereotyping. D) can lead to a reduction in perceptual errors. E) screen out people
with Machiavellian tendencies. 3. Kyle does not like to work with people of a particular ethnicity
even before he has met them. Kyle is exhibiting... A) selective perception. B) stereotyping. C)
projection. D) heredity. E) prejudice. 4. You are a supervisor for a small retail store and have
decided to apply the Big Five Personality Model to try and understand your subordinates and
their wor habits. You have determined that Brian is an extravert and Jim is not conscientious.
Brian will likely... A) be shy and reserved. B) perform well as a salesman because of his ability
to be outgoing. C) be unassertive and not do well as a salesman. D) be quite comfortable with
solitude and individual work. E) be able to work well under pressure, as long as he is working as
an individual and not as part of a team.
5. Organizational commitment refers to the degree to which... A) employees and employers are
both committed to each other. B) employers are committed to maintaining the membership of
their employees. C) employers are committed to their employees. D) employees identify with the
organization they work for and its goals. E) employees identify with the organization's purpose.
6. If an employee's attitude is negative toward his or her job, that employee likely does not
have... A) job satisfaction. B) shared values. C) organizational commitment. D) job commitment.
E) continuance commitment. 7. Tina really cares about the work she does and strongly identifies
with her position and responsibilities. This is an example of... A) affective commitment. B)
continuance commitment. C) core self-evaluation. D) organizational citizenship behaviour. E)
job involvement. 8. An individual's involvement with, satisfaction with, and enthusiasm for the
work he or she does is the concept of... A) psychological empowerment. B) employee
engagement. C) loyalty. D) humane orientation. E) normative commitment.
9. Attitudes are evaluative statements about objects, people, or events. Attitudes in the workplace
are important because they... A) predict differences in employee values. B) show differences in
job experience. C) determine the need for training. D) affect job behaviour. E) show personalities
or employees. 10. A team is... A) peop.
Please help this code is supposed to evaluate current node state and i.pdf
Please help this code is supposed to evaluate current node state and i.pdfclimatecontrolsv Please help this code is supposed to evaluate current node state and if its not the goal state create
children nodes. It is then supposed evaluate which node has the shortest manhattan distance and
then select it as the current node import sys import heapq import copy class PriorityQueue():
def __init__(self): self.thisQueue = [] def push(self, thisNode):
heapq.heappush(self.thisQueue, (thisNode.val, -thisNode.id, thisNode)) def pop(self):
return heapq.heappop(self.thisQueue)[2] def isEmpty(self): return len(self.thisQueue) == 0
def length(self): return len(self.thisQueue) class Set(): def __init__(self): self.thisSet
= set() def add(self, entry): if entry is not None: self.thisSet.add(entry.__hash__())
def length(self): return len(self.thisSet) def isMember(self, query): return
query.__hash__() in self.thisSet class Node(): def __init__(self, val, startstate, endstate, depth,
cost): global nodeid self.id = nodeid nodeid += 1 self.val = val self.state =
startstate self.endstate = endstate self.depth = 0 self.cost = cost def __str__(self):
return 'Node: id=%d val=%d' % (self.id, self.val) class State(): def __init__(self):
self.xpos = 0 self.ypos = 0 self.tiles = [[0, 1, 2], [3, 4, 5], [6, 7, 8]] self.cost=
cost def left(self): if self.ypos == 0: return None s = self.copy()
s.tiles[s.xpos][s.ypos] = s.tiles[s.xpos][s.ypos - 1] s.ypos -= 1 s.tiles[s.xpos][s.ypos]
= 0 return s def right(self): if self.ypos == 2: return None s =
self.copy() s.tiles[s.xpos][s.ypos] = s.tiles[s.xpos][s.ypos + 1] s.ypos += 1
s.tiles[s.xpos][s.ypos] = 0 return s def up(self): if self.xpos == 0:
return None s = self.copy() s.tiles[s.xpos][s.ypos] = s.tiles[s.xpos - 1][s.ypos]
s.xpos -= 1 s.tiles[s.xpos][s.ypos] = 0 return s def down(self): if
self.xpos == 2: return None s = self.copy() s.tiles[s.xpos][s.ypos] =
s.tiles[s.xpos + 1][s.ypos] s.xpos += 1 s.tiles[s.xpos][s.ypos] = 0 return s
def __hash__(self): return (tuple(self.tiles[0]),tuple(self.tiles[1]),tuple(self.tiles[2]))
def __str__(self): return '%d %d %d\n%d %d %d\n%d %d %d\n'%(
self.tiles[0][0],self.tiles[0][1],self.tiles[0][2],
self.tiles[1][0],self.tiles[1][1],self.tiles[1][2],
self.tiles[2][0],self.tiles[2][1],self.tiles[2][2]) def copy(self): s = copy.deepcopy(self)
return s def __eq__(self, other): if other is None: return False
return self.tiles == other.tiles class State(): def __init__(self): self.xpos = 0
self.ypos = 0 self.tiles = [[0, 1, 2], [3, 4, 5], [6, 7, 8]] self.cost= 0 def
left(self): if self.ypos == 0: return None s = self.copy()
s.tiles[s.xpos][s.ypos] = s.tiles[s.xpos][s.ypos - 1] s.ypos -= 1 s.tiles[s.xpos][s.ypos]
= 0 return s def right(self): if self.ypos == 2: return None s =
self.copy() s.tiles[s.xpos][s.ypos] = s.tiles[s.xpos][s.ypos + 1] s.ypos += 1
s.tiles[s.xpos][s.ypos] = 0 return s def up(self): if self.xpos == 0:
return None s = self.copy() s.tiles[s.xpos][s.ypos] = s.tiles[s.xpos - 1][s.ypos]
s.xpos -= 1 s.tiles[s.xpos][s.ypos] = 0 return s def down(self): if
self.xpos == 2: .
Please IRAC this brief. Terrance and Barbara Moser were married on O.pdf
Please IRAC this brief. Terrance and Barbara Moser were married on O.pdfclimatecontrolsv Please IRAC this brief. Terrance and Barbara Moser were married on October 11, 1980. Over the
next 16 years, they had two children, Shannon and Joshua, and accumulated assets in excess of
\$2 million. On December 31, 1996, Terrance and Barbara signed a document creating the Moser
Family Limited Partnership. A family limited partnership is an estate planning device designed
to minimize tax liabilities. The Moser Family Limited Partnership was set up with Terrance, as
trustee of a revocable trust holding his assets, as general partner; Barbara, as trustee of a
revocable trust holding her assets, as a limited partner; and Shannon and Joshua as limited
partners, with Barbara as their custodian. Typically, a family partnership is funded with assets
having a high potential for appreciation. Parents will then give to their children a certain number
of units or a percentage interest in the limited partnership, without tax liability, taking advantage
of the gift tax exclusion. At the time the Moser Family Limited Partnership was created, the
annual gift tax exclusion was $10,000. In order to function properly as an estate planning device,
the gifts of partnership interest to the children had to be completed, irrevocable gifts. In this way,
wealth could be transferred to children during the parents' lifetime, thus avoiding estate taxes,
while the parents would be able to maintain a certain amount of control of the wealth, by virtue
of the general partner's control of the partnership. After its creation, the Moser Family Limited
Partnership, in conjunction with Moser Construction and other business entities previously
owned and operated by the Mosers, successfully oversaw several land development ventures.
Unfortunately, Terrance and Barbara had marital problems. On January 17, 2003, Barbara filed
for divorce. In addition to naming Terrance as a defendant, she also named the Moser Family
Limited Partnership as an additional defendant, arguing that its assets were part of the marital
estate and that she should receive a portion of the limited partnership's assets. The trial court
agreed with Barbara. The court determined the total value of the marital estate to be $3,778,764,
of which $1,507,663 represented the net value of the Moser Family Limited Partnership.
Terrance appealed the decision to an Ohio appellate court.
Grendell, Judge Terrance raises two arguments. The first is that the trial court erred by
invalidating the gifts of partnership interest to the Moser children. The second is that the trial
court erred by treating partnership assets as marital property. As any initial assets of the
Partnership were marital, Terrance and Barbara were deemed to be equal partners, i.e., 50
percent owners of the partnership shares. The trial court found that transfers of interest in the
Moser Family Limited Partnership to the Moser children did not occur on December 31, 1996,
and January 1, 1997, as purported in the federal gift tax returns. Leslie D. Smeach is.
Please help me fix this code! will upvote. The code needs to produce .pdf
Please help me fix this code! will upvote. The code needs to produce .pdfclimatecontrolsv Please help me fix this code! will upvote. The code needs to produce nodes for the current state.
and when the current state isnt the goal state, its supposed to create child nodes and pick the node
with the smallest manhattan distance and make that the next node in the list. Then print all of the
states of the board until the goal state class PriorityQueue(): def __init__(self):
self.thisQueue = [] def push(self, thisNode): heapq.heappush(self.thisQueue,
(thisNode.val, -thisNode.id, thisNode)) def pop(self): return
heapq.heappop(self.thisQueue)[2] def isEmpty(self): return len(self.thisQueue) == 0 def
length(self): return len(self.thisQueue) class Set(): def __init__(self): self.thisSet =
set() def add(self, entry): if entry is not None: self.thisSet.add(entry.__hash__())
def length(self): return len(self.thisSet) def isMember(self, query): return
query.__hash__() in self.thisSet class Node(): def __init__(self, val, startstate, endstate, depth,
cost): global nodeid self.id = nodeid nodeid += 1 self.val = val self.state =
startstate self.endstate = endstate self.depth = 0 self.cost = cost def __str__(self):
return 'Node: id=%d val=%d' % (self.id, self.val) class State(): def __init__(self):
self.xpos = 0 self.ypos = 0 self.tiles = [[0, 1, 2], [3, 4, 5], [6, 7, 8]] self.cost=
cost def left(self): if self.ypos == 0: return None s = self.copy()
s.tiles[s.xpos][s.ypos] = s.tiles[s.xpos][s.ypos - 1] s.ypos -= 1 s.tiles[s.xpos][s.ypos]
= 0 return s def right(self): if self.ypos == 2: return None s =
self.copy() s.tiles[s.xpos][s.ypos] = s.tiles[s.xpos][s.ypos + 1] s.ypos += 1
s.tiles[s.xpos][s.ypos] = 0 return s def up(self): if self.xpos == 0:
return None s = self.copy() s.tiles[s.xpos][s.ypos] = s.tiles[s.xpos - 1][s.ypos]
s.xpos -= 1 s.tiles[s.xpos][s.ypos] = 0 return s def down(self): if
self.xpos == 2: return None s = self.copy() s.tiles[s.xpos][s.ypos] =
s.tiles[s.xpos + 1][s.ypos] s.xpos += 1 s.tiles[s.xpos][s.ypos] = 0 return s
def __hash__(self): return (tuple(self.tiles[0]),tuple(self.tiles[1]),tuple(self.tiles[2]))
def __str__(self): return '%d %d %d\n%d %d %d\n%d %d %d\n'%(
self.tiles[0][0],self.tiles[0][1],self.tiles[0][2],
self.tiles[1][0],self.tiles[1][1],self.tiles[1][2],
self.tiles[2][0],self.tiles[2][1],self.tiles[2][2]) def copy(self): s = copy.deepcopy(self)
return s def __eq__(self, other): if other is None: return False
return self.tiles == other.tiles class State(): def __init__(self): self.xpos = 0
self.ypos = 0 self.tiles = [[0, 1, 2], [3, 4, 5], [6, 7, 8]] self.cost= 0 def left(self):
if self.ypos == 0: return None s = self.copy() s.tiles[s.xpos][s.ypos]
= s.tiles[s.xpos][s.ypos - 1] s.ypos -= 1 s.tiles[s.xpos][s.ypos] = 0 return s
def right(self): if self.ypos == 2: return None s = self.copy()
s.tiles[s.xpos][s.ypos] = s.tiles[s.xpos][s.ypos + 1] s.ypos += 1
s.tiles[s.xpos][s.ypos] = 0 return s def up(self): if self.xpos == 0:
return None s = self.copy() s.tiles[s.xpos][s.ypos] = s.tiles[s.xpos - 1][s.ypos]
s.xpos -= 1 s.
PART 1Net present value represents the difference between the pres.pdf
PART 1Net present value represents the difference between the pres.pdfclimatecontrolsv PART 1
Net present value represents the difference between the present value of cash inflows and
outflows (Gallant, 2023). A positive NPV means that an investment is worth investing in, NPV
of zero would indicate that the investment would be balanced between the cash inflows and
outflows, if the NPV is negative than the investment would not be worth investing in. The
internal rate of return or IRR is used by companies to estimate how much profit would the
investment generate over time. NPV and IRR can help a company make smarter decisions and
reduce risk when it comes to investing.
What are things/scenarios that would greatly affect the NPV & IRR? and why? Please be very
detailed. Thanks
PART 2
Net present value (NPV) is the difference between the present value of cash inflows and the
present value of cash outflows over a period of time. NPV is used in Capital budget and
investment planning to analyze the profitability of a projected investment or project.
It is essential to understand the different risk and factors that are taken into countability when it
comes to the investments being done. Starting off with how differential risk that can be
incorporated into NVP analysis. The following would be done by increasing the discount rate for
those different projects that hold a higher risk. This tool will reduce the present value of cash
flows, which means that it increases uncertainty and risk.
Now lets refer to IRR analysis "The internal rate of return (IRR) is a metric used in financial
analysis to estimate the profitability of potential investments. IRR is a discount rate that makes
the NVP of all cash flows equal to zero in a discounted cash flow analysis. Leading to apply that
the riskier the project, the higher IRR less than riskier ones.
What other things are essential to reduce the risk on investments? What steps must be taking to
lower the risk or what things must be considered prior looking into the NVP & IRR? Please be
very detailed. Thanks.
Please create a context diagram of the following housing system Y.pdf
Please create a context diagram of the following housing system Y.pdfclimatecontrolsv Please create a context diagram of the following housing system:
YOUR TURN 4-1 CAMPUS HOUSING Create a set of use cases for the following high-level
requirements in a housing system run by the Campus Housing Service. The Campus Housing
Service helps students find apartments. Owners of apartments fill in information forms about the
rental units they have available (e.g., location, number of bedrooms, monthly rent), which are
entered into a database. Students can search through this database via the Web to find apartments
that meet their needs (e.g., a two-bedroom apartment for $800 or less per month within 1/2 mile
of campus). They then contact the apartment owners directly to see the apartment and possibly
rent it. Apartment owners call the service to delete their listing when they have rented their
apartment(s). In building the major use cases, follow the four-step process: Identify the use
cases, identify the steps within them, identify the elements within the steps, and confirm the use
cases..
Recently uploaded (20)
Post Exam Fun(da)- a General under-25 quiz, Prelims and Finals
Post Exam Fun(da)- a General under-25 quiz, Prelims and FinalsPragya - UEM Kolkata Quiz Club Post Exam Funda is an general u-25 quiz under Pragya, the Official Quiz Club Of UEM Kolkata
Intervene with Precision: Zooming In as a Leader Without Micromanaging
Intervene with Precision: Zooming In as a Leader Without Micromanagingvictoriamangiantini1 Intervene with Precision: Zooming In as a Leader Without Micromanaging
Leveraging AI to Streamline Operations for Nonprofits [05.20.2025].pdf![Leveraging AI to Streamline Operations for Nonprofits [05.20.2025].pdf](https://cdn.slidesharecdn.com/ss_thumbnails/leveragingaitostreamlineoperationsfornonprofits05-250520212021-64a860c5-thumbnail.jpg?width=560&fit=bounds)
Leveraging AI to Streamline Operations for Nonprofits [05.20.2025].pdfTechSoup Explore how AI tools can enhance operational efficiency for nonprofits. Learn practical strategies for automating repetitive tasks, optimizing resource allocation, and driving organizational impact. Gain actionable insights into implementing AI solutions tailored to nonprofit needs.
Decision Tree-ID3,C4.5,CART,Regression Tree
Decision Tree-ID3,C4.5,CART,Regression TreeGlobal Academy of Technology Machine Learning
Decision Tree
Problems on Decision Tree
ALL BENGAL U25 QUIZ LEAGUE 2.0 SET BY SKP.pptx
ALL BENGAL U25 QUIZ LEAGUE 2.0 SET BY SKP.pptxSourav Kr Podder ALL BENGAL U25 QUIZ LEAGUE SET BY SKP
How to Manage Customer Info from POS in Odoo 18
How to Manage Customer Info from POS in Odoo 18Celine George In this slide, we’ll discuss on how to manage blanket order in Odoo 18. A Blanket Order in Odoo 18 is a long-term agreement with a vendor for a specific quantity of goods or services at a predetermined price.
The Pedagogy We Practice: Best Practices for Critical Instructional Design
The Pedagogy We Practice: Best Practices for Critical Instructional DesignSean Michael Morris Keynote offered at the Spring Pedagogy Institute 2025 at Plymouth State University.
Management of head injury in children.pdf
Management of head injury in children.pdfsachin7989 Management of Head Injury: A Clinical Overview
1. Initial Assessment and Stabilization:
The management of a head injury begins with a rapid and systematic assessment using the ABCDE approach:
A – Airway: Ensure the airway is patent; consider cervical spine protection.
B – Breathing: Assess respiratory effort and oxygenation; provide supplemental oxygen if needed.
C – Circulation: Monitor pulse, blood pressure, and capillary refill; manage shock if present.
D – Disability: Evaluate neurological status using the Glasgow Coma Scale (GCS); assess pupil size and reactivity.
E – Exposure: Fully expose the patient to assess for other injuries while preventing hypothermia.
2. Classification of Head Injury:
Head injuries are classified based on GCS score:
Mild: GCS 13–15
Moderate: GCS 9–12
Severe: GCS ≤8
3. Imaging and Diagnosis:
CT scan of the head is the imaging modality of choice, especially in moderate to severe injuries, or if red flag symptoms are present (e.g., vomiting, seizures, focal neurological signs, skull fracture).
Cervical spine imaging may also be necessary.
4. Acute Management:
Mild head injury: Observation, symptomatic treatment (e.g., analgesics), and instructions for return precautions.
Moderate to severe head injury:
Admit to hospital, ideally in an intensive care unit (ICU) if GCS ≤8.
Maintain cerebral perfusion pressure (CPP): control blood pressure and intracranial pressure (ICP).
Consider hyperosmolar therapy (e.g., mannitol or hypertonic saline) if signs of raised ICP.
Elevate head of the bed to 30 degrees.
Surgical intervention (e.g., evacuation of hematomas) may be required based on CT findings.
5. Monitoring and Supportive Care:
Continuous monitoring of GCS, pupils, vitals, and neurological signs.
ICP monitoring in patients with severe injury.
Prevent secondary brain injury by optimizing oxygenation, ventilation, and perfusion.
Seizure prophylaxis may be considered in select cases.
6. Rehabilitation and Long-Term Care:
Referral for neurorehabilitation for physical, cognitive, and emotional recovery.
Psychological support and education for patient and family.
Regular follow-up to monitor for late complications like post-traumatic epilepsy, cognitive deficits, or behavioral changes.
7. Prevention:
Education on safety measures (e.g., helmets, seat belts).
Public health strategies to reduce road traffic accidents, falls, and violence.
Letter to Secretary Linda McMahon from U.S. Senators
Letter to Secretary Linda McMahon from U.S. SenatorsMebane Rash About funding for mental health in education
Regression Analysis-Machine Learning -Different Types
Regression Analysis-Machine Learning -Different TypesGlobal Academy of Technology Regression
Linear Regression
Multiple Linear Regression
Polynomial Regression
Logistics Regression
Electronics Engineering Assignment Help Guide – Expert Support for Students
Electronics Engineering Assignment Help Guide – Expert Support for Studentsonline college homework help This comprehensive Electronics Engineering Assignment Help Guide is designed to support students in mastering core concepts such as analog and digital electronics, embedded systems, signal processing, microcontrollers, and circuit design.
Whether you're tackling complex homework problems, simulation-based projects, or struggling with lab reports, this guide provides step-by-step assistance and academic tips to boost your performance.
Learn about common challenges, key topics, expert tutoring benefits, and practical strategies to excel in your coursework.
Ideal for engineering students at undergraduate and postgraduate levels.
Download now and simplify your electronics learning journey!
WhatsApp:- +91-9878492406
Email:- [email protected]
Visit:- https://onlinecollegehomeworkhelp.com/electronics-engineering-homework-help
TechSoup - Microsoft Discontinuation of Selected Cloud Donated Offers 2025.05...
TechSoup - Microsoft Discontinuation of Selected Cloud Donated Offers 2025.05...TechSoup Thousands of nonprofits rely on donated Microsoft 365 Business Premium and Office 365 E1 subscriptions. In this webinar, TechSoup discuss Microsoft's May 14 announcement that the donated versions of these licenses would no longer be available to nonprofits after July 1, 2025, and which options are best for nonprofits moving forward as they transition off these licenses.
The Splitting of the Moon (Shaqq al-Qamar).pdf
The Splitting of the Moon (Shaqq al-Qamar).pdfMirza Gazanfar Ali Baig This article explores the miraculous event of the Splitting of the Moon (Shaqq al-Qamar) as recorded in Islamic scripture and tradition. Drawing from the Qur'an, authentic hadith collections, and classical tafsir, the article affirms the event as a literal miracle performed by Prophet Muhammad ﷺ in response to the Quraysh’s demand for a sign. It also investigates external historical accounts, particularly the legend of Cheraman Perumal, a South Indian king who allegedly witnessed the miracle and embraced Islam. The article critically examines the authenticity and impact of such regional traditions, while also discussing the lack of parallel astronomical records and how scholars have interpreted this event across centuries. Concluding with the theological significance of the miracle, the article offers a well-rounded view of one of Islam’s most discussed supernatural events.
Basic principles involved in the traditional systems of medicine, Chapter 7,...
Basic principles involved in the traditional systems of medicine, Chapter 7,...ARUN KUMAR Basic principles involved in the traditional systems of medicine include:
Ayurveda, Siddha, Unani, and Homeopathy
Method of preparation of Ayurvedic formulations like:
Arista, Asava, Gutika, Taila, Churna, Lehya and Bhasma
How to Manage Allow Ship Later for Sold Product in odoo Point of Sale
How to Manage Allow Ship Later for Sold Product in odoo Point of SaleCeline George The "Allow Ship Later for Sold Product" feature in Odoo Point of Sale (POS) allows businesses to sell products without requiring immediate delivery. This option gives customers the flexibility to purchase an item and have it shipped at a later date.
YSPH VMOC Special Report - Measles Outbreak Southwest US 5-21-2025.pptx
YSPH VMOC Special Report - Measles Outbreak Southwest US 5-21-2025.pptxYale School of Public Health - The Virtual Medical Operations Center (VMOC) As of May 21, 2025, the Southwestern outbreak has 872 cases, including confirmed and pending cases across Texas, New Mexico, Oklahoma, and Kansas. Experts warn this is likely a severe undercount. The situation remains fluid, though we are starting to see a significant reduction in new cases in Texas. Experts project the outbreak could last up to a year.
CURRENT CASE COUNT: 872 (As of 5/21/2025)
- Texas: 725 (+5) (62% of cases are in Gaines County)
- New Mexico: 74 (92.4% of cases are from Lea County)
- Oklahoma: 17
- Kansas: 56 (+2) (38.89% of the cases are from Gray County)
HOSPITALIZATIONS: 101
- Texas: 92 - This accounts for 13% of all cases in the State.
- New Mexico: 7 – This accounts for 9.47% of all cases in New Mexico.
- Kansas: 2 - This accounts for 3.7% of all cases in Kansas.
DEATHS: 3
- Texas: 2 – This is 0.28% of all cases
- New Mexico: 1 – This is 1.35% of all cases
US NATIONAL CASE COUNT: 1,050 (confirmed and suspected)
INTERNATIONAL SPREAD (As of 5/20/2025)
Mexico: 1,649 - 4 fatalities (1 fatality in Sonora)
- Chihuahua, Mexico: 1,537 cases, 3 fatalities, 5 hospitalizations
Canada: 2,272 (+330) (Includes Ontario’s outbreak, which began November 2024)
- Ontario, Canada – 1,622 (+182), 101 (+18) hospitalizations
- Alberta, Canada – 505(+97)
Statement by Linda McMahon on May 21, 2025
Statement by Linda McMahon on May 21, 2025Mebane Rash Appropriations Subcommittee on Labor, Health and Human Services, Education, and Related Agencies
Electronics Engineering Assignment Help Guide – Expert Support for Students
Electronics Engineering Assignment Help Guide – Expert Support for Studentsonline college homework help
YSPH VMOC Special Report - Measles Outbreak Southwest US 5-21-2025.pptx
YSPH VMOC Special Report - Measles Outbreak Southwest US 5-21-2025.pptxYale School of Public Health - The Virtual Medical Operations Center (VMOC)
PROBLEM STATEMENTIn this assignment, you will complete DoubleEnde.pdf
- 1. PROBLEM STATEMENT: In this assignment, you will complete DoubleEndedList.java that implements the ListInterface as well as an interface called DoubleEndedInterface which represents the list's entries by using a chain of nodes that has both a head reference and a tail reference. Be sure to read through the code and understand the implementation. WHAT IS PROVIDED: - A driver class to test your code. You should not modify this file! - A list interface (ListInterface.java) - A double ended interface (DoubleEndedInterface.java) - An incomplete DoubleEndedList class (DoubleEndedList.java) WHAT YOU NEED TO DO: 4. Complete the DoubleEndedList class 4. Run the driver and make sure your output is exactly the same as mine (at the bottom of Driver.java) } // end else numberofEntries--; else throw new IndexOut0fBoundsException("Illegal position given to remove operation."); return result; // Return removed entry }//endreturnreve public T replace(int givenPosition, T newEntry) { T replace(int givenPosition, T newEntry) { if ((givenPosition >=1)&& (givenPosition <= numberOfEntries)) { // Assertion: The list is not empty Node desiredNode = getNodeAt (givenPosition); ToriginalEntry = desiredNode.getData(); desiredNode.setData(newEntry); return originalEntry; f // end if else throw new IndexOut0fBoundsException("Illegal position given to replace operation."); replace if (( givenPosition >=1)&& (givenPosition <= number0fEntries)) { // Assertion: The list is not empty Node desiredNode = getNodeAt ( givenPosition); T originalEntry = desiredNode. getData( ); desiredNode.setData(newEntry); return originalentry; } // end if throw new Index0ut0fBoundsException("Illegal position given to replace operation."); } // end replace public T getEntry(int givenPosition) { if ((givenPosition >=1) && (givenPosition < = number0fEntries ) ) { // Assertion: The list is not empty return getNodeAt (givenPosition). getData(); else // end if throw new IndexOut0fBoundsException("Illegal position given to getEntry operation."); } // end getEntry public boolean contains ( T anEntry) { boolean found = false; Node currentNode = firstNode; while (!found && (currentNode != null)) { if (anEntry.equals (currentNode.getData())) else found = true; } // end while currentNode = currentNode. getNextNode () ; return found; } // end contains public int getLength() { return
- 2. numberofEntries; } // end getLength public boolean isEmpty() { return number0fEntries ==0; } // end isEmpty public T[] toArray() { // The cast is safe because the new array contains null entries aSuppressWarnings ("unchecked") T[] result =(T[]) new 0bject [numberofEntries]; // Unchecked cast int index =0; Node currentNode = firstNode; while ((index < numberOfEntries) && (currentNode != null)) & result [ index ]= currentNode. getData () ; currentNode = currentNode.getNextNode ( ); index++; 3 // end while return result; 3 // end toArray // Returns a reference to the node at a given position. // Precondition: List is not empty; 1<= givenPosition < = numberofEntries. // Assertion: (firstNode != null) and (1<= givenPosition) and (givenPosition <= // numberofEntries) Node currentNode = firstNode; if (givenPosition == numberofEntries) currentNode = lastNode; else if (givenPosition >1 ) // Traverse the chain to locate the desired node for (int counter =1; counter < givenPosition; counter++) currentNode = currentNode. getNextNode () ; assert currentNode != null; return currentNode; } // end getNodeAt private class Node { private T data; // Data portion private Node next; // Next to next node data = dataPortion; } // end constructor data = dataPortion; } // end constructor private T getData() { } // end return data; private void setData( T newData) { data = newData; } // end setData private Node getNextNode() { return next; } // end getNextNode private void setNextNode(Node nextNode) { next = nextNode; } // end setNextNode } // end Node 1** A class that implements the ADT double-ended list by using a chain of nodes. * The chain has both a head reference and a tail reference. * Position numbers begin with 1 . * Q eauthor Frank M. Carrano * dauthor Joseph Erickson */ aversion 5.0 public class DoubleEndedList implements ListInterface , DoubleEndedInterface { private Node firstNode; // Head reference to first node private Node lastNode; // Ta private int numberofEntries; public DoubleEndedList() { } clear (); // ============= // ADDED METHODS: public void addFirst(T newEntry) f } // end addFirst public void addLast (T newEntry) { } // end addLast public T removefirst() { } // end removefirst public T removelast() { } // end removelast public T getFirst() { } // end getFirst public T getLast () { } // end getLast public void moveToEnd() { } // end moveToEnd // ====================== public final void clear() firstNode = null; lastNode = null; numberOfEntries =0 } // end clear public void add ( T newEntry) { Node newNode = new Node (newEntry); // Create new node if (isEmpty()) else firstNode = newNode; las tNode.
- 3. setNextNode (newNode); lastNode = newNode; numberOfEntries++; 3 // end add if (( newPosition >=1)&& (newPosition <= numberofEntries +1)){ Node newNode = new Node (newEntry); if (isEmpty()) firstNode = newNode lastNode = newNode; }// end if else if (newPosition =1 ) { newNode. SetNextNodel first Node = newNode; 3 // end else if (newPosition == numberOfEntries +1 ) { lastNode. setNextNode (newNode); last Node = newNode; } // end else { Node nodeBefore = getNodeAt ( newPosition -1); Node nodeAfter = nodeBefore.getNextNode () newNode. setNextNode (nodeAfter); 3 // end else } // end if else } // end add throw new IndexOut0fBoundsException("Illegal position given to add operation."); public T remove(int givenPosition) { T result = null; // Return value if ((givenPosition >=1)&& (givenPosition <= number0fEntries)) { // Assertion: The list is not empty result = firstNode. getData ();// Save entry to be removed firstNode = firstNode.getNextNode( ); if (numberofentries =1 ) } // end if lastNode = null; // Solitary entry was removed else // Case 2: givenPosition > 1 Node nodeBefore = getNodeAt (givenPosition -1); Node nodeToRemove = nodeBefore. getNextNode (); Node nodeAfter = nodeToRemove. getNextNode (); Node nodeAfter = nodeToRemove.getNextNode (); nodeBefore.setNextNode(nodeAfter); // Disconnect the node to be removed result = nodeToRemove.getData(); // Save entry to be removed if (givenPosition == numberofentries) lastNode = nodeBefore; // Last node was removed } // end else numberofEntries--; else throw new Indexout0fBoundsException("Illegal position given to remove operation."); return result; // Return removed entry remove } // end remove public T replace(int givenPosition, T newEntry) { venPosition >=1)&& (givenPosition <= numberofentries) ) { Node desiredNode = getNodeAt (givenPosition); ToriginalEntry = desiredNode.getData( ); return originalData (newEntry); } // end if throw new IndexOut0fBoundsException("Illegal position given to replace operation."); An interface for a collection that has a first entry and a last entry. @author Frank M. Carrano Qversion 5.0 / ablic interface DoubleEndedInterface {/ * Adds a new entry to the beginning of this collection. * @param newEntry The object to be added as a new entry. 1 public void addFirst(T newEntry); /** * Adds a new entry to the end of this collection. * Qparam newEntry The object to be added as a new entry. / public void addLast( T newEntry); /** * Removes and returns the first entry in this collection. * areturn A reference to the removed entry or null, if * the list was empty. / public T removefirst(); /** * Removes and returns the last entry in this collection. * Qreturn A reference to the removed entry or null, if * the list was empty. / public T removelast(); /** * Retrieves the first entry in this collection. * areturn A reference to the first entry or null, if * the list is empty. 1 public T getFirst(); /** * Retrieves the last entry in this collection. * Qreturn A reference to the last entry or null, if * the list is empty. / public T getLast(); /** Moves the first entry in this collection to the end of the list. */ public void
- 4. moveToEnd(); // end DoubleEndedInterface ver that demonstrates the class DoubleEndedList. thest only the additional methods, since the methods or Frank M. Carrano ion 5.0 lass Driver { lass Driver { public static void main(String[] args) { System.out.println("Create an empty list."); System. out.print ln("Create an empty list."); DoubleEndedList < String > myList = new DoubleEndedList <(); System.out.println("List should be empty; isEmpty() returns " + myList.isEmpty() + "."); System.out.print ln("nTesting addFirst:"); myList.addFirst ("15"); myList. addFirst (" 25 ") mylist.addFirst (" 45) System.out.println("List should contain 453525 15."); myList.clear(); mylist.clear(); myList. addLast ("15"); myList.addLast ("35") myList.addLast (" 45) myList.addLast ("55"); myList. addLast ("65"); displaylist (myList); System.out.print ln("nTesting removeFirst with previous list:"); System.out.println("removeFirst (): " + myList. removeFirst ()); System. out.println("nList should containn45 5565 "); displayList (myList); System. out.println("removefirst(): " + myList. removeFirst()); System. out.println("removefirst(): " + myList. removefirst()); System. out.println("List should be empty; isEmpty() returns" + myList.isEmpty() + "."); myList.clear(); myList. addLast ("15"); myList.addLast (" 25 ") myList. addLast ("45"); myList. addLast ("55"); System.out.println("List should contain 1525354555 65."); displaylist (myList); System.out.println("removeLast (): " + myList.removeLast()); System.out.println("removeLast (): " + myList.removeLast ()); System. out.print ln ("removeLast (): " + myList. removeLast ()) System. out.print ln ("removeLast (): " + mylist.removelast ()); System.out.println("nList should contain n15"); displaylist (myList); ( ) System.out.print ln("nTesting getFirst and getlast with the following list:"); myList.clear() myList.addLast ("15"); myList.addLast (" 25 "); myList. addLast ("35"); myList. addLast (" 55) myList.addLast ("65"); displayList (myList): System.out.println("Retrieving the first entry : returns " + myList.getFirst()); System.out.print ln("nTesting moveToEnd with the following list:"); displayList (myList); myList. moveToEnd () System. out.println("After moveToEnd, the list is:"); displaylist (myList); myList. moveToEnd ( ) System.out.println("After moveToEnd, the list is:"); displaylist (myList); myList. moveToEnd ( ) System.out.println("After moveToEnd, the list is:"); displaylist (mylist); System. out.print ln ("nnDone."); public static void displayList(ListInterface aList) { System.out.println("The list contains " + aList.getLength() + "string(s), as follows:"); Object [] listArray = aList. toArray(); for (int index =0; index < listarray. length; index++) { } // end for System.out.print ln(); for (int position =1; position <= listarray. length; position++) { if (position < 10) else System.out.print(" " + position); System.out.print (position); System.out.print(" "); }//endfor System.out.print ln(); H/ end Driver e an empty list. should be empty; isEmpty() returns true. son list. ng addFirst: should contain 45352515 ist contains 4 string(s), as follows: 4 ng addlast with the following list: should contain
- 5. 152535455565. ist contains 456 * Testing removefirst with previous list: * removefirst(): 15 * removeFirst(): 25 * removeFirst(): 35 * List should contain * 455565 * The list contains 3 string(s), as follows: * 455565 * 123 * removeFirst(): 45 * removeFirst(): 55 * removeFirst(): 65 * removefirst(): null * List should be empty; isEmpty() returns true. * * Testing removelast with the following list: * List should contain 152535455565 . * The list contains 6 string(s), as follows: * 152535455565 * 123456 * removeLast (): 65 * removelast (): 55 * removelast (): 45 * removelast (): 35 * removeLast (): 25 * List should contain * 15 * The list contains 1 string(s), as follows: * 15 * 1 * removelast (): 15 * removelast (): null * List should be empty; isEmpty() returns true. * Testing getFirst and getlast with the following list: * The list contains 6 string(s), as follows: * 152535455565 * 123456 * Retrieving the first entry : returns 15 * Retrieving the last entry : returns 65 * Testing moveToEnd with the following list: * The list contains 6 string(s), as follows: * 152535455565 * 123456 * After moveToEnd, the list is: * The list contains 6 string(s), as follows: * 253545556515 * 123456 * After moveToEnd, the list is: * The list contains 6 string(s), as follows: * 354555651525 * 123456 * After moveToEnd, the list is: * The list contains 6 string(s), as follows: * 455565152535 * 123456 * * * Done. *I * Entries in a list have positions that begin with 1. * eauthor Frank M. Carrano * dauthor Timothy M. Henry * aversion 5.0 */ ublic interface ListInterface { /** * Adds a new entry to the end of this list. * Entries currently in the list are unaffected. * The list's size is increased by 1 . * Gparam newEntry The object to be added as a new entry. */ public void add( T newEntry); /** * Adds a new entry at a specified position within this list. * Entries originally at and above the specified position * are at the next higher position within the list. * The list's size is increased by 1 . * Caparam newPosition An integer that specifies the desired * position of the new entry. * Caparam newEntry The object to be added as a new entry. * Gathrows IndexoutofBoundsException if either newPosition < 1 or newPosition > */ getLength ()+1. public void add(int newPosition, T newEntry); /*** * Removes the entry at a given position from this list. * Entries originally at positions higher than the given * position are at the next lower position within the list, * and the list's size is decreased by 1 . * eparam givenPosition An integer that indicates the position of the entry to be removed. * ereturn A reference to the removed entry. * athrows IndexOutofBoundsException if either * givenPosition <1 or givenPosition > */ getLength(). public T remove(int givenPosition); /** Removes all entries from this list. */ public void clear(); /** * Replaces the entry at a given position in this list. * Gparam givenPosition An integer that indicates the position of * the entry to be replaced. * eparam newEntry The object that will replace the entry at the * areturn The original position givenPosition. * athrows
- 6. Index0utal entry that was replaced. * givenPosition <1 or givenPosition > */ givenPosition < 1 or givenPosition > getLength(). public T replace(int givenPosition, T newEntry); / ** Retrieves the entry at a given position in this list. * @param givenPosition An integer that indicates the position of the desired entry. * areturn A reference to the indicated entry. * Gthrows Index0ut0fBoundsException if either givenPosition < 1 or givenPosition > */ getLength ( ). public T getEntry(int givenPosition); /** * Retrieves all entries that are in this list in the order in which * they occur in the list. * Greturn A newly allocated array of all the entries in the list. * If the list is empty, the returned array is empty. public T[] toArray(); /*** * Sees whether this list contains a given entry. * eparam anEntry The object that is the desired entry. * Greturn True if the list contains anEntry, or false if not. */ public boolean contains ( T anEntry); /*** * Gets the length of this list. * areturn The integer number of entries currently in the list. public int getLength(); /** * Sees whether this list is empty. * ereturn True if the list is empty, or false if not. * a public boolean isEmpty(); // end ListInterface