In the class we extensively discussed a generic singly linked list i.pdf

•

0 likes•2 views

In the class we extensively discussed a generic singly linked list implemented as a node class. Implement a generic node class called DoublyNode in which each node contains an element of type E and each node is linked not only forward to the next element in the list but also backward to the previous element in the list. Your implementation should adapt and implement all the methods of generic Node including the following methods: Constructor for DoublyNode addNodeAfter, removeNodeAfter getData, setData getForeLink, setForeLink getBackLink, setBackLink listCopy listCopyWithTail listLength listPart listPosition listSearch Solution import java.util.ListIterator; import java.util.NoSuchElementException; import java.util.Random; public class DoublyNode { private Node head; private Node tail; private int size; public DoublyNode() { size = 0; } private class Node { E element; Node getForeNode; Node getBackNode; public Node(E element, Node next, Node prev) { this.element = element; this.getForeNode = next; this.getBackNode = prev; } } public int listLength() { return size; } public boolean isEmpty() { return size == 0; } public void addFirst(E element) { Node tmp = new Node(element, head, null); if(head != null ) {head.getBackNode = tmp;} head = tmp; if(tail == null) { tail = tmp;} size++; System.out.println(\"adding: \"+element); } public void addNodeAfter(E element) { Node tmp = new Node(element, null, tail); if(tail != null) {tail.getForeNode = tmp;} tail = tmp; if(head == null) { head = tmp;} size++; System.out.println(\"adding: \"+element); } public void addNodeAfterSpecifiedNode(E element, E tobeAddedAfter) { Node prevTobeAddedAfter = listSearch(element); Node afterNode = prevTobeAddedAfter.getForeNode; Node tmpNode = new Node(element,prevTobeAddedAfter,afterNode); tmpNode = prevTobeAddedAfter.getForeNode; afterNode = tmpNode.getForeNode; } public void listCopy(){ System.out.println(\"iterating forward..\"); Node tmp = head; while(tmp != null){ System.out.println(tmp.element); tmp = tmp.getForeNode; } } public Node listSearch(E item){ System.out.println(\"Searching Item \"+item); Node tmp = head; while(tmp != null){ System.out.println(tmp.element); if(tmp.element == item) { System.out.println(\"Item found \"+item); return tmp; } tmp = tmp.getForeNode; } return null; } public void iterateBackward(){ System.out.println(\"iterating backword..\"); Node tmp = tail; while(tmp != null){ System.out.println(tmp.element); tmp = tmp.getBackNode; } } public E removeFirst() { if (size == 0) throw new NoSuchElementException(); Node tmp = head; head = head.getForeNode; head.getBackNode = null; size--; System.out.println(\"deleted: \"+tmp.element); return tmp.element; } public E removeNodeAfter() { if (size == 0) throw new NoSuchElementException(); Node tmp = tail; tail = tail.getBackNode; tail.getForeNode = null; size--; System.out.println(\"deleted: \"+tmp.element); return tmp.element; } }.

Education

Node getForeNode;
Node getBackNode;
public Node(E element, Node next, Node prev) {
this.element = element;
this.getForeNode = next;
this.getBackNode = prev;
}
}
public int listLength() { return size; }
public boolean isEmpty() { return size == 0; }
public void addFirst(E element) {
Node tmp = new Node(element, head, null);
if(head != null ) {head.getBackNode = tmp;}
head = tmp;
if(tail == null) { tail = tmp;}
size++;
System.out.println("adding: "+element);
}
public void addNodeAfter(E element) {
Node tmp = new Node(element, null, tail);
if(tail != null) {tail.getForeNode = tmp;}
tail = tmp;
if(head == null) { head = tmp;}
size++;
System.out.println("adding: "+element);
}

public void addNodeAfterSpecifiedNode(E element, E tobeAddedAfter) {
Node prevTobeAddedAfter = listSearch(element);
Node afterNode = prevTobeAddedAfter.getForeNode;
Node tmpNode = new Node(element,prevTobeAddedAfter,afterNode);
tmpNode = prevTobeAddedAfter.getForeNode;
afterNode = tmpNode.getForeNode;
}
public void listCopy(){
System.out.println("iterating forward..");
Node tmp = head;
while(tmp != null){
System.out.println(tmp.element);
tmp = tmp.getForeNode;
}
}
public Node listSearch(E item){
System.out.println("Searching Item "+item);
Node tmp = head;
while(tmp != null){
System.out.println(tmp.element);
if(tmp.element == item) {
System.out.println("Item found "+item);
return tmp;
}
tmp = tmp.getForeNode;

}
return null;
}
public void iterateBackward(){
System.out.println("iterating backword..");
Node tmp = tail;
while(tmp != null){
System.out.println(tmp.element);
tmp = tmp.getBackNode;
}
}
public E removeFirst() {
if (size == 0) throw new NoSuchElementException();
Node tmp = head;
head = head.getForeNode;
head.getBackNode = null;
size--;
System.out.println("deleted: "+tmp.element);
return tmp.element;
}
public E removeNodeAfter() {
if (size == 0) throw new NoSuchElementException();
Node tmp = tail;
tail = tail.getBackNode;
tail.getForeNode = null;
size--;
System.out.println("deleted: "+tmp.element);
return tmp.element;
}

Similar to In the class we extensively discussed a generic singly linked list i.pdf

Write the Java source code necessary to build a solution for the pro.pdf

fckindswear

PathOfMostResistance

Edward Cleveland

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 .

hi i have to write a java program involving link lists. i have a pro.pdf

archgeetsenterprises

To complete the task, you need to fill in the missing code. I’ve included code to create an Iterator. An Iterator is an object that iterates over another object – in this case, a circular linked list. You can use the .next() method to advance the Iterator to the next item (the first time you call it, the iterator will travel to node at index 0). Using iterator’s .remove() removes the node the iterator is currently at. Say that we had a CircularLinkedList that looked like this: A ==> B ==> C ==> D ==> E ==> Calling .next() three times will advance the iterator to index 2. Calling .remove() once will remove the node at index 2. A ==> B ==> D ==> E ==> Calling .remove() once more will remove the node now at index 2. A ==> B ==> E ==> The Iterator methods handle wrapping around the CircularLinkedList. Be sure to create the iterator using l.iterator() and after you’ve added all the nodes to the list, where l is your CircularLinkedList Solution import java.util.Iterator; class CircularLinkedList implements Iterable { // Your variables // You can include a reference to a tail if you want Node head; int size; // BE SURE TO KEEP TRACK OF THE SIZE // implement this constructor public CircularLinkedList() { head=null; } // writing helper functions for add and remove, like the book did can help // but remember, the last element\'s next node will be the head! // attach a node to the end of the list // Be sure to handle the adding to an empty list // always returns true public boolean add(E e) { Node newNode=new Node(e); if(size==0){ head=newNode; } else{ Node last=getNode(size-1); last.next=newNode; } newNode.next=head; //last element node is set to head size++; return true; } // need to handle // out of bounds // empty list // adding to front // adding to middle // adding to \"end\" // REMEMBER TO INCREMENT THE SIZE public boolean add(int index, E e){ if(index>size) return false; Node tmp=new Node(e); if(index==0){ tmp.next=head; Node last=getNode(size-1); head=tmp; last.next=head; } else { Node curr=getNode(index-1); tmp.next=curr.next; curr.next=tmp; } size++; return true; } // I highly recommend using this helper method // Return Node found at the specified index // be sure to handle out of bounds cases private Node getNode(int index ) { Node prev=head; for(int i=0;isize) { e=null; } else if(index==0){ e = head.getElement(); Node last=getNode(size-1); head=head.next; last.next=head; size--; } else{ Node prev=getNode(index-1); Node curr=getNode(index); e=curr.getElement(); prev.next=curr.next; size--; } return e; } // Turns your list into a string // Useful for debugging public String toString(){ Node current = head; StringBuilder result = new StringBuilder(); if(size == 0){ return \"\"; } if(size == 1) { return head.getElement().toString(); } else{ do{ result.append(current.getElement()); result.append(\" ==> \"); current = current.next; } while(current != head); } return result.toString(); } public Iterator iterator() { return new ListIterator(); } /.

To complete the task, you need to fill in the missing code. I’ve inc.pdf

ezycolours78

**JAVA** A double-ended queue is a list that allows the addition and removal of items from either end. One end is arbitrarily called the front and other the rear, but the two ends behave identically. Specify, design and implement a class for a double-ended queue. Include operations to check if it is empty and to return the number of items in the list. For each end, include operations for adding and deleting items. Use doubly linked list for your implementation. Call your class Deque (pronounced \"deck\"). Solution //package com.java2novice.ds.queue; public class DequeDblLinkedListImpl { private LinkedNode front; private LinkedNode rear; public void insertFront(T item){ //add element at the beginning of the queue System.out.println(\"adding at front: \"+item); LinkedNode nd = new LinkedNode(); nd.setValue(item); nd.setNext(front); if(front != null) front.setPrev(nd); if(front == null) rear = nd; front = nd; } public void insertRear(T item){ //add element at the end of the queue System.out.println(\"adding at rear: \"+item); LinkedNode nd = new LinkedNode(); nd.setValue(item); nd.setPrev(rear); if(rear != null) rear.setNext(nd); if(rear == null) front = nd; rear = nd; } public void removeFront(){ if(front == null){ System.out.println(\"Deque underflow!! unable to remove.\"); return; } //remove an item from the beginning of the queue LinkedNode tmpFront = front.getNext(); if(tmpFront != null) tmpFront.setPrev(null); if(tmpFront == null) rear = null; System.out.println(\"removed from front: \"+front.getValue()); front = tmpFront; } public int size(){ if(front == null && rear ==null){ return 0; } //remove an item from the beginning of the queue LinkedNode tmpFront = front; LinkedNode tmpRear = rear; int i=0; while(tmpFront != rear) { i++; tmpFront=tmpFront.getNext(); } i++; return i; } public void removeRear(){ if(rear == null){ System.out.println(\"Deque underflow!! unable to remove.\"); return; } //remove an item from the beginning of the queue LinkedNode tmpRear = rear.getPrev(); if(tmpRear != null) tmpRear.setNext(null); if(tmpRear == null) front = null; System.out.println(\"removed from rear: \"+rear.getValue()); rear = tmpRear; } public static void main(String a[]){ DequeDblLinkedListImpl deque = new DequeDblLinkedListImpl(); deque.insertFront(34); deque.insertFront(67); System.out.println(\"Size of the queue : \"+deque.size()); deque.insertFront(29); deque.insertFront(765); deque.removeFront(); deque.removeFront(); deque.removeFront(); deque.insertRear(43); deque.insertRear(83); deque.insertRear(84); deque.insertRear(546); deque.insertRear(356); deque.removeRear(); deque.removeRear(); deque.removeRear(); deque.removeRear(); deque.removeFront(); deque.removeFront(); deque.removeFront(); } } class LinkedNode{ private LinkedNode prev; private LinkedNode next; private T value; public LinkedNode getPrev() { return prev; } public void setPrev(LinkedNode prev) { this.prev = prev; } public LinkedNode getNext() { return next; } public void setNext(L.

JAVA A double-ended queue is a list that allows the addition and.pdf

amrishinda

package com.java2novice.ds.linkedlist; import java.util.NoSuchElementException; public class DoublyLinkedListImpl { private Node head; private Node tail; private int size; public DoublyLinkedListImpl() { size = 0; } /** * this class keeps track of each element information * @author java2novice * */ private class Node { E element; Node next; Node prev; public Node(E element, Node next, Node prev) { this.element = element; this.next = next; this.prev = prev; } } /** * returns the size of the linked list * @return */ public int size() { return size; } /** * return whether the list is empty or not * @return */ public boolean isEmpty() { return size == 0; } /** * adds element at the starting of the linked list * @param element */ public void addFirst(E element) { Node tmp = new Node(element, head, null); if(head != null ) {head.prev = tmp;} head = tmp; if(tail == null) { tail = tmp;} size++; System.out.println(\"adding: \"+element); } /** * adds element at the end of the linked list * @param element */ public void addLast(E element) { Node tmp = new Node(element, null, tail); if(tail != null) {tail.next = tmp;} tail = tmp; if(head == null) { head = tmp;} size++; System.out.println(\"adding: \"+element); } /** * this method walks forward through the linked list */ public void iterateForward(){ System.out.println(\"iterating forward..\"); Node tmp = head; while(tmp != null){ System.out.println(tmp.element); tmp = tmp.next; } } /** * this method walks backward through the linked list */ public void iterateBackward(){ System.out.println(\"iterating backword..\"); Node tmp = tail; while(tmp != null){ System.out.println(tmp.element); tmp = tmp.prev; } } /** * this method removes element from the start of the linked list * @return */ public E removeFirst() { if (size == 0) throw new NoSuchElementException(); Node tmp = head; head = head.next; head.prev = null; size--; System.out.println(\"deleted: \"+tmp.element); return tmp.element; } /** * this method removes element from the end of the linked list * @return */ public E removeLast() { if (size == 0) throw new NoSuchElementException(); Node tmp = tail; tail = tail.prev; tail.next = null; size--; System.out.println(\"deleted: \"+tmp.element); return tmp.element; } public static void main(String a[]){ DoublyLinkedListImpl dll = new DoublyLinkedListImpl(); dll.addFirst(10); dll.addFirst(34); dll.addLast(56); dll.addLast(364); dll.iterateForward(); dll.removeFirst(); dll.removeLast(); dll.iterateBackward(); } } Solution package com.java2novice.ds.linkedlist; import java.util.NoSuchElementException; public class DoublyLinkedListImpl { private Node head; private Node tail; private int size; public DoublyLinkedListImpl() { size = 0; } /** * this class keeps track of each element information * @author java2novice * */ private class Node { E element; Node next; Node prev; public Node(E element, Node next, Node prev) { this.element = element; this.next = next; this.prev = prev; } } /** * returns the size of the l.

package com.java2novice.ds.linkedlist;import java.util.NoSuchEleme.pdf

aptind

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.

Help please!!(Include your modified DList.java source code file in.pdf

jyothimuppasani1

PROBLEM STATEMENT: In this assignment, you will complete DoubleEndedList.java that implements the ListInterface as well as an interface called DoubleEndedInterface which represents the list's entries by using a chain of nodes that has both a head reference and a tail reference. Be sure to read through the code and understand the implementation. WHAT IS PROVIDED: - A driver class to test your code. You should not modify this file! - A list interface (ListInterface.java) - A double ended interface (DoubleEndedInterface.java) - An incomplete DoubleEndedList class (DoubleEndedList.java) WHAT YOU NEED TO DO: 4. Complete the DoubleEndedList class 4. Run the driver and make sure your output is exactly the same as mine (at the bottom of Driver.java) \} // end else numberofEntries--; else throw new IndexOut0fBoundsException("Illegal position given to remove operation."); return result; // Return removed entry }//endreturnreve public T replace(int givenPosition, T newEntry) \{ T replace(int givenPosition, T newEntry) \{ if ((givenPosition >=1)&& (givenPosition <= numberOfEntries)) \{ // Assertion: The list is not empty Node desiredNode = getNodeAt (givenPosition); ToriginalEntry = desiredNode.getData(); desiredNode.setData(newEntry); return originalEntry; f // end if else throw new IndexOut0fBoundsException("Illegal position given to replace operation."); replace if (( givenPosition >=1)&& (givenPosition <= number0fEntries)) \{ // Assertion: The list is not empty Node desiredNode = getNodeAt ( givenPosition); T originalEntry = desiredNode. getData( ); desiredNode.setData(newEntry); return originalentry; \} // end if throw new Index0ut0fBoundsException("Illegal position given to replace operation."); \} // end replace public T getEntry(int givenPosition) \{ if ((givenPosition >=1) \&\& (givenPosition < = number0fEntries ) ) \{ // Assertion: The list is not empty return getNodeAt (givenPosition). getData(); else // end if throw new IndexOut0fBoundsException("Illegal position given to getEntry operation."); \} // end getEntry public boolean contains ( T anEntry) \{ boolean found = false; Node currentNode = firstNode; while (!found && (currentNode != null)) \{ if (anEntry.equals (currentNode.getData())) else found = true; \} // end while currentNode = currentNode. getNextNode () ; return found; \} // end contains public int getLength() \{ return numberofEntries; \} // end getLength public boolean isEmpty() \{ return number0fEntries ==0; \} // end isEmpty public T[] toArray() \{ // The cast is safe because the new array contains null entries aSuppressWarnings ("unchecked") T[] result =(T[]) new 0bject [numberofEntries]; // Unchecked cast int index =0; Node currentNode = firstNode; while ((index < numberOfEntries) \&\& (currentNode != null)) \& result [ index ]= currentNode. getData () ; currentNode = currentNode.getNextNode ( ); index++; 3 // end while return result; 3 // end toArray // Returns a reference to the node at a given position. // Precondition: L.

PROBLEM STATEMENTIn this assignment, you will complete DoubleEnde.pdf

climatecontrolsv

/** The LinkedList1 class implements a Linked list. */ class LinkedList1 { /** The Node class stores a list element and a reference to the next node. */ private class Node { String value; Node next; /** Constructor. @param val The element to store in the node. @param n The reference to the successor node. */ Node(String val, Node n) { value = val; next = n; } /** Constructor. @param val The element to store in the node. */ Node(String val) { // Call the other (sister) constructor. this(val, null); } } private Node first; // list head private Node last; // last element in list /** Constructor. */ public LinkedList1() { first = null; last = null; } /** The isEmpty method checks to see if the list is empty. @return true if list is empty, false otherwise. */ public boolean isEmpty() { return first == null; } /** The size method returns the length of the list. @return The number of elements in the list. */ public int size() { int count = 0; Node p = first; while (p != null) { // There is an element at p count ++; p = p.next; } return count; } /** The add method adds an element to the end of the list. @param e The value to add to the end of the list. */ public void add(String e) { if (isEmpty()) { first = new Node(e); last = first; } else { // Add to end of existing list last.next = new Node(e); last = last.next; } } /** The add method adds an element at a position. @param e The element to add to the list. @param index The position at which to add the element. @exception IndexOutOfBoundsException When index is out of bounds. */ public void add(int index, String e) { if (index < 0 || index > size()) { String message = String.valueOf(index); throw new IndexOutOfBoundsException(message); } // Index is at least 0 if (index == 0) { // New element goes at beginning first = new Node(e, first); if (last == null) last = first; return; } // Set a reference pred to point to the node that // will be the predecessor of the new node Node pred = first; for (int k = 1; k <= index - 1; k++) { pred = pred.next; } // Splice in a node containing the new element pred.next = new Node(e, pred.next); // Is there a new last element ? if (pred.next.next == null) last = pred.next; } /** The toString method computes the string representation of the list. @return The string form of the list. */ public String toString() { StringBuilder strBuilder = new StringBuilder(); // Use p to walk down the linked list Node p = first; while (p != null) { strBuilder.append(p.value + \"\ \"); p = p.next; } return strBuilder.toString(); } /** The remove method removes the element at an index. @param index The index of the element to remove. @return The element removed. @exception IndexOutOfBoundsException When index is out of bounds. */ public String remove(int index) { if (index < 0 || index >= size()) { String message = String.valueOf(index); throw new IndexOutOfBoundsException(message); } String element; // The element to return if (index == 0) { // Removal of first item in the list element.

The LinkedList1 class implements a Linked list. class.pdf

malavshah9013

#ifndef LINKED_LIST_ #define LINKED_LIST_ template class LinkedList { private: std::shared_ptr> headPtr; // Pointer to first node in the chain; // (contains the first entry in the list) int itemCount; // Current count of list items std::shared_ptr> getNodeAt(int position) const; public: LinkedList(); LinkedList(const LinkedList& aList); virtual ~LinkedList(); bool isEmpty() const; int getLength() const; bool insert(int newPosition, const ItemType& newEntry); bool remove(int position); void clear(); /** throw PrecondViolatedExcept if position < 1 or position > getLength(). */ ItemType getEntry(int position) const throw(PrecondViolatedExcept); /** throw PrecondViolatedExcept if position < 1 or position > getLength(). */ void replace(int position, const ItemType& newEntry) throw(PrecondViolatedExcept); // Operator Overloading void operator = (const LinkedList& arg); friend std::ostream& operator << (std::ostream& os, const LinkedList& arg) { os << \"There are \" << arg.getLength() << \" values in the list:\" << std::endl; for (int i{ 1 }; i <= arg.getLength(); i++) { os << arg.getEntry(i) << std::endl; } os << std::endl << std::endl << std::endl << std::endl; return os; } }; // Returns a pointer to the Node at the given position. template std::shared_ptr> LinkedList::getNodeAt (int position) const { std::shared_ptr> currPtr{ headPtr }; for (int i{ 1 }; i < position; i++) currPtr = currPtr->getNext(); return currPtr; } // Default constructor. template LinkedList::LinkedList() { headPtr = nullptr; itemCount = 0; } // Copy constructor. template LinkedList::LinkedList(const LinkedList& aList) { itemCount = aList.getLength(); auto currPtr{ aList.headPtr }; auto newNodePtr{ headPtr = std::make_shared>(currPtr->getItem()) }; auto prevNodePtr{ newNodePtr }; currPtr = currPtr->getNext(); for (int i{ 2 }; i <= itemCount; i++) { newNodePtr = std::make_shared>(currPtr->getItem()); prevNodePtr->setNext(newNodePtr); prevNodePtr = newNodePtr; currPtr = currPtr->getNext(); } } // Destructor. template LinkedList::~LinkedList() { headPtr = nullptr; itemCount = 0; } // Accessor/Info Functions. template bool LinkedList::isEmpty() const { return (itemCount > 0)?0:1; } template int LinkedList::getLength() const { return itemCount; } // Places a Node at a given position (element at the same position is now pos+1). template bool LinkedList::insert(const int newPosition, const ItemType& newEntry) { bool ableToInsert{ (newPosition >= 1) && (newPosition <= itemCount + 1) }; if (ableToInsert) { // Create a new node containing the new entry auto newNodePtr{ std::make_shared>(newEntry) }; // Attach new node to chain if (newPosition == 1) { // Insert new node at beginning of chain newNodePtr->setNext(headPtr); headPtr = newNodePtr; } else { // Find node that will be before new node auto prevPtr{ getNodeAt(newPosition - 1) }; // Insert new node after node to which prevPtr points newNodePtr->setNext(prevPtr->getNext()); prevPtr->setNext(newNodePtr); } // end if itemCount++; // .

#ifndef LINKED_LIST_ #define LINKED_LIST_ templateclass It.pdf

angelsfashion1

Implement a minimum spanning tree using Boruvka\'s algorithm. Implement a minimum spanning tree using Boruvka\'s algorithm. Solution The psuedo code is as follows: 1 Graph input = /* read input */; 2 UnionFind uf (input.getNodes ()); 3 Workset ws = input.getNodes(); 4 foreach (Node n : ws) { 5 Edge e = minWeight (input.getOutEdges (n)); 6 Node rep1 = uf.find (e.src); 7 Node rep2 = uf.find (e.dst); 8 if (rep1 != rep2) { 9 e.markInMST(); 10 Node rep = uf.union (rep1, rep2); 11 ws.add (rep) 12 } 13 }.

Implement the additional 5 methods as indicated in the LinkedList fi.pdf

footstatus

singly link list project in dsa.....by rohit malav

Rohit malav

Step 1 The Pair Class Many times in writing software we come across problems that require us of values. For to store a pair example, a coordinate system would require an x, y value pair or a hash key value pair Your task on this assignment is table as a data, one type but to create a simple template pair class called Pair that has two type parameters. You should call these parameters F and s. Functionality Constructor You should create a working constructor that takes two type parameters one for each of the pair values. get First This is an accessor method that will return the first of the pair values. get second This is an accessor method that will return the second of the pair values. set First This is a mutator method that will set the first pair value setsecond This is a mutator method that will set the second pair value Solution Pair.java public class Pair { private F first; //first member of pair private S second; //second member of pair public Pair(F first, S second) { this.first = first; this.second = second; } public void setFirst(F first) { this.first = first; } public void setSecond(S second) { this.second = second; } public F getFirst() { return first; } public S getSecond() { return second; } } LinkedList.java template class Node { private T data; //the object information private Node* next; //pointer to the next node element public void setData(T val) { this.data = val; } public void setNextNull() { this.next = NULL; } public void setNext(Node *tmp) { this.next = tmp; } public Node* getNext() { return this.next; } }; template class LinkedList extends Node { private Node *head = new Node; private Node *tail = new Node; public LinkedList() { head = NULL; tail = NULL; } public ~LinkedList() { } //Method adds info to the end of the list public void append(T info) { if(head == NULL) //if our list is currently empty { head = new Node; //Create new node of type T head->setData(info); tail = head; } else //if not empty add to the end and move the tail { Node* temp = new Node; temp->setData(info); temp->setNextNull(); tail->setNext(temp); tail = tail->getNext(); } } public void addFront(T info) { if(head == NULL) //if our list is currently empty { head = new Node; //Create new node of type T head->setData(info); tail = head; } else //if not empty add to the end and move the tail { Node* temp = new Node; temp->setData(info); temp->setNext(head); head = temp; } } //insert after given node public void insert(Node *node,T info) { Node *temp = new Node; temp->setData(info); temp->setNext(node->getNext()); node->setNext(temp); } public void delete(Node *node) { Node *temp = new Node; temp = head; while(temp->getNext() != node && temp->getNext() ) { temp = temp->getNext(); } if(temp) { temp->setNext(node->getNext()); delete node; } } public Integer size(Node *head) { int sz=0; Node * temp = new Node; temp = head; while(temp) { sz++; temp = temp->getNext(); } return sz; } } PairList.java public class PairList< E, F > extends LinkedList< Pair< E,.

Step 1 The Pair Class Many times in writing software we come across p.pdf

formaxekochi

You can list anything, it doesnt matter. I just want to see code f.pdf

fashionbigchennai

import java-util--- public class MyLinkedList{ public static void.pdf

asarudheen07

implement the ListLinked ADT (the declaration is given in ListLinked.pdf

FOREVERPRODUCTCHD

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; } } }.

Can someone help me to fix the code please package dlist i.pdf

ABHISHEKREADYMADESKO

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

How do I fix it in LinkedList.javathis is what i didLabProgra.pdf

mail931892

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

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

fathimalinks

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

How do I fix it in LinkedList.javaLabProgram.javaLinkedList.jav.pdf

mail931892

Similar to In the class we extensively discussed a generic singly linked list i.pdf (20)