Write the following using javaGiven a class ‘Node’ and ‘NodeList’,.pdf
0 likes2 views
Write the following using java Given a class ‘Node’ and ‘NodeList’, that contains the below information diagram. -id: int -name: String -next: Node +Node(id: int, name: String) +setId(id: int): void +getId(): int +setName(name: String) : void +getName(): String +setNext(node: Node): void +getNext(): Node NodeList -size: int -root: Node +add(node: Node): void +size(): int +findNode(node: Node): boolean Implement add(Node), findNode(Node) and size methods in the NodeList class which is provided to you. The methods should work as: Using the following main method: public static void main(String[] args) { NodeList list = new NodeList(); Node node = new Node(1, \"Book\"); Node node2 = new Node(2, \"Lappy\"); list.add(node); list.add(node2); System.out.println(\"Length : \"+list.size()); Node node3 = new Node(3, \"Glass\"); Node node4 = new Node(4, \"Pen\"); list.add(node3); System.out.println(\"Length : \"+list.size()); if(list.findNode(node3)) System.out.println(\"Node found: \"+ node3.getName()); else System.out.println(\"Node not found: \"+ node3.getName()); if(list.findNode(node4)) System.out.println(\"Node found: \"+ node4.getName()); else System.out.println(\"Node not found: \"+ node4.getName()); } Then it should return the following output: Length : 2 Length : 3 Node found: Glass Node not found: Pen The given Node class is: public class Node { private int id = 0; private String name = \"\"; private Node next; public Node(int id, String name) { this.id = id; this.name = name; this.next = null; } public Node getNext() { return next; } public void setNext(Node node) { this.next = node } public int getId() { return id; { public void setId(int id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String toString() { return \"ID : \"+this.id+\" Name : \"+this.name; } } The given NodeList class is: public class NodeList { private int size = 0; private Node root = null; /* * It has to take a new Node and add that to the next address of previous Node. * If the list is empty, assign it as the \"root\" * @Param - Node */ public void add(Node node) { // Implement this method!!! } /* * It has to return the size of the NodeList * * @return size */ public int size() { // Implement this method!!! } /* * It has to take a Node and checks if the node is in the list. * If it finds the node, it returns true, otherwise false * * @param - Node * @return boolean true/false */ public boolean findNode(Node node) { // Implement this method!!! } }Node -id: int -name: String -next: Node +Node(id: int, name: String) +setId(id: int): void +getId(): int +setName(name: String) : void +getName(): String +setNext(node: Node): void +getNext(): Node Solution Hi, Please find my implementation. Please let me know in case of any issue. ############ Node.java ############# public class Node { private int id = 0; private String name = \"\"; private Node next; public Node(int id, String name) { this.id = id; this..
1 of 8
Download to read offline
![Write the following using java
Given a class ‘Node’ and ‘NodeList’, that contains the below information diagram.
-id: int
-name: String
-next: Node
+Node(id: int, name: String)
+setId(id: int): void
+getId(): int
+setName(name: String) : void
+getName(): String
+setNext(node: Node): void
+getNext(): Node
NodeList
-size: int
-root: Node
+add(node: Node): void
+size(): int
+findNode(node: Node): boolean
Implement add(Node), findNode(Node) and size methods in the NodeList class which is
provided to you. The methods should work as:
Using the following main method:
public static void main(String[] args)
{
NodeList list = new NodeList();
Node node = new Node(1, "Book");
Node node2 = new Node(2, "Lappy");
list.add(node);
list.add(node2);
System.out.println("Length : "+list.size());
Node node3 = new Node(3, "Glass");
Node node4 = new Node(4, "Pen");
list.add(node3);
System.out.println("Length : "+list.size());
if(list.findNode(node3)) System.out.println("Node found: "+ node3.getName());
else](https://image.slidesharecdn.com/writethefollowingusingjavagivenaclassnodeandnodelist-230708024646-bba2fc8f/85/Write-the-following-using-javaGiven-a-class-Node-and-NodeList-pdf-1-320.jpg)
![/*
* It has to return the size of the NodeList
*
* @return size
*/
public int size()
{
// Implement this method!!!
return size;
}
/*
* It has to take a Node and checks if the node is in the list.
* If it finds the node, it returns true, otherwise false
*
* @param - Node
* @return boolean true/false
*/
public boolean findNode(Node node)
{
// Implement this method!!!
Node temp = root;
while(temp != null){
if(temp.getId() == node.getId() &&
temp.getName().equalsIgnoreCase(node.getName()))
return true;
temp = temp.getNext();
}
return false;
}
}
################ NodeListTest.java ########################
public class NodeListTest {
public static void main(String[] args)
{
NodeList list = new NodeList();](https://image.slidesharecdn.com/writethefollowingusingjavagivenaclassnodeandnodelist-230708024646-bba2fc8f/85/Write-the-following-using-javaGiven-a-class-Node-and-NodeList-pdf-7-320.jpg)
Recommended
In Java....The methods should work as add(Node) It has to take a .pdf
In Java....The methods should work as add(Node) It has to take a .pdfmanjan6 In Java....
The methods should work as: add(Node) It has to take a new Node and add that to the next
address of previous Node. findNode(Node) It has to take a node and checks if the node is in the
list. size() It should return the size of the NodeList.
public class NodeList {
private int size = 0;
private Node root = null;
/*
* It has to take a new Node and add that to the next address of previous Node.
* If the list is empty, assign it as the \"root\"
* @Param - Node
*/
public void add(Node node) {
// Implement this method!!!
}
/*
* It has to return the size of the NodeList
*
* @return size
*/
public int size() {
// Implement this method!!!
}
/*
* It has to take a Node and checks if the node is in the list.
* If it finds the node, it returns true, otherwise false
*
* @param - Node
* @return boolean true/false
*/
public boolean findNode(Node node){
// Implement this method!!!
}
}
Solution
public class NodeList {
private int size = 0;
private Node root = null;
/*
* It has to take a new Node and add that to the next address of previous Node.
* If the list is empty, assign it as the \"root\"
* @Param - Node
*/
public void add(Node node) {
// Implement this method!!!
if(node==null)
return;
if(root == null)
root=node;
else{
Node temp = root;
while(temp.next!=null){
temp = temp.next;
}
temp.next = node;
}
}
/*
* It has to return the size of the NodeList
*
* @return size
*/
public int size() {
// Implement this method!!!
int count =0;
if(root==null)
return count;
else{
Node temp = root;
while(temp!=null){
temp= temp.next;
count++;
}
}
return count;
}
/*
* It has to take a Node and checks if the node is in the list.
* If it finds the node, it returns true, otherwise false
*
* @param - Node
* @return boolean true/false
*/
public boolean findNode(Node node){
// Implement this method!!!
boolean flag = false;
if(root == null)
return false;
else{
Node temp = root;
while(temp!=null){
if(temp==node){
flag = true;
break;
}
}
return flag;
}
}
}
also find the defination of class Node
class Node{
int data;
Node next;
}.
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.
Help please!!(Include your modified DList.java source code file in.pdf
Help please!!(Include your modified DList.java source code file in.pdfjyothimuppasani1 Help please!!
(Include your modified DList.java source code file in your homework solution zip archive)
Using
whatever Java IDE you prefer, create a project and add DList.java and DListTest.java to it (these
files are provided
in the Week 6 Source zip archive). Modify DList to implement a method that removes all
occurrences of a specific
integer from the list. Here is the pseudocode:
Method removeAll(In: Integer pData) Returns Nothing
Define index variable i and initialize i to 0
While i < the size of this Dlist Do
If get(i) equals pData Then
remove(i)
Else
Increment i
End If
End While
End Method removeAll
Next, modify DListTest() to add test case 21 which tests that removeAll() works correctly.
WHat more do i need to provide to get help on this???
Solution
/* DListNode.java */
/**
* A DListNode is a node in a DList (doubly-linked list).
*/
class DListNode {
/**
* item references the item stored in the current node.
* prev references the previous node in the DList.
* next references the next node in the DList.
*
* DO NOT CHANGE THE FOLLOWING FIELD DECLARATIONS.
*/
public Object item;
protected DListNode prev;
protected DListNode next;
/**
* DListNode() constructor.
* @param i the item to store in the node.
* @param p the node previous to this node.
* @param n the node following this node.
*/
DListNode(Object i, DListNode p, DListNode n) {
item = i;
prev = p;
next = n;
}
}
/* DList.java */
/**
* A DList is a mutable doubly-linked list ADT. Its implementation is
* circularly-linked and employs a sentinel (dummy) node at the head
* of the list.
*
* DO NOT CHANGE ANY METHOD PROTOTYPES IN THIS FILE.
*/
class DList {
/**
* head references the sentinel node.
* size is the number of items in the list. (The sentinel node does not
* store an item.)
*
* DO NOT CHANGE THE FOLLOWING FIELD DECLARATIONS.
*/
protected DListNode head;
protected int size;
/* DList invariants:
* 1) head != null.
* 2) For any DListNode x in a DList, x.next != null.
* 3) For any DListNode x in a DList, x.prev != null.
* 4) For any DListNode x in a DList, if x.next == y, then y.prev == x.
* 5) For any DListNode x in a DList, if x.prev == y, then y.next == x.
* 6) size is the number of DListNodes, NOT COUNTING the sentinel,
* that can be accessed from the sentinel (head) by a sequence of
* \"next\" references.
*/
/**
* newNode() calls the DListNode constructor. Use this class to allocate
* new DListNodes rather than calling the DListNode constructor directly.
* That way, only this method needs to be overridden if a subclass of DList
* wants to use a different kind of node.
* @param item the item to store in the node.
* @param prev the node previous to this node.
* @param next the node following this node.
*/
protected DListNode newNode(Object item, DListNode prev, DListNode next) {
return new DListNode(item, prev, next);
}
/**
* DList() constructor for an empty DList.
*/
public DList() {
// Your solution here.
head = newNode(null, head, head);
head.prev = head;
head.next = head;
si.
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 *.
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.
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.
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..
Please and Thank youObjective The purpose of this exercise is to .pdf
Please and Thank youObjective The purpose of this exercise is to .pdfalicesilverblr Please and Thank you
Objective: The purpose of this exercise is to create a Linked List data structure that mimics the
behavior of the Java Standard Library Version (Java API). The outcomes/results of using the
library features should be identical with your own version (My API). However, the underlying
implementation should follow with the descriptions listed below.
Instructions : Create the following Linked List Data Structure with the given description below
in your utils package and use "for loops" for your repetitive tasks.
Where to find starter code in my-api
package.class : utils.LinkedList
package.class : tests.console.week04.LinkedListTest
Where to find your JUNIT test in my-api
package.class : tests.junit.LinkedListJUnitTest
Nested Class that has to be added to LinkedList class
package.class : utils.LinkedList.Node
Task Check List
ONLY "for" loops should be used within the data structure class. There is an automatic 30%
deduction, if other loops are used.
The names of identifiers MUST match the names listed in the description below. Deductions
otherwise.
Complete coding Assignment in your "my-api" GitHub Repository. You will not be graded
otherwise and will receive a 0, if not uploaded there.
Run JUNIT TEST and take a SNAPSHOT of results. Upload PDF of snapshot of your JUnitTest
results to Canvas.
Description
The internal structure of the Linked List is a doubly linked Node data structure and should have
at a minimum the following specifications:
data fields: The data fields to declare are private and you will keep track of the size of the list
with the variable size and the start of the list with the reference variable data.
first is a reference variable for the first Node in the list.
last is a reference variable for the last Node in the list.
size keeps track of the number of nodes in the list of type int. This will allow you to know the
current size of the list without having to traversing the list.
constructors: The overloaded constructors will initialize the data fields size and data.
A constructor that is a default constructor initializes the starting node location first and size to a
zero equivalent, that is, constructs an empty list.
methods: methods that manages the behavior of the linked nodes.
Together, the methods below give the illusion of a index or countable location. Implement these
methods within your generic Linked List class.
Method
Description
Header
public boolean add(E item)
public void add(int index, E item)
public void append( E item)
private void checkIndex(int index)
public boolean contains(E item)
public void clear()
private E detach(int index)
public E get(int index)
public int indexOf(E item)
private void insertBefore(int index, E item)
public boolean isEmpty()
private Node node(int index)
public E remove(int index)
public boolean remove(E item)
public E set(int index, E item)
public int size()
public String toString()
Node Data Structure
The generic Linked List class includes a static Node class as a ne.
In this assignment you will implement insert() method for a singly l.pdf
In this assignment you will implement insert() method for a singly l.pdffantasiatheoutofthef In this assignment you will implement insert() method for a singly linked Link list. The code
MyLinkedlist.java is given , it uses generic type as the linked list can be created with any object
type. Some methods like add() and toString() are already implemented. The MyLinkedList class
has a private nested class called Node.
The objective of this assignment is to implement the insert() method that takes two inputs an
element of generic type to be inserted and an index (value of integer type) at which it should be
inserted. For this assignment we will assume the first element has the index 0. if the given index
is less than zero do nothing but if it is greater than the size of the list, insert the element at the
end of the list. if the index is between 0 and size , insert it in the appropriate location. You insert
code should correctly update the theSize data member of the linked list. Return type for insert()
method is boolean (true or false) depending on whether the insertion was successful or not. Use
the following method header.
}
Main.java
//add necessary libraries
public class Main
{
//add your function here
public static void main (String [] args)
{
}
}
MyLinkedList.java
public class MyLinkedList {
// A private nested Node class
private static class Node{
public AnyType data; // Data members are public, this is fine as the Node class itself is
private
public Node next;
public Node(AnyType d, Node n)
{
data = d;
next=n;
}
@Override
public String toString() {
return data.toString();
}
}
// Data Members
private Node head; // A node pointer to the first item in the List
private int theSize; // a integer variable to hold the size of the List
public MyLinkedList() {
doClear();
}
public void clear() {
doClear();
}
private void doClear() {
head = null;
theSize =0 ;
}
// An add method that will always add at the beginning of the List
public boolean add(AnyType x) {
if(head == null) // List is empty
{
head = new Node(x, null);
theSize++;
return true;
}
else // List has at least one item lets get to the end of it
{
Node newnode = new Node(x, head);
head = newnode;
theSize++;
return true;
}
}
@Override
public String toString() {
// This to String method will print the List from head to the end.
String theList = "";
if(head==null)
return theList;
Node cur = head;
while(cur.next!=null) {
theList = theList + cur.toString() + " ";
cur= cur.next;
}
return theList + cur.toString();
}
public int getTheSize() {
return theSize;
}
}
/*****************************************************************************
*
*
* SOLUTION CODE BELOW THIS HEADER
*
*****************************************************************************/
/*****************************************************************************
*
*
* SOLUTION CODE ABOVE THIS HEADER
*
*****************************************************************************/
}
Current file: Main.java Load default template... //add necessary Libraries public class Main \{
//add your function here public static vo.
Rewrite this code so it can use a generic type instead of integers. .pdf
Rewrite this code so it can use a generic type instead of integers. .pdfalphaagenciesindia Rewrite this code so it can use a generic type instead of integers. This means we can use any data
type with it.
For example:
LinkedList = new LinkedLIst<>();
public class Main {
public static void main(String[] args) {
/*
* Expected output:
*
* The list: 8 -> 1 -> 5 -> 3 -> 6
* Size: 5
* Head: 8
* Tail: 6
* Removeing 1...
* The list: 8 -> 5 -> 3 -> 6
* Size: 4
* Head: 8
* Tail: 6
* Removeing head...
* The list: 5 -> 3 -> 6
* Size: 3
* Head: 5
* Tail: 6
* Removeing tail...
* The list: 5 -> 3
* Size: 2
* Head: 5
* Tail: 3
*/
LinkedList list = new LinkedList();
list.append(5);
list.append(3);
list.append(6);
list.prepend(1);
list.prepend(8);
printListDetails(list);
System.out.println("Removeing 1...");
list.removeByValue(1);
printListDetails(list);
System.out.println("Removeing head...");
list.removeHead();
printListDetails(list);
System.out.println("Removeing tail...");
list.removeTail();
printListDetails(list);
}
public static void printListDetails(LinkedList list) {
System.out.println("The list: " + list.toString());
System.out.println("Size: " + list.size());
System.out.println("Head: " + list.getHead());
System.out.println("Tail: " + list.getTail());
}
}
________________________________________
public class LinkedList {
private Node head;
private Node tail;
private int size;
public LinkedList() {
head = null;
tail = null;
size = 0;
}
public void append(int data) {
Node newNode = new Node(data);
if (head == null) {
head = newNode;
} else {
tail.next = newNode;
}
tail = newNode;
size++;
}
public void prepend(int data) {
Node newNode = new Node(data);
if (head == null) {
head = newNode;
tail = newNode;
} else {
newNode.next = head;
head = newNode;
}
size++;
}
public int getHead() {
return head.data;
}
public int getTail() {
return tail.data;
}
public int size() {
return size;
}
public void removeByValue(int data) {
Node current = head;
while (current.next != null && current.next.data != data) {
current = current.next;
}
if (current.next != null) {
current.next = current.next.next;
size--;
if (current.next == null) {
tail = current;
}
}
}
public int removeHead() {
int removedData = head.data;
head = head.next;
size--;
if (head == null) {
tail = null;
}
return removedData;
}
public int removeTail() {
int removedData = tail.data;
if (head == tail) {
head = null;
tail = null;
} else {
Node current = head;
while (current.next != tail) {
current = current.next;
}
tail = current;
tail.next = null;
}
size--;
return removedData;
}
@Override
public String toString() {
StringBuilder builder = new StringBuilder();
Node current = head;
while (current != null) {
builder.append(current.data);
if (current.next != null) {
builder.append(" -> ");
}
current = current.next;
}
return builder.toString();
}
private class Node {
public Node next;
public int data;
public Node(int data) {
this.data = data;
}
}
}.
Objective The purpose of this exercise is to create a Linked List d.pdf
Objective The purpose of this exercise is to create a Linked List d.pdfaliracreations Objective: The purpose of this exercise is to create a Linked List data structure that mimics the
behavior of the Java Standard Library Version (Java API). The outcomes/results of using the
library features should be identical with your own version (My API). However, the underlying
implementation should follow with the descriptions listed below.
Instructions : Create the following Linked List Data Structure with the given description below
in your utils package and use "for loops" for your repetitive tasks.
Where to find starter code in my-api
package.class : utils.LinkedList
package.class : tests.console.week04.LinkedListTest
Where to find your JUNIT test in my-api
package.class : tests.junit.LinkedListJUnitTest
Nested Class that has to be added to LinkedList class
package.class : utils.LinkedList.Node
Task Check List
ONLY "for" loops should be used within the data structure class. There is an automatic 30%
deduction, if other loops are used.
The names of identifiers MUST match the names listed in the description below. Deductions
otherwise.
Complete coding Assignment in your "my-api" GitHub Repository. You will not be graded
otherwise and will receive a 0, if not uploaded there.
Run JUNIT TEST and take a SNAPSHOT of results. Upload PDF of snapshot of your JUnitTest
results to Canvas.
Description
The internal structure of the Linked List is a doubly linked Node data structure and should have
at a minimum the following specifications:
data fields: The data fields to declare are private and you will keep track of the size of the list
with the variable size and the start of the list with the reference variable data.
first is a reference variable for the first Node in the list.
last is a reference variable for the last Node in the list.
size keeps track of the number of nodes in the list of type int. This will allow you to know the
current size of the list without having to traversing the list.
constructors: The overloaded constructors will initialize the data fields size and data.
A constructor that is a default constructor initializes the starting node location first and size to a
zero equivalent, that is, constructs an empty list.
methods: methods that manages the behavior of the linked nodes.
Together, the methods below give the illusion of a index or countable location. Implement these
methods within your generic Linked List class.
Method
Description
Header
public boolean add(E item)
public void add(int index, E item)
public void append( E item)
private void checkIndex(int index)
public boolean contains(E item)
public void clear()
private E detach(int index)
public E get(int index)
public int indexOf(E item)
private void insertBefore(int index, E item)
public boolean isEmpty()
private Node node(int index)
public E remove(int index)
public boolean remove(E item)
public E set(int index, E item)
public int size()
public String toString()
Node Data Structure
The generic Linked List class includes a static Node class as a nested class, i.e. a st.
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.
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.
Can someone help me to fix the code please package dlist i.pdf
Can someone help me to fix the code please package dlist i.pdfABHISHEKREADYMADESKO Can someone help me to fix the code please?
package dlist;
import java.util.Iterator;
public class DList implements Iterable<String> {
private static class DListNode {
public String data;
public DListNode next;
public DListNode previous;
}
private DListNode nil;
private int size;
public DList() {
nil = new DListNode();
nil.previous = nil;
nil.next = nil;
nil.data = null;
size = 0;
}
public void addFirst(String elem) {
DListNode newNode = new DListNode();
newNode.data = elem;
newNode.next = nil.next;
newNode.previous = nil;
nil.next.previous = newNode;
nil.next = newNode;
size++;
}
public void addLast(String elem) {
DListNode newNode = new DListNode();
newNode.data = elem;
newNode.next = nil;
newNode.previous = nil.previous;
nil.previous.next = newNode;
nil.previous = newNode;
size++;
}
public String getFirst() {
if (size == 0) {
throw new RuntimeException("DList is empty");
}
return nil.next.data;
}
public String getLast() {
if (size == 0) {
throw new RuntimeException("DList is empty");
}
return nil.previous.data;
}
public String removeFirst() {
if (size == 0) {
throw new RuntimeException("DList is empty");
}
DListNode first = nil.next;
first.next.previous = nil;
nil.next = first.next;
size--;
return first.data;
}
public String removeLast() {
if (size == 0) {
throw new RuntimeException("DList is empty");
}
DListNode last = nil.previous;
last.previous.next = nil;
nil.previous = last.previous;
size--;
return last.data;
}
public String get(int index) {
if (index < 0 || index >= size) {
throw new IndexOutOfBoundsException();
}
DListNode node = nil.next;
for (int i = 0; i < index; i++) {
node = node.next;
}
return node.data;
}
public String set(int index, String value) {
if (index < 0 || index >= size) {
throw new IndexOutOfBoundsException();
}
DListNode node = nil.next;
for (int i = 0; i < index; i++) {
node = node.next;
}
String oldValue = node.data;
node.data = value;
return oldValue;
}
public boolean contains(Object obj) {
DListNode node = nil.next;
while (node != nil) {
if (node.data.equals(obj)) {
return true;
}
node = node.next;
}
return false;
}
public int size() {
return size;
}
public int indexOf(Object obj)
{
int index = 0;
DListNode node = nil.next;
while (node != nil)
{
if (node.data.equals(obj))
{
return index;
}
index++;
node = node.next;
}
return -1;
}
@Override
public Iterator<String> iterator()
{
return new DListIterator();
}
private class DListIterator implements Iterator<String>
{
private DListNode pointer;
public DListIterator()
{
if(nil.next==nil)
{
pointer = nil;
}
else
pointer=nil.next;
}
public boolean hasNext()
{
return pointer != nil;
}
}
}.
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 =.
This is problem is same problem which i submitted on 22017, I just.pdf
This is problem is same problem which i submitted on 22017, I just.pdffcaindore There is a host of sociological and cultural research that paints a robust picture of the effects of
globalization on culture. This Application focuses on the flows of culture between Western and
developing nations. As a practitioner in this global environment, you should be familiar with
these culture effects. Use newspapers, magazines, and the Internet to research cultural changes in
both Western and developing countries due to globalization. Then perform the following tasks:
Outline the cultural aspects of globalization. Take an anthropological, rather than a business,
perspective. Explain how you think understanding culture helps in doing business in today\'s
global economy. Cite resources to justify your response.
Solution
Information technology has penetrated almost every aspect of our lives, “shrinking” our world
into a global village.
Economies and cultures have come closer. People are now aware of the cultures, traditions,
lifestyle, living conditions
prevailing in almost every corner of the world. Interestingly, this is going beyond awareness and
into a state of
integration that is a result of cross-pollinated views, ideologies, products and services.
This evolution is termed as “globalization.”
Culture has many definitions. My own definition is that culture is our collective experience as a
society,
and its impact on our reaction and decision-making relative to every-day facts and
circumstances.
Why is cross-cultural competence critical to your professional future and the viability of your
company?
It’s omnipresent in every business interaction and strategic decision.It is not feasible to be an
expert on
all the world’s cultures. It is possible, however, to incorporate a cross-cultural framework that
improves
cross-cultural understanding and interactions.
Multinational firms whose operations are borderless have to consider the cultural variability of
different regions
of the world and develop cultural understanding. Major cultural constraints encountered by
businesses include local
attitudes, taste preferences, language, religion, management style, gender discrimination, skills,
personalities,
education, etc. To be successful, they need to mold their business actions in accordance with the
local cultural models,
they need to establish a global mindset.
Let’s consider an example of the food giant, McDonald’s. The company enjoys a global
presence; operating in more than
100 countries serving 70 million people every day. Their headquarters and senior management
are U.S.-based but they
entrust their local operations to local managers of the countries they operate in. Operations in
more than 50 percent of
their outlets are franchised. Furthermore, their menus are customized according to cultural
habits and local taste
preferences in every country. It is without a doubt that global thinking and cultural
understanding are both powerful
business tools which allow multinational firms to dominate the local markets and establish a
global pres.
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.
can you add a delete button and a add button to the below program. j.pdf
can you add a delete button and a add button to the below program. j.pdfsales88 The document describes a Java program that implements a linked list of Car objects. It includes classes for the Car object with attributes like make, model, year, and color, and a NuLinkedList class that implements basic linked list functionality for adding, removing, and accessing Car elements. The program reads a file of cars into an ArrayList and provides buttons to navigate between cars, displaying the current car details. The request is to add delete and add buttons to allow removing and adding cars to the linked list from the GUI.
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.
Note Given Code modified as required and required met.pdf
Note Given Code modified as required and required met.pdfAnkitchhabra28 Note:
Given Code modified as required and required methods added.
Code:
// class node
class Node
{
// declare the required variable
String data;
Node next;
// constructor
Node(){}
// constructor with arguments
Node(String data)
{
this.data = data;
next = null;
}
// method to get the data
public String getData()
{
return data;
}
// method to set the data
public void setData(String data)
{
this.data = data;
}
// method to get the next data
public Node getNext()
{
return next;
}
// method to set the next data
public void setNext(Node next)
{
this.next = next;
}
}
// class for a linked list
class MyLInkedList
{
Node head;alue into a list
// method to add the v
public void add(String num)
{
if (head == null)
{
head = new Node(num);
}
else{
Node temp = new Node(num);
Node current = head;
if (current != null) {
while (current.getNext() != null) {
current = current.getNext();
}
current.setNext(temp);
}
}
}
// method to search a value from a list
public void search(String num)
{
Node current = head;
boolean flag=true;
if (current != null)
{
while (current != null)
{
if(current.getData() == num)
{
System.out.println(\"Search value \"+
current.getData()+\" is available\");
flag=false;
}
current = current.getNext();
}
if (flag==true)
{
System.out.println(\"Search value \"+
current.getData()+\" is not available\");
}
}
else
{
System.out.println(\"Linked list is empty\");
}
}
// method to delete a value from a list
public void delete(String num)
{
//Node current = head;
boolean flag=true;
if (head == null)
{
System.out.println(\"Can\'t Delete, Linked list is
empty\");
return;
}
if(head.getData() == num)
{
head=head.getNext();
return;
}
Node temp = new Node(num);
Node cr = head;
Node prev=null;
while ((cr != null) && !(cr.getData() == num))
{
prev=cr;
cr = cr.getNext();
}
prev.setNext(cr.getNext());
}
// method to print the list
public void print()
{
Node current = head;
if (current != null) {
while (current != null) {
System.out.println(current.getData());
current = current.getNext();
}
}
}
}
// method to test the class
public class MyLInkedListTester
{
// main method to perform the linked list operatrions
public static void main(String args[])
{
MyLInkedList llist = new MyLInkedList();
// insert the values into list
llist.add(\"1\");
llist.add(\"2\");
llist.add(\"3\");
llist.add(\"4\");
// print the list values
llist.print();
// sear the values in a list
llist.search(\"1\");
llist.print();
// delete the value from a list
llist.delete(\"4\");
System.out.println(\"List after deletion:\");
llist.print();
}
}
Result:
1
2
3
4
Search value 1 is available
1
2
3
4
List after deletion:
1
2
3
Solution
Note:
Given Code modified as required and required methods added.
Code:
// class node
class Node
{
// declare the required variable
String data;
Node next;
// constructor
Node(){}
// constructor with arguments
Node(String data)
{
this.data = data;
next = null;
}
// method to get the data
public String getData()
{
return data;
}
// method to set the data
public void se.
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.
Objective The purpose of this exercise is to create a Linke.pdf
Objective The purpose of this exercise is to create a Linke.pdfadvancethchnologies Objective: The purpose of this exercise is to create a Linked List data structure that mimics the
behavior of the Java Standard Library Version (Java API). The outcomes/results of using the
library features should be identical with your own version (My API). However, the underlying
implementation should follow with the descriptions listed below.
Instructions : Create the following Linked List Data Structure with the given description below in
your utils package and use "for loops" for your repetitive tasks.
Where to find starter code in my-api
package.class : utils.LinkedList
package.class : tests.console.week04.LinkedListTest
Where to find your JUNIT test in my-api
package.class : tests.junit.LinkedListJUnitTest
Nested Class that has to be added to LinkedList class
package.class : utils.LinkedList.Node
Task Check List
ONLY "for" loops should be used within the data structure class. There is an automatic 30%
deduction, if other loops are used.
The names of identifiers MUST match the names listed in the description below. Deductions
otherwise.
Complete coding Assignment in your "my-api" GitHub Repository. You will not be graded
otherwise and will receive a 0, if not uploaded there.
Run JUNIT TEST and take a SNAPSHOT of results. Upload PDF of snapshot of your JUnitTest
results to Canvas.
Description
The internal structure of the Linked List is a doubly linked Node data structure and should have
at a minimum the following specifications:
data fields: The data fields to declare are private and you will keep track of the size of the list with
the variable size and the start of the list with the reference variable data.
first is a reference variable for the first Node<E> in the list.
last is a reference variable for the last Node<E> in the list.
size keeps track of the number of nodes in the list of type int. This will allow you to know the
current size of the list without having to traversing the list.
constructors: The overloaded constructors will initialize the data fields size and data.
A constructor that is a default constructor initializes the starting node location first and size to a
zero equivalent, that is, constructs an empty list.
methods: methods that manages the behavior of the linked nodes.
Together, the methods below give the illusion of a index or countable location. Implement these
methods within your generic Linked List class.
Method
Description
Header
public boolean add(E item)
public void add(int index, E item)
public void append( E item)
private void checkIndex(int index)
public boolean contains(E item)
public void clear()
private E detach(int index)
public E get(int index)
public int indexOf(E item)
private void insertBefore(int index, E item)
public boolean isEmpty()
private Node<E> node(int index)
public E remove(int index)
public boolean remove(E item)
public E set(int index, E item)
public int size()
public String toString()
Node Data Structure
The generic Linked List class includes a static Node class as a nested class, .
Objective The purpose of this exercise is to create a Linke.pdf
Objective The purpose of this exercise is to create a Linke.pdfgiriraj65 Objective: The purpose of this exercise is to create a Linked List data structure that mimics the
behavior of the Java Standard Library Version (Java API). The outcomes/results of using the
library features should be identical with your own version (My API). However, the underlying
implementation should follow with the descriptions listed below.
Instructions : Create the following Linked List Data Structure with the given description below in
your utils package and use "for loops" for your repetitive tasks.
Where to find starter code in my-api
package.class : utils.LinkedList
package.class : tests.console.week04.LinkedListTest
Where to find your JUNIT test in my-api
package.class : tests.junit.LinkedListJUnitTest
Nested Class that has to be added to LinkedList class
package.class : utils.LinkedList.Node
Task Check List
ONLY "for" loops should be used within the data structure class. There is an automatic 30%
deduction, if other loops are used.
The names of identifiers MUST match the names listed in the description below. Deductions
otherwise.
Complete coding Assignment in your "my-api" GitHub Repository. You will not be graded
otherwise and will receive a 0, if not uploaded there.
Run JUNIT TEST and take a SNAPSHOT of results. Upload PDF of snapshot of your JUnitTest
results to Canvas.
Description
The internal structure of the Linked List is a doubly linked Node data structure and should have
at a minimum the following specifications:
data fields: The data fields to declare are private and you will keep track of the size of the list with
the variable size and the start of the list with the reference variable data.
first is a reference variable for the first Node<E> in the list.
last is a reference variable for the last Node<E> in the list.
size keeps track of the number of nodes in the list of type int. This will allow you to know the
current size of the list without having to traversing the list.
constructors: The overloaded constructors will initialize the data fields size and data.
A constructor that is a default constructor initializes the starting node location first and size to a
zero equivalent, that is, constructs an empty list.
methods: methods that manages the behavior of the linked nodes.
Together, the methods below give the illusion of a index or countable location. Implement these
methods within your generic Linked List class.
Method
Description
Header
public boolean add(E item)
public void add(int index, E item)
public void append( E item)
private void checkIndex(int index)
public boolean contains(E item)
public void clear()
private E detach(int index)
public E get(int index)
public int indexOf(E item)
private void insertBefore(int index, E item)
public boolean isEmpty()
private Node<E> node(int index)
public E remove(int index)
public boolean remove(E item)
public E set(int index, E item)
public int size()
public String toString()
Node Data Structure
The generic Linked List class includes a static Node class as a nested class, .
hi i have to write a java program involving link lists. i have a pro.pdf
hi i have to write a java program involving link lists. i have a pro.pdfarchgeetsenterprises hi i have to write a java program involving link lists. i have a problem with the nodes, as it is
posting errors with the nodes.
please help me with this problem. thank you.
public class LinkLists {
/* only need to store a single pointer to the node at the head
* of the list.
* The pointer is null if the list is empty.
* Also record the size of the list.
*/
protected Node head;
/* invariant: size is the number of nodes in the list pointed to by head */
protected int size;
/* no-arguments default constructor creates an empty list */
public LinkLists() {
head = null; // start with an empty list
size = 0;
}
/* accessor method */
public int size() {
return size;
}
/* value to add to the end of the list
*/
public void add(T value) {
head = addAtEnd(head, value);
size++;
}
/* node of the list to which the value should be added
* value to add to the end of the list
*/
private Node addAtEnd(Node node, T value) {
if (node == null) { // special case
return new Node(value, null);
} else if (node.getNext() == null) { // other special case
node.setNext(new Node(value, null));
} else {
addAtEnd(node.getNext(), value);
}
return node;
}
/* iterative implementation of the same method
* value to add to the end of the list
*/
public void add2(T value) {
if (head == null) {
head = new Node(value, null);
} else {
Node node = head; // guaranteed not to be null initially
while (node.getNext() != null) {
node = node.getNext(); // guaranteed not to be null here
}
// now, node.getNext() is guaranteed to be null
// similar to the second special case in addAtEnd
node.setNext(new Node(value, null));
}
size++;
}
public void remove(int position) throws BadItemCountException {
if ((position < 1) || (position > size)) {
throw new
BadItemCountException(\"invalid position \" + position +
\", only 1..\" + size + \" available\");
}
if (position == 1) {
head = head.getNext();
} else {
Node node = head;
for (int i = 2; i < position; i++) {
node = node.getNext();
}
node.setNext(node.getNext().getNext());
}
size--; // one less item
}
public String toString() {
return toString(head);
}
private String toString(Node node) {
if (node == null) {
return \"\";
} else {
return node.getValue() + \"\ \" + toString(node.getNext());
}
}
public static void main(String[] args) {
/* create two empty lists, make sure they print out correctly */
LinkLists list1 = new LinkLists();
LinkLists list2 = new LinkLists();
System.out.println(\"list1 = \'\" + list1 + \"\', list2 = \'\" + list2 + \"\'\");
System.out.println(\"list1.size() = \" + list1.size() +
\", list2.size() = \" + list2.size());
/* insert some items, keep checking */
list1.add(\"hello\");
list1.add(\"world\");
list2.add(\"foo\");
list2.add(\"bar\");
list2.add(\"baz\");
System.out.println(\"list1 = \'\" + list1 + \"\', list2 = \'\" + list2 + \"\'\");
System.out.println(\"list1.size() = \" + list1.size() +
\", list2.size() = \" + list2.size());
/* remove an item at an invalid position */
boolean caught = false;
try {
list2.remove(4);
} catch .
Linked List Objective The purpose of this exercise is to cr.pdf
Linked List Objective The purpose of this exercise is to cr.pdfadityacomputers001 Linked List
Objective: The purpose of this exercise is to create a Linked List data structure that mimics the
behavior of the Java Standard Library Version (Java API). The outcomes/results of using the
library features should be identical with your own version (My API). However, the underlying
implementation should follow with the descriptions listed below.
Instructions : Create the following Linked List Data Structure with the given description below in
your utils package and use "for loops" for your repetitive tasks.
Where to find starter code in my-api
package.class : utils.LinkedList
package.class : tests.console.week04.LinkedListTest
Where to find your JUNIT test in my-api
package.class : tests.junit.LinkedListJUnitTest
Nested Class that has to be added to LinkedList class
package.class : utils.LinkedList.Node
Task Check List
ONLY "for" loops should be used within the data structure class. There is an automatic 30%
deduction, if other loops are used.
The names of identifiers MUST match the names listed in the description below. Deductions
otherwise.
Complete coding Assignment in your "my-api" GitHub Repository. You will not be graded
otherwise and will receive a 0, if not uploaded there.
Run JUNIT TEST and take a SNAPSHOT of results. Upload PDF of snapshot of your JUnitTest
results to Canvas.
Description
The internal structure of the Linked List is a doubly linked Node data structure and should have
at a minimum the following specifications:
data fields: The data fields to declare are private and you will keep track of the size of the list with
the variable size and the start of the list with the reference variable data.
first is a reference variable for the first Node<E> in the list.
last is a reference variable for the last Node<E> in the list.
size keeps track of the number of nodes in the list of type int. This will allow you to know the
current size of the list without having to traversing the list.
constructors: The overloaded constructors will initialize the data fields size and data.
A constructor that is a default constructor initializes the starting node location first and size to a
zero equivalent, that is, constructs an empty list.
methods: methods that manages the behavior of the linked nodes.
Together, the methods below give the illusion of a index or countable location. Implement these
methods within your generic Linked List class.
Method
Description
Header
public boolean add(E item)
public void add(int index, E item)
public void append( E item)
private void checkIndex(int index)
public boolean contains(E item)
public void clear()
private E detach(int index)
public E get(int index)
public int indexOf(E item)
private void insertBefore(int index, E item)
public boolean isEmpty()
private Node<E> node(int index)
public E remove(int index)
public boolean remove(E item)
public E set(int index, E item)
public int size()
public String toString()
Node Data Structure
The generic Linked List class includes a static Node class as a ne.
Use the singly linked list class introduced in the lab to implement .pdf
Use the singly linked list class introduced in the lab to implement .pdfsales87 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 (addition, subtraction, multiplication) and then display the
result. The program will stop upon entering the # character (without the double quotes).
this singly linked list class:
public class SLL {
private class SLLNode {
private T info;
private SLLNode next;
int value;
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;
w.
-JAVA-provide a test class that do the required -you may add met.pdf
-JAVA-provide a test class that do the required -you may add met.pdfalphawheels007 -JAVA-
provide a test class that do the required
-you may add methods you need in the SLL-
//************************** SLL.java *********************************
// a generic 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;
}
//
// Please write the methods of Task02 here:
//
public void insertBefore(int index, T newElem) throws Exception {
//throws exception if the list is empty
if(isEmpty()){
throw new Exception("list is empty");
}
//inserts
if(index < size()){
if (index == 0){
SLLNode newnode = new SLLNode<>(newElem, head);
head = newnode;
}
else{
SLLNode temp = head;
SLLNode newnode = new SLLNode<>(newElem, null);
for (int i = 0; i < index - 1; i++) {
temp = temp.next;
}
newnode.next = .
Write a program in C++ that declares a structure to store the code n.pdf
Write a program in C++ that declares a structure to store the code n.pdffathimalinks Write a program in C++ that declares a structure to store the code number, salary and grade of an
employee. The program defines two structures variables, inputs records of two employees and
then displays the record of the employees.
Solution
#include
#include
using namespace std;
struct employee
{
int codenumber[7];
char grade[14];
float salary;
};
int main(void)
{
struct employee ;
cout<<\'\ .......................................: \" ;
cout<<\"\ enter the employee code number: \" ;
gets(employee.codenumber);
cout<<\"\ enter the employee grade: \" ;
gets(employee.grade);
cout<<\"\ enter the employee salary: \" ;
gets(employee.salary);
return (employee);
}
int list_function(employee list)
{
cout<<\"\ employee codenumber: \" <.
Write a generic VBA Sub procedure to compute the value of the follow.pdf
Write a generic VBA Sub procedure to compute the value of the follow.pdffathimalinks Write a generic VBA Sub procedure to compute the value of the following Integral (I) using the
Trapezoidal Rule. dac
Solution
// Trapazoidal rule calculates area under the curve
// n is number of interval
Function Integration(a As Integer, b as Integer, n As Integer) As Double
Dim sum as Double
sum = (F(a) + F(b))/2
For i = 1 To n - 1
sum = sum + F(a + ((b-a)/n)*i)
Next i
Integration = sum * (b-a)/n
End Function.
More Related Content
Similar to Write the following using javaGiven a class ‘Node’ and ‘NodeList’,.pdf (20)
Please and Thank youObjective The purpose of this exercise is to .pdf
Please and Thank youObjective The purpose of this exercise is to .pdfalicesilverblr Please and Thank you
Objective: The purpose of this exercise is to create a Linked List data structure that mimics the
behavior of the Java Standard Library Version (Java API). The outcomes/results of using the
library features should be identical with your own version (My API). However, the underlying
implementation should follow with the descriptions listed below.
Instructions : Create the following Linked List Data Structure with the given description below
in your utils package and use "for loops" for your repetitive tasks.
Where to find starter code in my-api
package.class : utils.LinkedList
package.class : tests.console.week04.LinkedListTest
Where to find your JUNIT test in my-api
package.class : tests.junit.LinkedListJUnitTest
Nested Class that has to be added to LinkedList class
package.class : utils.LinkedList.Node
Task Check List
ONLY "for" loops should be used within the data structure class. There is an automatic 30%
deduction, if other loops are used.
The names of identifiers MUST match the names listed in the description below. Deductions
otherwise.
Complete coding Assignment in your "my-api" GitHub Repository. You will not be graded
otherwise and will receive a 0, if not uploaded there.
Run JUNIT TEST and take a SNAPSHOT of results. Upload PDF of snapshot of your JUnitTest
results to Canvas.
Description
The internal structure of the Linked List is a doubly linked Node data structure and should have
at a minimum the following specifications:
data fields: The data fields to declare are private and you will keep track of the size of the list
with the variable size and the start of the list with the reference variable data.
first is a reference variable for the first Node in the list.
last is a reference variable for the last Node in the list.
size keeps track of the number of nodes in the list of type int. This will allow you to know the
current size of the list without having to traversing the list.
constructors: The overloaded constructors will initialize the data fields size and data.
A constructor that is a default constructor initializes the starting node location first and size to a
zero equivalent, that is, constructs an empty list.
methods: methods that manages the behavior of the linked nodes.
Together, the methods below give the illusion of a index or countable location. Implement these
methods within your generic Linked List class.
Method
Description
Header
public boolean add(E item)
public void add(int index, E item)
public void append( E item)
private void checkIndex(int index)
public boolean contains(E item)
public void clear()
private E detach(int index)
public E get(int index)
public int indexOf(E item)
private void insertBefore(int index, E item)
public boolean isEmpty()
private Node node(int index)
public E remove(int index)
public boolean remove(E item)
public E set(int index, E item)
public int size()
public String toString()
Node Data Structure
The generic Linked List class includes a static Node class as a ne.
In this assignment you will implement insert() method for a singly l.pdf
In this assignment you will implement insert() method for a singly l.pdffantasiatheoutofthef In this assignment you will implement insert() method for a singly linked Link list. The code
MyLinkedlist.java is given , it uses generic type as the linked list can be created with any object
type. Some methods like add() and toString() are already implemented. The MyLinkedList class
has a private nested class called Node.
The objective of this assignment is to implement the insert() method that takes two inputs an
element of generic type to be inserted and an index (value of integer type) at which it should be
inserted. For this assignment we will assume the first element has the index 0. if the given index
is less than zero do nothing but if it is greater than the size of the list, insert the element at the
end of the list. if the index is between 0 and size , insert it in the appropriate location. You insert
code should correctly update the theSize data member of the linked list. Return type for insert()
method is boolean (true or false) depending on whether the insertion was successful or not. Use
the following method header.
}
Main.java
//add necessary libraries
public class Main
{
//add your function here
public static void main (String [] args)
{
}
}
MyLinkedList.java
public class MyLinkedList {
// A private nested Node class
private static class Node{
public AnyType data; // Data members are public, this is fine as the Node class itself is
private
public Node next;
public Node(AnyType d, Node n)
{
data = d;
next=n;
}
@Override
public String toString() {
return data.toString();
}
}
// Data Members
private Node head; // A node pointer to the first item in the List
private int theSize; // a integer variable to hold the size of the List
public MyLinkedList() {
doClear();
}
public void clear() {
doClear();
}
private void doClear() {
head = null;
theSize =0 ;
}
// An add method that will always add at the beginning of the List
public boolean add(AnyType x) {
if(head == null) // List is empty
{
head = new Node(x, null);
theSize++;
return true;
}
else // List has at least one item lets get to the end of it
{
Node newnode = new Node(x, head);
head = newnode;
theSize++;
return true;
}
}
@Override
public String toString() {
// This to String method will print the List from head to the end.
String theList = "";
if(head==null)
return theList;
Node cur = head;
while(cur.next!=null) {
theList = theList + cur.toString() + " ";
cur= cur.next;
}
return theList + cur.toString();
}
public int getTheSize() {
return theSize;
}
}
/*****************************************************************************
*
*
* SOLUTION CODE BELOW THIS HEADER
*
*****************************************************************************/
/*****************************************************************************
*
*
* SOLUTION CODE ABOVE THIS HEADER
*
*****************************************************************************/
}
Current file: Main.java Load default template... //add necessary Libraries public class Main \{
//add your function here public static vo.
Rewrite this code so it can use a generic type instead of integers. .pdf
Rewrite this code so it can use a generic type instead of integers. .pdfalphaagenciesindia Rewrite this code so it can use a generic type instead of integers. This means we can use any data
type with it.
For example:
LinkedList = new LinkedLIst<>();
public class Main {
public static void main(String[] args) {
/*
* Expected output:
*
* The list: 8 -> 1 -> 5 -> 3 -> 6
* Size: 5
* Head: 8
* Tail: 6
* Removeing 1...
* The list: 8 -> 5 -> 3 -> 6
* Size: 4
* Head: 8
* Tail: 6
* Removeing head...
* The list: 5 -> 3 -> 6
* Size: 3
* Head: 5
* Tail: 6
* Removeing tail...
* The list: 5 -> 3
* Size: 2
* Head: 5
* Tail: 3
*/
LinkedList list = new LinkedList();
list.append(5);
list.append(3);
list.append(6);
list.prepend(1);
list.prepend(8);
printListDetails(list);
System.out.println("Removeing 1...");
list.removeByValue(1);
printListDetails(list);
System.out.println("Removeing head...");
list.removeHead();
printListDetails(list);
System.out.println("Removeing tail...");
list.removeTail();
printListDetails(list);
}
public static void printListDetails(LinkedList list) {
System.out.println("The list: " + list.toString());
System.out.println("Size: " + list.size());
System.out.println("Head: " + list.getHead());
System.out.println("Tail: " + list.getTail());
}
}
________________________________________
public class LinkedList {
private Node head;
private Node tail;
private int size;
public LinkedList() {
head = null;
tail = null;
size = 0;
}
public void append(int data) {
Node newNode = new Node(data);
if (head == null) {
head = newNode;
} else {
tail.next = newNode;
}
tail = newNode;
size++;
}
public void prepend(int data) {
Node newNode = new Node(data);
if (head == null) {
head = newNode;
tail = newNode;
} else {
newNode.next = head;
head = newNode;
}
size++;
}
public int getHead() {
return head.data;
}
public int getTail() {
return tail.data;
}
public int size() {
return size;
}
public void removeByValue(int data) {
Node current = head;
while (current.next != null && current.next.data != data) {
current = current.next;
}
if (current.next != null) {
current.next = current.next.next;
size--;
if (current.next == null) {
tail = current;
}
}
}
public int removeHead() {
int removedData = head.data;
head = head.next;
size--;
if (head == null) {
tail = null;
}
return removedData;
}
public int removeTail() {
int removedData = tail.data;
if (head == tail) {
head = null;
tail = null;
} else {
Node current = head;
while (current.next != tail) {
current = current.next;
}
tail = current;
tail.next = null;
}
size--;
return removedData;
}
@Override
public String toString() {
StringBuilder builder = new StringBuilder();
Node current = head;
while (current != null) {
builder.append(current.data);
if (current.next != null) {
builder.append(" -> ");
}
current = current.next;
}
return builder.toString();
}
private class Node {
public Node next;
public int data;
public Node(int data) {
this.data = data;
}
}
}.
Objective The purpose of this exercise is to create a Linked List d.pdf
Objective The purpose of this exercise is to create a Linked List d.pdfaliracreations Objective: The purpose of this exercise is to create a Linked List data structure that mimics the
behavior of the Java Standard Library Version (Java API). The outcomes/results of using the
library features should be identical with your own version (My API). However, the underlying
implementation should follow with the descriptions listed below.
Instructions : Create the following Linked List Data Structure with the given description below
in your utils package and use "for loops" for your repetitive tasks.
Where to find starter code in my-api
package.class : utils.LinkedList
package.class : tests.console.week04.LinkedListTest
Where to find your JUNIT test in my-api
package.class : tests.junit.LinkedListJUnitTest
Nested Class that has to be added to LinkedList class
package.class : utils.LinkedList.Node
Task Check List
ONLY "for" loops should be used within the data structure class. There is an automatic 30%
deduction, if other loops are used.
The names of identifiers MUST match the names listed in the description below. Deductions
otherwise.
Complete coding Assignment in your "my-api" GitHub Repository. You will not be graded
otherwise and will receive a 0, if not uploaded there.
Run JUNIT TEST and take a SNAPSHOT of results. Upload PDF of snapshot of your JUnitTest
results to Canvas.
Description
The internal structure of the Linked List is a doubly linked Node data structure and should have
at a minimum the following specifications:
data fields: The data fields to declare are private and you will keep track of the size of the list
with the variable size and the start of the list with the reference variable data.
first is a reference variable for the first Node in the list.
last is a reference variable for the last Node in the list.
size keeps track of the number of nodes in the list of type int. This will allow you to know the
current size of the list without having to traversing the list.
constructors: The overloaded constructors will initialize the data fields size and data.
A constructor that is a default constructor initializes the starting node location first and size to a
zero equivalent, that is, constructs an empty list.
methods: methods that manages the behavior of the linked nodes.
Together, the methods below give the illusion of a index or countable location. Implement these
methods within your generic Linked List class.
Method
Description
Header
public boolean add(E item)
public void add(int index, E item)
public void append( E item)
private void checkIndex(int index)
public boolean contains(E item)
public void clear()
private E detach(int index)
public E get(int index)
public int indexOf(E item)
private void insertBefore(int index, E item)
public boolean isEmpty()
private Node node(int index)
public E remove(int index)
public boolean remove(E item)
public E set(int index, E item)
public int size()
public String toString()
Node Data Structure
The generic Linked List class includes a static Node class as a nested class, i.e. a st.
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.
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.
Can someone help me to fix the code please package dlist i.pdf
Can someone help me to fix the code please package dlist i.pdfABHISHEKREADYMADESKO Can someone help me to fix the code please?
package dlist;
import java.util.Iterator;
public class DList implements Iterable<String> {
private static class DListNode {
public String data;
public DListNode next;
public DListNode previous;
}
private DListNode nil;
private int size;
public DList() {
nil = new DListNode();
nil.previous = nil;
nil.next = nil;
nil.data = null;
size = 0;
}
public void addFirst(String elem) {
DListNode newNode = new DListNode();
newNode.data = elem;
newNode.next = nil.next;
newNode.previous = nil;
nil.next.previous = newNode;
nil.next = newNode;
size++;
}
public void addLast(String elem) {
DListNode newNode = new DListNode();
newNode.data = elem;
newNode.next = nil;
newNode.previous = nil.previous;
nil.previous.next = newNode;
nil.previous = newNode;
size++;
}
public String getFirst() {
if (size == 0) {
throw new RuntimeException("DList is empty");
}
return nil.next.data;
}
public String getLast() {
if (size == 0) {
throw new RuntimeException("DList is empty");
}
return nil.previous.data;
}
public String removeFirst() {
if (size == 0) {
throw new RuntimeException("DList is empty");
}
DListNode first = nil.next;
first.next.previous = nil;
nil.next = first.next;
size--;
return first.data;
}
public String removeLast() {
if (size == 0) {
throw new RuntimeException("DList is empty");
}
DListNode last = nil.previous;
last.previous.next = nil;
nil.previous = last.previous;
size--;
return last.data;
}
public String get(int index) {
if (index < 0 || index >= size) {
throw new IndexOutOfBoundsException();
}
DListNode node = nil.next;
for (int i = 0; i < index; i++) {
node = node.next;
}
return node.data;
}
public String set(int index, String value) {
if (index < 0 || index >= size) {
throw new IndexOutOfBoundsException();
}
DListNode node = nil.next;
for (int i = 0; i < index; i++) {
node = node.next;
}
String oldValue = node.data;
node.data = value;
return oldValue;
}
public boolean contains(Object obj) {
DListNode node = nil.next;
while (node != nil) {
if (node.data.equals(obj)) {
return true;
}
node = node.next;
}
return false;
}
public int size() {
return size;
}
public int indexOf(Object obj)
{
int index = 0;
DListNode node = nil.next;
while (node != nil)
{
if (node.data.equals(obj))
{
return index;
}
index++;
node = node.next;
}
return -1;
}
@Override
public Iterator<String> iterator()
{
return new DListIterator();
}
private class DListIterator implements Iterator<String>
{
private DListNode pointer;
public DListIterator()
{
if(nil.next==nil)
{
pointer = nil;
}
else
pointer=nil.next;
}
public boolean hasNext()
{
return pointer != nil;
}
}
}.
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 =.
This is problem is same problem which i submitted on 22017, I just.pdf
This is problem is same problem which i submitted on 22017, I just.pdffcaindore There is a host of sociological and cultural research that paints a robust picture of the effects of
globalization on culture. This Application focuses on the flows of culture between Western and
developing nations. As a practitioner in this global environment, you should be familiar with
these culture effects. Use newspapers, magazines, and the Internet to research cultural changes in
both Western and developing countries due to globalization. Then perform the following tasks:
Outline the cultural aspects of globalization. Take an anthropological, rather than a business,
perspective. Explain how you think understanding culture helps in doing business in today\'s
global economy. Cite resources to justify your response.
Solution
Information technology has penetrated almost every aspect of our lives, “shrinking” our world
into a global village.
Economies and cultures have come closer. People are now aware of the cultures, traditions,
lifestyle, living conditions
prevailing in almost every corner of the world. Interestingly, this is going beyond awareness and
into a state of
integration that is a result of cross-pollinated views, ideologies, products and services.
This evolution is termed as “globalization.”
Culture has many definitions. My own definition is that culture is our collective experience as a
society,
and its impact on our reaction and decision-making relative to every-day facts and
circumstances.
Why is cross-cultural competence critical to your professional future and the viability of your
company?
It’s omnipresent in every business interaction and strategic decision.It is not feasible to be an
expert on
all the world’s cultures. It is possible, however, to incorporate a cross-cultural framework that
improves
cross-cultural understanding and interactions.
Multinational firms whose operations are borderless have to consider the cultural variability of
different regions
of the world and develop cultural understanding. Major cultural constraints encountered by
businesses include local
attitudes, taste preferences, language, religion, management style, gender discrimination, skills,
personalities,
education, etc. To be successful, they need to mold their business actions in accordance with the
local cultural models,
they need to establish a global mindset.
Let’s consider an example of the food giant, McDonald’s. The company enjoys a global
presence; operating in more than
100 countries serving 70 million people every day. Their headquarters and senior management
are U.S.-based but they
entrust their local operations to local managers of the countries they operate in. Operations in
more than 50 percent of
their outlets are franchised. Furthermore, their menus are customized according to cultural
habits and local taste
preferences in every country. It is without a doubt that global thinking and cultural
understanding are both powerful
business tools which allow multinational firms to dominate the local markets and establish a
global pres.
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.
can you add a delete button and a add button to the below program. j.pdf
can you add a delete button and a add button to the below program. j.pdfsales88 The document describes a Java program that implements a linked list of Car objects. It includes classes for the Car object with attributes like make, model, year, and color, and a NuLinkedList class that implements basic linked list functionality for adding, removing, and accessing Car elements. The program reads a file of cars into an ArrayList and provides buttons to navigate between cars, displaying the current car details. The request is to add delete and add buttons to allow removing and adding cars to the linked list from the GUI.
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.
Note Given Code modified as required and required met.pdf
Note Given Code modified as required and required met.pdfAnkitchhabra28 Note:
Given Code modified as required and required methods added.
Code:
// class node
class Node
{
// declare the required variable
String data;
Node next;
// constructor
Node(){}
// constructor with arguments
Node(String data)
{
this.data = data;
next = null;
}
// method to get the data
public String getData()
{
return data;
}
// method to set the data
public void setData(String data)
{
this.data = data;
}
// method to get the next data
public Node getNext()
{
return next;
}
// method to set the next data
public void setNext(Node next)
{
this.next = next;
}
}
// class for a linked list
class MyLInkedList
{
Node head;alue into a list
// method to add the v
public void add(String num)
{
if (head == null)
{
head = new Node(num);
}
else{
Node temp = new Node(num);
Node current = head;
if (current != null) {
while (current.getNext() != null) {
current = current.getNext();
}
current.setNext(temp);
}
}
}
// method to search a value from a list
public void search(String num)
{
Node current = head;
boolean flag=true;
if (current != null)
{
while (current != null)
{
if(current.getData() == num)
{
System.out.println(\"Search value \"+
current.getData()+\" is available\");
flag=false;
}
current = current.getNext();
}
if (flag==true)
{
System.out.println(\"Search value \"+
current.getData()+\" is not available\");
}
}
else
{
System.out.println(\"Linked list is empty\");
}
}
// method to delete a value from a list
public void delete(String num)
{
//Node current = head;
boolean flag=true;
if (head == null)
{
System.out.println(\"Can\'t Delete, Linked list is
empty\");
return;
}
if(head.getData() == num)
{
head=head.getNext();
return;
}
Node temp = new Node(num);
Node cr = head;
Node prev=null;
while ((cr != null) && !(cr.getData() == num))
{
prev=cr;
cr = cr.getNext();
}
prev.setNext(cr.getNext());
}
// method to print the list
public void print()
{
Node current = head;
if (current != null) {
while (current != null) {
System.out.println(current.getData());
current = current.getNext();
}
}
}
}
// method to test the class
public class MyLInkedListTester
{
// main method to perform the linked list operatrions
public static void main(String args[])
{
MyLInkedList llist = new MyLInkedList();
// insert the values into list
llist.add(\"1\");
llist.add(\"2\");
llist.add(\"3\");
llist.add(\"4\");
// print the list values
llist.print();
// sear the values in a list
llist.search(\"1\");
llist.print();
// delete the value from a list
llist.delete(\"4\");
System.out.println(\"List after deletion:\");
llist.print();
}
}
Result:
1
2
3
4
Search value 1 is available
1
2
3
4
List after deletion:
1
2
3
Solution
Note:
Given Code modified as required and required methods added.
Code:
// class node
class Node
{
// declare the required variable
String data;
Node next;
// constructor
Node(){}
// constructor with arguments
Node(String data)
{
this.data = data;
next = null;
}
// method to get the data
public String getData()
{
return data;
}
// method to set the data
public void se.
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.
Objective The purpose of this exercise is to create a Linke.pdf
Objective The purpose of this exercise is to create a Linke.pdfadvancethchnologies Objective: The purpose of this exercise is to create a Linked List data structure that mimics the
behavior of the Java Standard Library Version (Java API). The outcomes/results of using the
library features should be identical with your own version (My API). However, the underlying
implementation should follow with the descriptions listed below.
Instructions : Create the following Linked List Data Structure with the given description below in
your utils package and use "for loops" for your repetitive tasks.
Where to find starter code in my-api
package.class : utils.LinkedList
package.class : tests.console.week04.LinkedListTest
Where to find your JUNIT test in my-api
package.class : tests.junit.LinkedListJUnitTest
Nested Class that has to be added to LinkedList class
package.class : utils.LinkedList.Node
Task Check List
ONLY "for" loops should be used within the data structure class. There is an automatic 30%
deduction, if other loops are used.
The names of identifiers MUST match the names listed in the description below. Deductions
otherwise.
Complete coding Assignment in your "my-api" GitHub Repository. You will not be graded
otherwise and will receive a 0, if not uploaded there.
Run JUNIT TEST and take a SNAPSHOT of results. Upload PDF of snapshot of your JUnitTest
results to Canvas.
Description
The internal structure of the Linked List is a doubly linked Node data structure and should have
at a minimum the following specifications:
data fields: The data fields to declare are private and you will keep track of the size of the list with
the variable size and the start of the list with the reference variable data.
first is a reference variable for the first Node<E> in the list.
last is a reference variable for the last Node<E> in the list.
size keeps track of the number of nodes in the list of type int. This will allow you to know the
current size of the list without having to traversing the list.
constructors: The overloaded constructors will initialize the data fields size and data.
A constructor that is a default constructor initializes the starting node location first and size to a
zero equivalent, that is, constructs an empty list.
methods: methods that manages the behavior of the linked nodes.
Together, the methods below give the illusion of a index or countable location. Implement these
methods within your generic Linked List class.
Method
Description
Header
public boolean add(E item)
public void add(int index, E item)
public void append( E item)
private void checkIndex(int index)
public boolean contains(E item)
public void clear()
private E detach(int index)
public E get(int index)
public int indexOf(E item)
private void insertBefore(int index, E item)
public boolean isEmpty()
private Node<E> node(int index)
public E remove(int index)
public boolean remove(E item)
public E set(int index, E item)
public int size()
public String toString()
Node Data Structure
The generic Linked List class includes a static Node class as a nested class, .
Objective The purpose of this exercise is to create a Linke.pdf
Objective The purpose of this exercise is to create a Linke.pdfgiriraj65 Objective: The purpose of this exercise is to create a Linked List data structure that mimics the
behavior of the Java Standard Library Version (Java API). The outcomes/results of using the
library features should be identical with your own version (My API). However, the underlying
implementation should follow with the descriptions listed below.
Instructions : Create the following Linked List Data Structure with the given description below in
your utils package and use "for loops" for your repetitive tasks.
Where to find starter code in my-api
package.class : utils.LinkedList
package.class : tests.console.week04.LinkedListTest
Where to find your JUNIT test in my-api
package.class : tests.junit.LinkedListJUnitTest
Nested Class that has to be added to LinkedList class
package.class : utils.LinkedList.Node
Task Check List
ONLY "for" loops should be used within the data structure class. There is an automatic 30%
deduction, if other loops are used.
The names of identifiers MUST match the names listed in the description below. Deductions
otherwise.
Complete coding Assignment in your "my-api" GitHub Repository. You will not be graded
otherwise and will receive a 0, if not uploaded there.
Run JUNIT TEST and take a SNAPSHOT of results. Upload PDF of snapshot of your JUnitTest
results to Canvas.
Description
The internal structure of the Linked List is a doubly linked Node data structure and should have
at a minimum the following specifications:
data fields: The data fields to declare are private and you will keep track of the size of the list with
the variable size and the start of the list with the reference variable data.
first is a reference variable for the first Node<E> in the list.
last is a reference variable for the last Node<E> in the list.
size keeps track of the number of nodes in the list of type int. This will allow you to know the
current size of the list without having to traversing the list.
constructors: The overloaded constructors will initialize the data fields size and data.
A constructor that is a default constructor initializes the starting node location first and size to a
zero equivalent, that is, constructs an empty list.
methods: methods that manages the behavior of the linked nodes.
Together, the methods below give the illusion of a index or countable location. Implement these
methods within your generic Linked List class.
Method
Description
Header
public boolean add(E item)
public void add(int index, E item)
public void append( E item)
private void checkIndex(int index)
public boolean contains(E item)
public void clear()
private E detach(int index)
public E get(int index)
public int indexOf(E item)
private void insertBefore(int index, E item)
public boolean isEmpty()
private Node<E> node(int index)
public E remove(int index)
public boolean remove(E item)
public E set(int index, E item)
public int size()
public String toString()
Node Data Structure
The generic Linked List class includes a static Node class as a nested class, .
hi i have to write a java program involving link lists. i have a pro.pdf
hi i have to write a java program involving link lists. i have a pro.pdfarchgeetsenterprises hi i have to write a java program involving link lists. i have a problem with the nodes, as it is
posting errors with the nodes.
please help me with this problem. thank you.
public class LinkLists {
/* only need to store a single pointer to the node at the head
* of the list.
* The pointer is null if the list is empty.
* Also record the size of the list.
*/
protected Node head;
/* invariant: size is the number of nodes in the list pointed to by head */
protected int size;
/* no-arguments default constructor creates an empty list */
public LinkLists() {
head = null; // start with an empty list
size = 0;
}
/* accessor method */
public int size() {
return size;
}
/* value to add to the end of the list
*/
public void add(T value) {
head = addAtEnd(head, value);
size++;
}
/* node of the list to which the value should be added
* value to add to the end of the list
*/
private Node addAtEnd(Node node, T value) {
if (node == null) { // special case
return new Node(value, null);
} else if (node.getNext() == null) { // other special case
node.setNext(new Node(value, null));
} else {
addAtEnd(node.getNext(), value);
}
return node;
}
/* iterative implementation of the same method
* value to add to the end of the list
*/
public void add2(T value) {
if (head == null) {
head = new Node(value, null);
} else {
Node node = head; // guaranteed not to be null initially
while (node.getNext() != null) {
node = node.getNext(); // guaranteed not to be null here
}
// now, node.getNext() is guaranteed to be null
// similar to the second special case in addAtEnd
node.setNext(new Node(value, null));
}
size++;
}
public void remove(int position) throws BadItemCountException {
if ((position < 1) || (position > size)) {
throw new
BadItemCountException(\"invalid position \" + position +
\", only 1..\" + size + \" available\");
}
if (position == 1) {
head = head.getNext();
} else {
Node node = head;
for (int i = 2; i < position; i++) {
node = node.getNext();
}
node.setNext(node.getNext().getNext());
}
size--; // one less item
}
public String toString() {
return toString(head);
}
private String toString(Node node) {
if (node == null) {
return \"\";
} else {
return node.getValue() + \"\ \" + toString(node.getNext());
}
}
public static void main(String[] args) {
/* create two empty lists, make sure they print out correctly */
LinkLists list1 = new LinkLists();
LinkLists list2 = new LinkLists();
System.out.println(\"list1 = \'\" + list1 + \"\', list2 = \'\" + list2 + \"\'\");
System.out.println(\"list1.size() = \" + list1.size() +
\", list2.size() = \" + list2.size());
/* insert some items, keep checking */
list1.add(\"hello\");
list1.add(\"world\");
list2.add(\"foo\");
list2.add(\"bar\");
list2.add(\"baz\");
System.out.println(\"list1 = \'\" + list1 + \"\', list2 = \'\" + list2 + \"\'\");
System.out.println(\"list1.size() = \" + list1.size() +
\", list2.size() = \" + list2.size());
/* remove an item at an invalid position */
boolean caught = false;
try {
list2.remove(4);
} catch .
Linked List Objective The purpose of this exercise is to cr.pdf
Linked List Objective The purpose of this exercise is to cr.pdfadityacomputers001 Linked List
Objective: The purpose of this exercise is to create a Linked List data structure that mimics the
behavior of the Java Standard Library Version (Java API). The outcomes/results of using the
library features should be identical with your own version (My API). However, the underlying
implementation should follow with the descriptions listed below.
Instructions : Create the following Linked List Data Structure with the given description below in
your utils package and use "for loops" for your repetitive tasks.
Where to find starter code in my-api
package.class : utils.LinkedList
package.class : tests.console.week04.LinkedListTest
Where to find your JUNIT test in my-api
package.class : tests.junit.LinkedListJUnitTest
Nested Class that has to be added to LinkedList class
package.class : utils.LinkedList.Node
Task Check List
ONLY "for" loops should be used within the data structure class. There is an automatic 30%
deduction, if other loops are used.
The names of identifiers MUST match the names listed in the description below. Deductions
otherwise.
Complete coding Assignment in your "my-api" GitHub Repository. You will not be graded
otherwise and will receive a 0, if not uploaded there.
Run JUNIT TEST and take a SNAPSHOT of results. Upload PDF of snapshot of your JUnitTest
results to Canvas.
Description
The internal structure of the Linked List is a doubly linked Node data structure and should have
at a minimum the following specifications:
data fields: The data fields to declare are private and you will keep track of the size of the list with
the variable size and the start of the list with the reference variable data.
first is a reference variable for the first Node<E> in the list.
last is a reference variable for the last Node<E> in the list.
size keeps track of the number of nodes in the list of type int. This will allow you to know the
current size of the list without having to traversing the list.
constructors: The overloaded constructors will initialize the data fields size and data.
A constructor that is a default constructor initializes the starting node location first and size to a
zero equivalent, that is, constructs an empty list.
methods: methods that manages the behavior of the linked nodes.
Together, the methods below give the illusion of a index or countable location. Implement these
methods within your generic Linked List class.
Method
Description
Header
public boolean add(E item)
public void add(int index, E item)
public void append( E item)
private void checkIndex(int index)
public boolean contains(E item)
public void clear()
private E detach(int index)
public E get(int index)
public int indexOf(E item)
private void insertBefore(int index, E item)
public boolean isEmpty()
private Node<E> node(int index)
public E remove(int index)
public boolean remove(E item)
public E set(int index, E item)
public int size()
public String toString()
Node Data Structure
The generic Linked List class includes a static Node class as a ne.
Use the singly linked list class introduced in the lab to implement .pdf
Use the singly linked list class introduced in the lab to implement .pdfsales87 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 (addition, subtraction, multiplication) and then display the
result. The program will stop upon entering the # character (without the double quotes).
this singly linked list class:
public class SLL {
private class SLLNode {
private T info;
private SLLNode next;
int value;
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;
w.
-JAVA-provide a test class that do the required -you may add met.pdf
-JAVA-provide a test class that do the required -you may add met.pdfalphawheels007 -JAVA-
provide a test class that do the required
-you may add methods you need in the SLL-
//************************** SLL.java *********************************
// a generic 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;
}
//
// Please write the methods of Task02 here:
//
public void insertBefore(int index, T newElem) throws Exception {
//throws exception if the list is empty
if(isEmpty()){
throw new Exception("list is empty");
}
//inserts
if(index < size()){
if (index == 0){
SLLNode newnode = new SLLNode<>(newElem, head);
head = newnode;
}
else{
SLLNode temp = head;
SLLNode newnode = new SLLNode<>(newElem, null);
for (int i = 0; i < index - 1; i++) {
temp = temp.next;
}
newnode.next = .
More from fathimalinks (20)
Write a program in C++ that declares a structure to store the code n.pdf
Write a program in C++ that declares a structure to store the code n.pdffathimalinks Write a program in C++ that declares a structure to store the code number, salary and grade of an
employee. The program defines two structures variables, inputs records of two employees and
then displays the record of the employees.
Solution
#include
#include
using namespace std;
struct employee
{
int codenumber[7];
char grade[14];
float salary;
};
int main(void)
{
struct employee ;
cout<<\'\ .......................................: \" ;
cout<<\"\ enter the employee code number: \" ;
gets(employee.codenumber);
cout<<\"\ enter the employee grade: \" ;
gets(employee.grade);
cout<<\"\ enter the employee salary: \" ;
gets(employee.salary);
return (employee);
}
int list_function(employee list)
{
cout<<\"\ employee codenumber: \" <.
Write a generic VBA Sub procedure to compute the value of the follow.pdf
Write a generic VBA Sub procedure to compute the value of the follow.pdffathimalinks Write a generic VBA Sub procedure to compute the value of the following Integral (I) using the
Trapezoidal Rule. dac
Solution
// Trapazoidal rule calculates area under the curve
// n is number of interval
Function Integration(a As Integer, b as Integer, n As Integer) As Double
Dim sum as Double
sum = (F(a) + F(b))/2
For i = 1 To n - 1
sum = sum + F(a + ((b-a)/n)*i)
Next i
Integration = sum * (b-a)/n
End Function.
Why are standards needed in data communication and networking What .pdf
Why are standards needed in data communication and networking What .pdffathimalinks Why are standards needed in data communication and networking? What are the advantages and
disadvantages of standards? How do standards fit in with regulations at the federal,
manufacturing, and organizational levels? Give an example of a standard that fits in at your
workplace.
Solution
he Importance of Standards
Standards are necessary in almost every business and public service entity. For example, before
1904, fire hose couplings in the United States were not standard, which meant a fire department
in one community could not help in another community. The transmission of electric current was
not standardized until the end of the nineteenth century, so customers had to choose between
Thomas Edison’s direct current (DC) and George Westinghouse’s alternating current (AC).
The primary reason for standards is to ensure that hardware and software produced by different
vendors can work together. Without networking standards, it would be difficult—if not
impossible—to develop networks that easily share information. Standards also mean that
customers are not locked into one vendor. They can buy hardware and software from any vendor
whose equipment meets the standard. In this way, standards help to promote more competition
and hold down prices.
The use of standards makes it much easier to develop software and hardware that link different
networks because software and hardware can be developed one layer at a time.
The Standards-Making Process
There are two types of standards: formal and de facto. A formal standard is developed by an
official industry or government body. For example, there are formal standards for applications
such as Web browsers (e.g., HTTP, HTML), for network layer software (e.g., IP), data link layer
software (e.g., Ethernet IEEE 802.3), and for physical hardware (e.g., V.90 modems). Formal
standards typically take several years to develop, during which time technology changes, making
them less useful.
De facto standards are those that emerge in the marketplace and are supported by several vendors
but have no official standing. For example, Microsoft Windows is a product of one company and
has not been formally recognized by any standards organization, yet it is a de facto standard. In
the communications industry, de facto standards often become formal standards once they have
been widely accepted.
The formal standardization process has three stages: specification, identification of choices, and
acceptance. The specification stage consists of developing a nomenclature and identifying the
problems to be addressed. In the identification of choices stage, those working on the standard
identify the various solutions and choose the optimum solution from among the alternatives.
Acceptance, which is the most difficult stage, consists of defining the solution and getting
recognized industry leaders to agree on a single, uniform solution. As with many other
organizational processes that have the potential to influence the sales of hardwar.
Which of the following are mismatched A. Giordia - transmitted by f.pdf
Which of the following are mismatched A. Giordia - transmitted by f.pdffathimalinks Which of the following are mismatched? A. Giordia - transmitted by faces in drinking water B.
Histoplasma - causes Ohio Valley fever C. Trichomonas - sexually transmitted D. Plasmodium
- causes chagas disease E. Saccharomyces - yeast in making bread and beer All of the following
are helminths except A. pinworm. B. flukes. C. ring worm. D. roundworm. E. tapeworm.
Solution
Answer 24]
The mismatched is
D} plasmodium = causes Chagas disease
Plasmodium falciparum is a protozoan parasite a special species of plasmodium cause malaria in
humans
It is transmitted by female anopheles mosquito
it does not causes chagos disease
Incorrect options are=
A] Giardia = transmitted by feces in drinking water
it is the most common cause of waterborne disease in united state
B ] Histoplasma =causes ohio valley fever
is disease caused by fungus Histoplasma capsulatum
C]Tricomonas = Sexually transmitted
it is sexually transmitted
e] Saccharomyces = yeast in making bread & cake
Answer 25=
All of the following are Helminths except
C] Ring worm
Explaination = It is a misnomer it leads to the assumption that this organism is helminths
Actually it is refers to the very common infection caused by some types of fungus
microsporum,Epidermophyton & trycophyton.
Which of the following statements about human evolution is correct.pdf
Which of the following statements about human evolution is correct.pdffathimalinks Which of the following statements about human evolution is correct?
A) The upright posture and enlarged brain of humans evolved simultaneously.
B) Fossil evidence indicates that early anthropoids were arboreal, were cat-sized, and lived about
35-45 million years ago.
C) Human ancestors were virtually identical to chimpanzees. D) Human evolution
occurred by anagenic change within an unbranched lineage.
E) Modern humans are the only human species to have evolved on Earth.
Please explain reasoning. Thank you.
Solution
B.Fossil evidence indicates that early anthropoids were arboreal, were cat-sized, and lived about
35-45 million years ago.
Reason:-The fossil record of Family Felidae extends to the Late Eocene, 34 million years
ago.The first known feline was Aelurogale. Its descendent, Proailurus, gave rise to the major
branches of the cat family we see today.Miacoid species gave rise to Proailurus which appeared
about 30 million years ago, and is generally considered the first true cat.There were other cat-like
species before Proailurus.Archeological evidence shows a relationship between man and cat for
the past 8,000 years..
What are the six major pollutions in the National Ambient Air Qualit.pdf
What are the six major pollutions in the National Ambient Air Qualit.pdffathimalinks What are the six major pollutions in the National Ambient Air Quality Standards (NAAQS)?
Briefly explain dry adiabatic lapse rate? What is the value of the dry adiabatic lapse rate? How
does the dry adiabatic lapse rate affect atmospheric stabillity?, Explain briefly In general, how
many stability categories can you name? What are they?
Solution
The six major pollutants per NAAQS are sulphur dioxide, particulate matters (PM10 and
PM2.5), carbon monoxide, ozone, nitrogen dioxide and lead
the lapse rate observed in air when the air has little or no water is called dry adiabatiuc lapse rate
value of dry adiabatic lapse rate is 9.8oC/km.
UPS Worldpart DiscussionWhat do you think are the operational str.pdf
UPS Worldpart DiscussionWhat do you think are the operational str.pdffathimalinks UPS Worldpart Discussion:
What do you think are the operational strengths of UPS?
How have they achieved these strengths?
How do their strengths match their marketing messages, some of which can be seen below.
Solution
1.
Operational strengths of UPS are as following:
2.
They have achieved these strengths through:
3.
It seems to be an incomplete question as marketing messages are not given as mentioned in the
question..
True or False Justify your answer.Using multilevel signaling, it .pdf
True or False Justify your answer.Using multilevel signaling, it .pdffathimalinks True or False? Justify your answer.
Using multilevel signaling, it is possible to arbitrarily increase the bit rateat the physical layer by
increasing the number of levels that each pulsecarries.
Solution
False.
This is because as the number of levels increases, it becomes harder to detect the levels
accurately and this also leads to higher noise levels..
This is question about excel cuers wish to answer shortly how to use.pdf
This is question about excel cuers wish to answer shortly how to use.pdffathimalinks This is question about excel cuers wish to answer shortly how to use.
How would you use Financial Functions, Data tables and Hyperlinks on a day-to-day functions?
Solution
Excel provides an enormous number of functions to analyze, audit and calculate data.
Some of them are utilized by many Excel users on a daily basis while others are
so very specific that only a small group of financial, statistical or engineering specialists
understand and need them.
financial functions
*******************
Excel has a wide assortment of financial functions that are used by thousands of financial
analysts every day.
Microsoft Excel provides a host of functions to simplify the work of accounting managers,
financial analysts and banking specialists.
Here are some commonly used financial functions in Excel they are
i)Present Value (PV) = the value of the load or savings today.
ii)Interest Rate per period (RATE) = the interest rate, usually monthly (if given an annual rate,
be sure to divide by 12!)
iii)Number of payment periods (NPER) = Number of payment periods (number of months
usually).
iv)Periodic payment (PMT) = The payment per period (monthly payment usually). This value is
the same for every payment period.
Data tables
***********
A data table is a range of cells in which you can change values in some in some of the cells and
come up with different answers to a problem.
You can create one-variable or two-variable data tables, depending on the number of variables
and formulas that you want to test.
You can find some cool uses for tables in your data to day work. They are intuitive, easy to use
and provide great power without added complexity.
Hyperlinks
**********
A Hyperlink is nothing but a reference to a document, a location or an action that the reader can
directly follow by selecting the link.
Excel provides a convenient way for linking up cells data with whatever you want.
To create hyperlinks in the sheet. Select the cell in which you want to create hyperlink and right-
click to select Hyperlink.
When you click the cell that contains the HYPERLINK function, Microsoft Excel opens the file
that is stored at link_location.
The use of Hyperlinks in Excel has been extended to a number of areas and this includes:
Opening Files (of any type)
Opening Web Pages (Internet or Intranet).
There is a requirement to design a system to sense the presence of gl.pdf
There is a requirement to design a system to sense the presence of gl.pdffathimalinks There is a requirement to design a system to sense the presence of glass bottles leaving an
automatic washer on a production line conveyor belt. The production line is for food products
and the environment is clean and maintained at a temperature of 15 degree C. The system must
meet the following criteria: The switching distance will lie between 5 and 20 mm. The output
from the sensor is to be of binary form, i.e. logical 1 when the part is present and logical 0 when
no part is present. It is necessary to ensure that a change of sensor state occurs closer to the
sensor when a bottle approaches than when it moves away. Bottles will pass the sensor at the
rate of 10 every second. There is no requirement for protection from contact with objects but it
must be proof against water drips. Recommend a suitable sensor and justify your
recommendation. Sketch a diagram that shows the functional blocks within the sensor and
explain each function.
Solution
lock Diagram of the system
Basic Elements Used
MICRO CONTROLLER
RESISTORS
CAPACITOR
INDUCTOR
POWER DIODE
WATER PUMP
IR SENSORS
DC MOTOR
CONVEYOR BELT
Resistore
A part from resister and inductor, a capacitor is the other basic component used in electronic
circuits. It is a device which
1. Has the ability to store charge which neither a resistor nor an inductor can do;
2. opposes any change of voltage in the circuit in which it is connected;
3. Blocks the passage of direct current through it.
CAPACITOR
The electronic component (mostly a coil) which opposes the change of current in circuit is
called an inductor. The ability of coil or inductor due to which it opposes the change of current
flowing through it is known as its inductance. The inductance of an inductor may also be defined
as the ability of an inductor to produce induced voltage when the current varies through it. The
unit of inductance is Henry which is named after Joseph Henry.
INDUCTOR
Diodes allow electricity to flow in only one direction. The arrow of the circuit symbol shows the
direction in which the current can flow. Diodes are the electrical version of a valve and early
diodes were actually called valves. The construction and the fundamental working of the power
diode and signal diode are same but the power handling capacity of the power diode is higher
than the signal diodes
POWER DIODE
Sensors
IR Sensors work by using a specific light sensor to detect a select light wavelength in the Infra-
Red (IR) spectrum. By using an LED which produces light at the same wavelength as what the
sensor is looking for, you can look at the intensity of the received light. When an object is close
to the sensor, the light from the LED bounces off the object and into the light sensor. This results
in a large jump in the intensity, which can be detected using a threshold
DRIVER CIRCUIT FOR DC MOTOR
We have used the dc motors to drive conveyer belt and to. The driver circuit for dc motors is
shown below.
COMPARATOR CIRCUIT
Comparator circuit is used in thi.
The investments of Charger Inc. include a single investment 11,010 .pdf
The investments of Charger Inc. include a single investment 11,010 .pdffathimalinks The investments of Charger Inc. include a single investment: 11,010 shares of Raiders Inc.
common stock purchased on February 24, Year 1, for $39 per share including brokerage
commission. These shares were classified as trading securities. As of the December 31, Year 1,
balance sheet date, the share price had increased to $42 per share.
Required:A.Journalize the entries to acquire the investment on February 24, and record the
adjustment to fair value on December 31, Year 1. Refer to the Chart of Accounts for exact
wording of account titles.B.How is the unrealized gain or loss for trading investments reported
on the financial statements?
Solution
a) Journal entry :
b) Unrealized gain or loss for trading investment reported on the financial statement that is
recognized in net income.Dateaccount & explanationdebitcreditYear 1 Feb 24Investment in
trading securities (11010*39)429390Cash429390(To record investment)Year 1 Dec
31Investment in trading securities (11010*3)33030Unrealized Gain-Trading securities33030(To
record unrealized gain).
RNA polymerasebinds to DNA after the double strands have been unwoun.pdf
RNA polymerasebinds to DNA after the double strands have been unwoun.pdffathimalinks RNA polymerasebinds to DNA after the double strands have been unwound by helicase.
Solution
Answer: binds to the template strand in the promoter region.
Explanation:
RNA polymerases are enzymes that transcribe DNA into RNA. Using a DNA template, RNA
polymerase builds a new RNA molecule through base pairing. It always builds a new RNA
strand in the 5’ to 3’ direction..
Research and explain the deviant actions of the Los Angeles Police D.pdf
Research and explain the deviant actions of the Los Angeles Police D.pdffathimalinks Research and explain the deviant actions of the Los Angeles Police Department’s Rampart
CRASH unit during the late 1990s. Did socialization and culture of the unit have a role within
the officer’s deviant behaviors? As a member of the CRASH team, what would have been your
course of action after observing the illegal conduct? submit your answer in 3-5 pages.
Solution
Traditional definitions of police misconduct, especially Apolice corruption,@ are imprecise. In
the past, police scholars have classified acts of police misconduct as Apolice corruption,@
Apolice brutality,@ and Adrug-related misconduct.@ We found, however, that these
classifications are not mutually exclusive, and that determining whether profit-motivated
criminality by police officers involved jobrelated police corruption frequently is impossible. -
Involuntary separations are rare. Separations for cause from the New York City Police
Department (through dismissals, terminations, and forced resignations and retirements) are
infrequent events. Only two percent of the officers employed by the NYPD during the 22 years
(1975-96) we studied were involuntarily separated from the department. - Pre-employment
history matters. Officers whose life histories include records of arrest, traffic violations, and
failure in other jobs are more likely than other officers to be involuntarily separated from the
NYPD. - Education and training matter. Officers who hold associate or higher degrees are less
likely than those who do not to be involuntarily separated. Those who do well in the Police
Academy=s recruit training program are less likely than marginal recruits to be separated as
unsatisfactory probationers. Subsequently, they also are less likely to be involuntarily separated
for cause after successful completion of their probationary periods. - Diversity matters. As the
NYPD has become more diverse, it has become better behaved. We found a very strong inverse
correlation (r=-.71; r2 .50) between the percentage of white male NYPD officers and the
department=s annual rate of involuntary separations. - Race still matters, but apparently only for
black officers: As the representation of Hispanic and Asian officers in the NYPD has increased,
their involuntary separation rates have decreased and become virtually indistinguishable from
those of white officers. Black officers= representation in the NYPD remained relatively flat
during the years studied. Black officers= involuntary separation rates have also decreased, but
remain higher than those for other racial groups. This document is a research report submitted to
the U.S. Department of Justice. This report has not been published by the Department. Opinions
or points of view expressed are those of the author(s) and do not necessarily reflect the official
position or policies of the U.S. Department of Justice. Fyfe and Kane -- xiii The study reaches
these conclusions after examining the life and career histories of all 1,543 officers who were
dis.
Question 1 10 points Save A TALIA Contribute NINA Co Contribute TALIA.pdf
Question 1 10 points Save A TALIA Contribute NINA Co Contribute TALIA.pdffathimalinks Question 1 10 points Save A TALIA Contribute NINA Co Contribute TALIA EMILY TALIA
Contribute 9 Contribute TALIA Dont information sets and she has possible Consider the
extensive form representation of the game between Emily, Nina and Talia. Emily moves at
information sets and has possible strategies. Talia moves at strategies. (Please fill in the blanks
using numerical values like 0, 1, 75, etc)
Solution
Emily moves at 01 information sets with 02 possible strategies. Talia will have 04 information
sets and 08 strategies.
Q1. Print all the odd numbers from 1 to a user specifiable upper lim.pdf
Q1. Print all the odd numbers from 1 to a user specifiable upper lim.pdffathimalinks Q1. Print all the odd numbers from 1 to a user specifiable upper limit (inclusive) using both
while and for loops
Example,
Please enter a number:
9
Odd numbers from 1 to 9 are:
1
3
5
7
9
HINT: The number 9 should be included!!!
2. Write a program called CheckerBoard that displays the following n×n (n=7) checkerboard
pattern using two nested for-loops.
Solution
Q)1)
Using While Loop:
DisplayOddNumbers.java
import java.util.Scanner;
public class DisplayOddNumbers {
public static void main(String[] args) {
//Declaring variables
int number;
int i=1;
//Scanner object is used to get the inputs entered by the user
Scanner sc=new Scanner(System.in);
//getting the number entered by the user
System.out.println(\"Please enter a number:\");
number=sc.nextInt();
//Displaying the odd numbers using while loop
System.out.println(\"Odd numbers from 1 to 9 are:\");
while(number>0)
{
//Checking the number is even or odd
if(i%2!=0)
{
System.out.println(i);
}
i++;
number--;
}
}
}
_____________________
Output:
Please enter a number:
9
Odd numbers from 1 to 9 are:
1
3
5
7
9
_______________
using for loop:
DisplayOddNosUsingForLoop.java
import java.util.Scanner;
public class DisplayOddNosUsingForLoop {
public static void main(String[] args) {
//Declaring variables
int number;
//Scanner object is used to get the inputs entered by the user
Scanner sc=new Scanner(System.in);
//getting the number entered by the user
System.out.println(\"Please enter a number:\");
number=sc.nextInt();
//Displaying the odd numbers using while loop
System.out.println(\"Odd numbers from 1 to 9 are:\");
for(int i=1;i<=number;i++)
{
//Checking the number is even or odd
if(i%2!=0)
{
System.out.println(i);
}
}
}
}
____________________
Output:
Please enter a number:
9
Odd numbers from 1 to 9 are:
1
3
5
7
9
_____________________
2)Q)
package org.students;
import java.util.Scanner;
public class CheckerBoard {
public static void main(String[] args) {
//Displaying the checker board using nested for loop
for(int i=1;i<=7;i++)
{
for(int j=1;j<=7;j++)
{
if(i%2==0)
System.out.print(\" #\");
else
System.out.print(\"# \");
}
System.out.println(\" \");
}
}
}
__________________
output:
# # # # # # #
# # # # # # #
# # # # # # #
# # # # # # #
# # # # # # #
# # # # # # #
# # # # # # #
____________Thank You.
Please revise the answer bellow.Q1. What historically have been Ap.pdf
Please revise the answer bellow.Q1. What historically have been Ap.pdffathimalinks Please revise the answer bellow.
Q1. What historically have been Apple’s competitive advantages?
There have been many competitive advantages that have allowed Apple to be a consistent leader
in the PC market. One competitive advantage has been their innovative spirit. This was shown
with the initial release of the Apple 2. Steve Job’s mission of Apple was to bring an easy-to-use
computer to the market, and this is what he accomplished with the release of the Apple 2. The
Apple 2 was a revolutionary product that changed the PC world forever. The Apple 2 was
launched in 1978 and it lead the PC industry to $1 billion in annual sales in less than three years.
Another competitive advantage for Apple is that they have total control over all of the software,
hardware, and operations related to Apple products. The apple software is horizontally and
vertically integrated, meaning it relies on its own designs and does not license software to third
parties. Apple released the Mac in 1984, which featured an interface that was easy-to-use, a great
industrial design, and technical proficiency. The superior software allowed Apple to enter the
Mac into new markets, desktop publishing and education. In education, Apple grabbed almost
half of the market and by 1990, Apple had $1 billion in cash and was the most profitable PC
Company in the world. Furthermore, Apple hired Tim Cook to streamline the Apple supply
chain, and also Apple launched a website to set up direct sales. This has allowed Apple to be
successful by creating a comprehensive, unified culture with all aspects of the company. Their
most important competitive advantage was Steve Jobs. Being the co-founder, Steve Jobs had the
long-term vision of Apple and worked every day to live out the vision. Steve Jobs was forced out
of 1985, but returned as the interim CEO in 1997 when the company was near bankruptcy. Jobs
refocused Apple to only having 4 product categories, rather than 15 it had previously. Through
Steve Job’s leadership, Apple created the iMac in 1998, which allowed Apple’s sales to outpace
the industry average for the first time in many years. Steve Jobs made strategic decisions to make
Apple products the most competitive by bringing a new culture to Apple, and positively
changing the image and brand of Apple.
Q2. Analyze the personal computer industry. Why did Apple struggle historically in PCs?
It is true that Apple was the company who pioneered the personal computing devices, but IBM
was the company the mainstream PC’s. This was the biggest competitor to the early success of
Apple. The IBM PC operated on an “open” system that allowed producers to clone it. Another
reason why Apple struggled with PCs was the price. Macintosh did have a loyal customer base
which allowed them to sell it at a premium price. IBM- compatible prices started to drop, and the
high Macintosh’s looked unfeasible and too expensive. Another reason for the struggle of Apple
PCs was the rise of “Wintel”. “Wintel” was t.
Negligence Curtis R. Wilhelm owned beehives and kept the hives on pr.pdf
Negligence Curtis R. Wilhelm owned beehives and kept the hives on pr.pdffathimalinks Negligence Curtis R. Wilhelm owned beehives and kept the hives on property he owned. John
Black, who operated a honeybee business, contracted to purchase some beehives from Wilhelm.
Black employed Santos Flores, Sr. to help him pick up the beehives from 101102Wilhelm. Black
provided Flores with a protective suit to wear while picking up the beehives. Neither Wilhelm
nor Black informed Flores of the danger of working with bees. After picking up beehives from
Wilhelm’s home, Black and Flores drove to remote property owned by Wilhelm to pick up other
beehives. Flores opened the veil on his protective suit. After loading one beehive onto the truck,
Flores started staggering and yelling for help. Flores sustained several bee stings, suffered
anaphylactic shock reaction, and died before an ambulance could reach him. Flores’s wife and
children sued Wilhelm and Black for negligence for failing to warn Flores of the dangers of
working with beehives and the possibility of dying of anaphylactic shock if stung by a bee. Did
Wilhelm act negligently by failing to warn Flores of the dangers of working with beehives?
Wilhelm v. Flores, 133 S.W.3d 726, Web 2003 Tex. App. Lexis 9335 (Court of Appeals of
Texas)
Solution
Answer:
Yes. The Court of Appeals held that the owner of the bees owed a duty to warn Flores of
thedangers of working with bees and bee stings, affirming the award of damages..
List and explain at least three popular sixteenth century dance type.pdf
List and explain at least three popular sixteenth century dance type.pdffathimalinks List and explain at least three popular sixteenth century dance types, including the style, common
instrumentation, and use in court, society, or both.
Solution
Sixteemth century dance types:
(1) Galliard:
(i) Renaissance dance
(ii) places-- England, France, Spain, Germany, and Italy
(iii) dance steps :--- five stepsright, left, right, left, cadence
(iv) instruments-- crumhorns, lute
(b)
Courante
(i)Renaissance dance
(ii)places:-- France and Italy
(iii)dance steps:-- fast running and jumping steps
(iv)instruments:- cello, harpsichord, lute and violin
(c)
Canary dance
(i)Renaissance dance
(ii)places:-- France ,Italy, spain and England
(iii)dance steps:-- jumps, stamping of the feet and violent movement
(iv)instruments:- drum and wind and stringed instruments.
Introduction to Database Management SystemConsider the following .pdf
Introduction to Database Management SystemConsider the following .pdffathimalinks Introduction to Database Management System:
Consider the following relation of students: R(A, B, C, D, E, F, G) (A is underlined)
D is a candidate key. Suppose the following dependencies exist:
FD1: A-> B, C, D, E, F, G
FD2: C, D -> A, B, E, F, G
FD3: D-> G
FD4: F -> C
Apply normalization until you cannot decompose the relations further. State the reasons behind
each decomposition.
Solution
FD1: A-> B, C, D, E, F, G: This Functional dependency uniquely idendifies the table row so, all
other functional dependecies are not need. we simply ignore all other.
>>> for example it any of the FD voilates any of the NF then we will decompose it and create a
new table for that FD. Here FD2 voilates 3NF but if we want to decompose it what could be the
foreign key in R2 since all other attributes are present in relation R1:(A, B, C, D, E, F, G) .
>>>Therefore FD1 is the final one for the Relation..
In female mammals, one of the X chromosomes in each cell is condensed.pdf
In female mammals, one of the X chromosomes in each cell is condensed.pdffathimalinks In female mammals, one of the X chromosomes in each cell is condensed as a heterochromatic
clump early in embryonic development. What is this condensed X chromosome called? a Harr
body a Barr body a Lyon body a Barriton body
Solution
a barr body is the condensed inactive X chromosome in the female somatic cell rendered inactive
in a process called lyonization.
Recently uploaded (20)
Policies, procedures, subject selection and QTAC.pptx
Policies, procedures, subject selection and QTAC.pptxmansk2 Policies, procedures, subject selection and QTAC
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
Combustion in Compression Ignition Engine (CIE)
Combustion in Compression Ignition Engine (CIE)NileshKumbhar21 Stages of combustion, Delay period, Factors affecting delay period, Abnormal
combustion- Diesel knock, Influence of engine design and operating variables
on diesel knock, Comparison of abnormal combustion in S.I. and C.I. Engines,
Cetane number, Additives. Requirements of combustion chambers for C.I.
Engines and its types
Product in Wartime: How to Build When the Market Is Against You
Product in Wartime: How to Build When the Market Is Against Youvictoriamangiantini1 Product in Wartime: How to Build When the Market Is Against You
Protest - Student Revision Booklet For VCE English
Protest - Student Revision Booklet For VCE Englishjpinnuck The 'Protest Student Revision Booklet' is a comprehensive resource to scaffold students to prepare for writing about this idea framework on a SAC or for the exam. This resource helps students breakdown the big idea of protest, practise writing in different styles, brainstorm ideas in response to different stimuli and develop a bank of creative ideas.
Launch of The State of Global Teenage Career Preparation - Andreas Schleicher...
Launch of The State of Global Teenage Career Preparation - Andreas Schleicher...EduSkills OECD Andreas Schleicher, Director for Education and Skills at the OECD, presents at the launch of the OECD report 'The State of Global Teenage Career Preparation' on the 20 May 2025. You can check out the video recording of the launch on the OECD website - https://oecdedutoday.com/webinars/
Module I. Democracy, Elections & Good Governance
Module I. Democracy, Elections & Good Governancesrkmcop0027 First Year B Pharm Credit Course , Democracy, Elections & Good Governance
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.
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.
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)
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
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
Quality Assurance and Quality Management, B. Pharm 6th Semester-Unit-1
Quality Assurance and Quality Management, B. Pharm 6th Semester-Unit-1Amit Kumar Sahoo This Presentation includes all topics are mentioned in the PCI Syllabus for B.Pharm 6th Semester.
AI and international projects. Helsinki 20.5.25
AI and international projects. Helsinki 20.5.25Matleena Laakso Read more: https://www.matleenalaakso.fi/p/in-english.html
And AI in education: https://padlet.com/matlaakso/ai
The Board Doesn’t Care About Your Roadmap: Running Product at the Board
The Board Doesn’t Care About Your Roadmap: Running Product at the Boardvictoriamangiantini1 The Board Doesn’t Care About Your Roadmap: Running Product at the Board
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
How to create Record rules in odoo 18 - Odoo Slides
How to create Record rules in odoo 18 - Odoo SlidesCeline George Record rules allow us to restrict which records are displayed to users. Creating record rules in Odoo 18 is essential for managing data access and ensuring that users can only see or interact with records they are authorized to access.
5503 Course Proposal Online Computer Middle School Course Wood M.pdf
5503 Course Proposal Online Computer Middle School Course Wood M.pdfMelanie Wood Course Proposal for Online Computer Middle School Course completed in Spring 2025 at OSU for EDTC 5503.
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)
Write the following using javaGiven a class ‘Node’ and ‘NodeList’,.pdf
- 1. Write the following using java Given a class ‘Node’ and ‘NodeList’, that contains the below information diagram. -id: int -name: String -next: Node +Node(id: int, name: String) +setId(id: int): void +getId(): int +setName(name: String) : void +getName(): String +setNext(node: Node): void +getNext(): Node NodeList -size: int -root: Node +add(node: Node): void +size(): int +findNode(node: Node): boolean Implement add(Node), findNode(Node) and size methods in the NodeList class which is provided to you. The methods should work as: Using the following main method: public static void main(String[] args) { NodeList list = new NodeList(); Node node = new Node(1, "Book"); Node node2 = new Node(2, "Lappy"); list.add(node); list.add(node2); System.out.println("Length : "+list.size()); Node node3 = new Node(3, "Glass"); Node node4 = new Node(4, "Pen"); list.add(node3); System.out.println("Length : "+list.size()); if(list.findNode(node3)) System.out.println("Node found: "+ node3.getName()); else
- 2. System.out.println("Node not found: "+ node3.getName()); if(list.findNode(node4)) System.out.println("Node found: "+ node4.getName()); else System.out.println("Node not found: "+ node4.getName()); } Then it should return the following output: Length : 2 Length : 3 Node found: Glass Node not found: Pen The given Node class is: public class Node { private int id = 0; private String name = ""; private Node next; public Node(int id, String name) { this.id = id; this.name = name; this.next = null; } public Node getNext() { return next; } public void setNext(Node node) { this.next = node } public int getId() { return id; {
- 3. public void setId(int id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String toString() { return "ID : "+this.id+" Name : "+this.name; } } The given NodeList class is: public class NodeList { private int size = 0; private Node root = null; /* * It has to take a new Node and add that to the next address of previous Node. * If the list is empty, assign it as the "root" * @Param - Node */ public void add(Node node) { // Implement this method!!!
- 4. } /* * It has to return the size of the NodeList * * @return size */ public int size() { // Implement this method!!! } /* * It has to take a Node and checks if the node is in the list. * If it finds the node, it returns true, otherwise false * * @param - Node * @return boolean true/false */ public boolean findNode(Node node) { // Implement this method!!! } }Node -id: int -name: String -next: Node +Node(id: int, name: String) +setId(id: int): void +getId(): int
- 5. +setName(name: String) : void +getName(): String +setNext(node: Node): void +getNext(): Node Solution Hi, Please find my implementation. Please let me know in case of any issue. ############ Node.java ############# public class Node { private int id = 0; private String name = ""; private Node next; public Node(int id, String name) { this.id = id; this.name = name; this.next = null; } public Node getNext() { return next; } public void setNext(Node node) { this.next = node ; } public int getId() { return id; } public void setId(int id) { this.id = id;
- 6. } public String getName() { return name; } public void setName(String name) { this.name = name; } public String toString() { return "ID : "+this.id+" Name : "+this.name; } } ################ NodeList.java ######################## public class NodeList { private int size = 0; private Node root = null; /* * It has to take a new Node and add that to the next address of previous Node. * If the list is empty, assign it as the "root" * @Param - Node */ public void add(Node node) { // Implement this method!!! if(root == null) root = node; else{ node.setNext(root); // adding at front root = node; } size++; }
- 7. /* * It has to return the size of the NodeList * * @return size */ public int size() { // Implement this method!!! return size; } /* * It has to take a Node and checks if the node is in the list. * If it finds the node, it returns true, otherwise false * * @param - Node * @return boolean true/false */ public boolean findNode(Node node) { // Implement this method!!! Node temp = root; while(temp != null){ if(temp.getId() == node.getId() && temp.getName().equalsIgnoreCase(node.getName())) return true; temp = temp.getNext(); } return false; } } ################ NodeListTest.java ######################## public class NodeListTest { public static void main(String[] args) { NodeList list = new NodeList();
- 8. Node node = new Node(1, "Book"); Node node2 = new Node(2, "Lappy"); list.add(node); list.add(node2); System.out.println("Length : "+list.size()); Node node3 = new Node(3, "Glass"); Node node4 = new Node(4, "Pen"); list.add(node3); System.out.println("Length : "+list.size()); if(list.findNode(node3)) System.out.println("Node found: "+ node3.getName()); else System.out.println("Node not found: "+ node3.getName()); if(list.findNode(node4)) System.out.println("Node found: "+ node4.getName()); else System.out.println("Node not found: "+ node4.getName()); } } /* Sample run: Length : 2 Length : 3 Node found: Glass Node not found: Pen */