Exception to indicate that Singly LinkedList is empty. .pdf
0 likes7 views
/** * Exception to indicate that Singly LinkedList is empty. */ class LinkedListEmptyException extends RuntimeException { public LinkedListEmptyException() { super(); } public LinkedListEmptyException(String message) { super(message); } } /** * Node class, which holds data and contains next which points to next Node. */ class Node { public int data; // data in Node. public Node next; // points to next Node in list. /** * Constructor */ public Node(int data) { this.data = data; } /** * Display Node\'s data */ public void displayNode() { System.out.print(data + \" \"); } } /** * Singly LinkedList class */ class LinkedList { private Node first; // ref to first link on list /** * LinkedList constructor */ public LinkedList() { first = null; } /** * Insert New Node at first position */ public void insertFirst(int data) { Node newNode = new Node(data); // Creation of New Node. newNode.next = first; // newLink ---> old first first = newNode; // first ---> newNode } /** * Method deletes specific Node from Singly LinkedList in java. */ public Node deleteSpecificNode(int deleteKey) { // Case1: when there is no element in LinkedList if (first == null) { // means LinkedList in empty, throw exception. throw new LinkedListEmptyException( \"LinkedList doesn\'t contain any Nodes.\"); } // Case2: when there is only one element in LinkedList- check whether we // have to delete that Node or not. if (first.data == deleteKey) { // means LinkedList consists of only one // element, delete that. Node tempNode = first; // save reference to first Node in tempNode- // so that we could return saved reference. first = first.next; System.out.println(\"Node with data=\" + tempNode.data + \" was found on first and has been deleted.\"); return tempNode; // return deleted Node. } // Case3: when there are atLeast two elements in LinkedList Node previous = null; Node current = first; while (current != null) { if (current.data == deleteKey) { System.out.println(\"Node with data=\" + current.data + \" has been deleted.\"); previous.next = current.next; // make previous node\'s next point // to current node\'s next. return current; // return deleted Node. } else { if (current.next == null) { // Means Node wasn\'t found. System.out.println(\"Node with data=\" + deleteKey + \" wasn\'t found for deletion.\"); return null; } previous = current; current = current.next; // move to next node. } } return null; } /** * Display Singly LinkedList */ public void displayLinkedList() { System.out.print(\"Displaying LinkedList [first--->last]: \"); Node tempDisplay = first; // start at the beginning of linkedList while (tempDisplay != null) { // Executes until we don\'t find end of // list. tempDisplay.displayNode(); tempDisplay = tempDisplay.next; // move to next Node System.out.print(\"-->\"); } System.out.println(); } } /** * Main class - To test LinkedList. */ public class SinglyLinkedListDeleteNodeExample { public static void main(String[] args) { LinkedList linkedList = new LinkedList(); /.
1 of 8
Download to read offline
![Node current = first;
while (current != null) {
if (current.data == deleteKey) {
System.out.println("Node with data=" + current.data
+ " has been deleted.");
previous.next = current.next; // make previous node's next point
// to current node's next.
return current; // return deleted Node.
} else {
if (current.next == null) { // Means Node wasn't found.
System.out.println("Node with data=" + deleteKey
+ " wasn't found for deletion.");
return null;
}
previous = current;
current = current.next; // move to next node.
}
}
return null;
}
/**
* Display Singly LinkedList
*/
public void displayLinkedList() {
System.out.print("Displaying LinkedList [first--->last]: ");
Node tempDisplay = first; // start at the beginning of linkedList
while (tempDisplay != null) { // Executes until we don't find end of
// list.
tempDisplay.displayNode();
tempDisplay = tempDisplay.next; // move to next Node
System.out.print("-->");
}
System.out.println();
}
}
/**](https://image.slidesharecdn.com/exceptiontoindicatethatsinglylinkedlistisempty-230630165133-15053a4f/85/Exception-to-indicate-that-Singly-LinkedList-is-empty-pdf-3-320.jpg)
![* Main class - To test LinkedList.
*/
public class SinglyLinkedListDeleteNodeExample {
public static void main(String[] args) {
LinkedList linkedList = new LinkedList(); // creation of Linked List
linkedList.insertFirst(92);
linkedList.insertFirst(20);
linkedList.insertFirst(19);
linkedList.insertFirst(29);
linkedList.displayLinkedList(); // display LinkedList
linkedList.deleteSpecificNode(20);
linkedList.displayLinkedList(); // Again display LinkedList
}
}
OUTPUT:
Displaying LinkedList [first--->last]: 29 -->19 -->20 -->92 -->
Node with data=20 has been deleted.
Node with data=11 wasn't found for deletion.
Displaying LinkedList [first--->last]: 29 -->19 -->92 -->
Solution
/**
* Exception to indicate that Singly LinkedList is empty.
*/
class LinkedListEmptyException extends RuntimeException {
public LinkedListEmptyException() {
super();
}
public LinkedListEmptyException(String message) {
super(message);
}
}
/**
* Node class, which holds data and contains next which points to next Node.
*/](https://image.slidesharecdn.com/exceptiontoindicatethatsinglylinkedlistisempty-230630165133-15053a4f/85/Exception-to-indicate-that-Singly-LinkedList-is-empty-pdf-4-320.jpg)
![current = current.next; // move to next node.
}
}
return null;
}
/**
* Display Singly LinkedList
*/
public void displayLinkedList() {
System.out.print("Displaying LinkedList [first--->last]: ");
Node tempDisplay = first; // start at the beginning of linkedList
while (tempDisplay != null) { // Executes until we don't find end of
// list.
tempDisplay.displayNode();
tempDisplay = tempDisplay.next; // move to next Node
System.out.print("-->");
}
System.out.println();
}
}
/**
* Main class - To test LinkedList.
*/
public class SinglyLinkedListDeleteNodeExample {
public static void main(String[] args) {
LinkedList linkedList = new LinkedList(); // creation of Linked List
linkedList.insertFirst(92);
linkedList.insertFirst(20);
linkedList.insertFirst(19);
linkedList.insertFirst(29);
linkedList.displayLinkedList(); // display LinkedList
linkedList.deleteSpecificNode(20);
linkedList.displayLinkedList(); // Again display LinkedList
}
}
OUTPUT:](https://image.slidesharecdn.com/exceptiontoindicatethatsinglylinkedlistisempty-230630165133-15053a4f/85/Exception-to-indicate-that-Singly-LinkedList-is-empty-pdf-7-320.jpg)
![Displaying LinkedList [first--->last]: 29 -->19 -->20 -->92 -->
Node with data=20 has been deleted.
Node with data=11 wasn't found for deletion.
Displaying LinkedList [first--->last]: 29 -->19 -->92 -->](https://image.slidesharecdn.com/exceptiontoindicatethatsinglylinkedlistisempty-230630165133-15053a4f/85/Exception-to-indicate-that-Singly-LinkedList-is-empty-pdf-8-320.jpg)
Ad
Recommended
please i need help Im writing a program to test the merge sort alg.pdf
please i need help Im writing a program to test the merge sort alg.pdfezonesolutions please i need help I\'m writing a program to test the merge sort algorithm for linked lists.
I need to Print the list before being sorted and the list after sorting the elements
here is my code only help in test program the four classes are ok except the test program.
TEST PROGRAM
import java.io.*;
import java.util.*;
public class Ch9_ProgExercise7 {
Scanner input = new Scanner(System.in);
public static void main(String[] args) throws IOException {
OrderedLinkedList list
= new OrderedLinkedList(); //Line 1
IntElement num = new IntElement(); //Line 2
// Prompt the user to enter some integers
System.out.println(\"Enter integers numbers \");
String temp = input.hasnextLine();
String[] split = temp.split(\" \");
for (int i = 0; i < split.length; i++) {
Integer a = Integer.parseInt(split[i]);
// insert the intgers into the list you created above
num.setNum(a);
list.insertNode(num);
}
System.out.println();
// Print the list before being sorted
// call the mergesort method
System.out.println();
// print the list after sorting the elements
}
}
ORDEREDLICKEDLIST CLASS
public class OrderedLinkedList extends LinkedListClass
{
//default constructor
public OrderedLinkedList()
{
super();
}
//copy constructor
public OrderedLinkedList(OrderedLinkedList otherList)
{
super(otherList);
}
public void linkedInsertionSort()
{
LinkedListNode lastInOrder;
LinkedListNode firstOutOfOrder;
LinkedListNode current;
LinkedListNode trailCurrent;
lastInOrder = first;
if(first == null)
System.out.println(\"Cannot sort an empty list\");
else
if(first.link == null)
System.out.println(\"The list is of length 1. \"
+ \"Already in order\");
else
while(lastInOrder.link != null)
{
firstOutOfOrder = lastInOrder.link;
if(firstOutOfOrder.info.compareTo(first.info) < 0)
{
lastInOrder.link = firstOutOfOrder.link;
firstOutOfOrder.link = first;
first = firstOutOfOrder;
}
else
{
trailCurrent = first;
current = first.link;
while(current.info.compareTo(firstOutOfOrder.info) < 0)
{
trailCurrent = current;
current = current.link;
}
if(current != firstOutOfOrder)
{
lastInOrder.link = firstOutOfOrder.link;
firstOutOfOrder.link = current;
trailCurrent.link = firstOutOfOrder;
}
else
lastInOrder = lastInOrder.link;
}
}
}//end linkedInsertionSort
//Method to determine whether searchItem is in
//the list.
//Postcondition: Returns true if searchItem is found
// in the list; otherwise, it returns
// false.
public boolean search(DataElement searchItem)
{
LinkedListNode current; //variable to traverse the list
boolean found;
current = first; //set current to point to the first
//node in the list
found = false; //set found to false
while(current != null && !found ) //search the list
if(current.info.compareTo(searchItem) >= 0)
found = true;
else
current = current.link; //make current point to
//the next node
if(found)
found = current.info.equals(searchItem);
return found;
}
//Method to insert insertItem in the list
//Postcondition: first points to the new list,
// newItem is inserted at the proper place
//.
Using NetBeansImplement a queue named QueueLL using a Linked List .pdf
Using NetBeansImplement a queue named QueueLL using a Linked List .pdfsiennatimbok52331 Using NetBeans
Implement a queue named QueueLL using a Linked List (same as we did for the stack). This
implementation must be used in all the following problems.
Implement a queue QueueST using a stack (use StackLL).
Test your implementations in the main with examples.
Solution
Answer:-
import java.util.*;
/* Class Node */
class Node
{
protected int data;
protected Node link;
/* Constructor */
public Node()
{
link = null;
data = 0;
}
/* Constructor */
public Node(int d,Node n)
{
data = d;
link = n;
}
/* Function to set link to next Node */
public void setLink(Node n)
{
link = n;
}
/* Function to set data to current Node */
public void setData(int d)
{
data = d;
}
/* Function to get link to next node */
public Node getLink()
{
return link;
}
/* Function to get data from current Node */
public int getData()
{
return data;
}
}
/* Class linkedQueue */
class linkedQueue
{
protected Node front, rear;
public int size;
/* Constructor */
public linkedQueue()
{
front = null;
rear = null;
size = 0;
}
/* Function to check if queue is empty */
public boolean isEmpty()
{
return front == null;
}
/* Function to get the size of the queue */
public int getSize()
{
return size;
}
/* Function to insert an element to the queue */
public void insert(int data)
{
Node nptr = new Node(data, null);
if (rear == null)
{
front = nptr;
rear = nptr;
}
else
{
rear.setLink(nptr);
rear = rear.getLink();
}
size++ ;
}
/* Function to remove front element from the queue */
public int remove()
{
if (isEmpty() )
throw new NoSuchElementException(\"Underflow Exception\");
Node ptr = front;
front = ptr.getLink();
if (front == null)
rear = null;
size-- ;
return ptr.getData();
}
/* Function to check the front element of the queue */
public int peek()
{
if (isEmpty() )
throw new NoSuchElementException(\"Underflow Exception\");
return front.getData();
}
/* Function to display the status of the queue */
public void display()
{
System.out.print(\"\ Queue = \");
if (size == 0)
{
System.out.print(\"Empty\ \");
return ;
}
Node ptr = front;
while (ptr != rear.getLink() )
{
System.out.print(ptr.getData()+\" \");
ptr = ptr.getLink();
}
System.out.println();
}
}
/* Class LinkedQueueImplement */
public class LinkedQueueImplement
{
public static void main(String[] args)
{
Scanner scan = new Scanner(System.in);
/* Creating object of class linkedQueue */
linkedQueue lq = new linkedQueue();
/* Perform Queue Operations */
System.out.println(\"Linked Queue Test\ \");
char ch;
do
{
System.out.println(\"\ Queue Operations\");
System.out.println(\"1. insert\");
System.out.println(\"2. remove\");
System.out.println(\"3. peek\");
System.out.println(\"4. check empty\");
System.out.println(\"5. size\");
int choice = scan.nextInt();
switch (choice)
{
case 1 :
System.out.println(\"Enter integer element to insert\");
lq.insert( scan.nextInt() );
break;
case 2 :
try
{
System.out.println(\"Removed Element = \"+ lq.remove());
}
catch (Exception e)
{
System.out.println(\"Error : \" + e.getMessage());
}
break;
case 3 .
Sorted number list implementation with linked listsStep 1 Inspec.pdf
Sorted number list implementation with linked listsStep 1 Inspec.pdfalmaniaeyewear Sorted number list implementation with linked lists
Step 1: Inspect the Node.java file
Inspect the class declaration for a doubly-linked list node in Node.java. Access Node.java by
clicking on the orange arrow next to LabProgram.java at the top of the coding window. The
Node class has three fields:
a double data value,
a reference to the next node, and
a reference to the previous node.
Each field is protected. So code outside of the class must use the provided getter and setter
methods to get or set a field.
Node.java is read only, since no changes are required.
Step 2: Implement the insert() method
A class for a sorted, doubly-linked list is declared in SortedNumberList.java. Implement the
SortedNumberList class's insert() method. The method must create a new node with the
parameter value, then insert the node into the proper sorted position in the linked list. Ex:
Suppose a SortedNumberList's current list is 23 47.25 86, then insert(33.5) is called. A new
node with data value 33.5 is created and inserted between 23 and 47.25, thus preserving the list's
sorted order and yielding: 23 35.5 47.25 86
Step 3: Test in develop mode
Code in main() takes a space-separated list of numbers and inserts each into a SortedNumberList.
The list is displayed after each insertion. Ex: If input is
then output is:
Try various program inputs, ensuring that each outputs a sorted list.
Step 4: Implement the remove() method
Implement the SortedNumberList class's remove() method. The method takes a parameter for the
number to be removed from the list. If the number does not exist in the list, the list is not
changed and false is returned. Otherwise, the first instance of the number is removed from the
list and true is returned.
Uncomment the commented-out part in main() that reads a second input line and removes
numbers from the list. Test in develop mode to ensure that insertion and removal both work
properly, then submit code for grading. Ex: If input is
then output is:
Given templates:
LabProgram.java
import java.util.Scanner;
import java.io.PrintWriter;
public class LabProgram {
// Prints the SortedNumberList's contents, in order from head to tail
public static void printList(SortedNumberList list) {
Node node = list.head;
while (null != node) {
System.out.print(node.getData() + " ");
node = node.getNext();
}
System.out.println();
}
public static void main(String[] args) {
Scanner scnr = new Scanner(System.in);
String inputLine;
// Read the line of input numbers
inputLine = scnr.nextLine();
// Split on space character
String[] terms = inputLine.split(" ");
// Insert each value and show the sorted list's contents after each insertion
SortedNumberList list = new SortedNumberList();
for (Object term : terms) {
double number = Double.parseDouble(term.toString());
System.out.println("List after inserting " + number + ": ");
list.insert(number);
printList(list);
}
/*
// Read the input line with numbers to remove
inputLine = scnr.nextLine();
terms = inputLine.split(" ".
How do I fix it in LinkedList.javaLabProgram.javaLinkedList.jav.pdf
How do I fix it in LinkedList.javaLabProgram.javaLinkedList.jav.pdfmail931892 How do I fix it in LinkedList.java?
LabProgram.java
LinkedList.java:
/**
* Defines a doubly-linked list class
* @author
* @author
*/
import java.util.NoSuchElementException;
public class LinkedList {
private class Node {
private T data;
private Node next;
private Node prev;
public Node(T data) {
this.data = data;
this.next = null;
this.prev = null;
}
}
private int length;
private Node first;
private Node last;
private Node iterator;
/**** CONSTRUCTORS ****/
/**
* Instantiates a new LinkedList with default values
* @postcondition
*/
public LinkedList() {
first = null;
last = null;
iterator = null;
length = 0;
}
/**
* Converts the given array into a LinkedList
* @param array the array of values to insert into this LinkedList
* @postcondition
*/
public LinkedList(T[] array) {
}
/**
* Instantiates a new LinkedList by copying another List
* @param original the LinkedList to copy
* @postcondition a new List object, which is an identical,
* but separate, copy of the LinkedList original
*/
public LinkedList(LinkedList original) {
}
/**** ACCESSORS ****/
public T getFirst() throws NoSuchElementException {
if (isEmpty()){
throw new NoSuchElementException("The list is empty");
}
return first.data;
}
public T getLast() throws NoSuchElementException {
if (isEmpty()){
throw new NoSuchElementException("The list is empty");
}
return last.data;
}
/**
* Returns the data stored in the iterator node
* @precondition
* @return the data stored in the iterator node
* @throw NullPointerException
*/
public T getIterator() throws NullPointerException {
if (iterator != null){
return iterator.data;
}else{
throw new NullPointerException("Iterator is off the end opf the list.");
}
}
/**
* Returns the current length of the LinkedList
* @return the length of the LinkedList from 0 to n
*/
public int getLength() {
return length;
}
/**
* Returns whether the LinkedList is currently empty
* @return whether the LinkedList is empty
*/
public boolean isEmpty() {
return length == 0;
}
/**
* Returns whether the iterator is offEnd, i.e. null
* @return whether the iterator is null
*/
public boolean offEnd() {
return iterator == null;
}
/**** MUTATORS ****/
public void addFirst(T data) {
Node newNode = new Node(data);
if(isEmpty()){
first = newNode;
last = newNode;
}
else{
newNode.next = first;
first.prev = newNode;
first = newNode;
}
length++;
}
public void addLast(T data) {
Node newNode = new Node(data);
if(isEmpty()){
first = newNode;
last = newNode;
}
else{
last.next = newNode;
newNode.prev = last;
last = newNode;
}
length++;
}
/**
* Inserts a new element after the iterator
* @param data the data to insert
* @precondition
* @throws NullPointerException
*/
public void addIterator(T data) throws NullPointerException{
if(iterator != null){
Node newNode = new Node(data);
newNode.next = iterator.next;
iterator.next = newNode;
if (iterator == first){
first = newNode;
}
}else{
throw new NullPointerException("Iterator is off the end opf the list.");
}
}
/
public void removeFirst() throws NoS.
Here is the editable codeSolutionimport java.util.NoSuchEleme.pdf
Here is the editable codeSolutionimport java.util.NoSuchEleme.pdfarrowmobile Here is the editable code:
Solution
import java.util.NoSuchElementException;
public class DoublyLinkedListImpl {
private Node head;
private Node tail;
private int size;
public DoublyLinkedListImpl() {
size = 0;
}
private class Node {
E element;
Node next;
Node prev;
public Node(E element, Node next, Node prev) {
this.element = element;
this.next = next;
this.prev = prev;
}
}
public int size() { return size; }
public boolean isEmpty() { return size == 0; }
public void addFirst(E element) {
Node tmp = new Node(element, head, null);
if(head != null ) {head.prev = tmp;}
head = tmp;
if(tail == null) { tail = tmp;}
size++;
System.out.println(\"adding: \"+element);
}
/**
* adds element at the end of the linked list
* @param element
*/
public void addLast(E element) {
Node tmp = new Node(element, null, tail);
if(tail != null) {tail.next = tmp;}
tail = tmp;
if(head == null) { head = tmp;}
size++;
System.out.println(\"adding: \"+element);
}
public void iterateForward(){
System.out.println(\"iterating forward..\");
Node tmp = head;
while(tmp != null){
System.out.println(tmp.element);
tmp = tmp.next;
}
}
/**
* this method walks backward through the linked list
*/
public void iterateBackward(){
System.out.println(\"iterating backword..\");
Node tmp = tail;
while(tmp != null){
System.out.println(tmp.element);
tmp = tmp.prev;
}
}
public E removeFirst() {
if (size == 0) throw new NoSuchElementException();
Node tmp = head;
head = head.next;
head.prev = null;
size--;
System.out.println(\"deleted: \"+tmp.element);
return tmp.element;
}
public E removeLast() {
if (size == 0) throw new NoSuchElementException();
Node tmp = tail;
tail = tail.prev;
tail.next = null;
size--;
System.out.println(\"deleted: \"+tmp.element);
return tmp.element;
}
public static void main(String a[]){
DoublyLinkedListImpl dll = new DoublyLinkedListImpl();
dll.addFirst(10);
dll.addFirst(34);
dll.addLast(56);
dll.addLast(364);
dll.iterateForward();
dll.removeFirst();
dll.removeLast();
dll.iterateBackward();
}
}
import java.util.Scanner;
/* Class Node */
class Node
{
protected int data;
protected Node next, prev;
/* Constructor */
public Node()
{
next = null;
prev = null;
data = 0;
}
/* Constructor */
public Node(int d, Node n, Node p)
{
data = d;
next = n;
prev = p;
}
/* Function to set link to next node */
public void setLinkNext(Node n)
{
next = n;
}
/* Function to set link to previous node */
public void setLinkPrev(Node p)
{
prev = p;
}
/* Funtion to get link to next node */
public Node getLinkNext()
{
return next;
}
/* Function to get link to previous node */
public Node getLinkPrev()
{
return prev;
}
/* Function to set data to node */
public void setData(int d)
{
data = d;
}
/* Function to get data from node */
public int getData()
{
return data;
}
}
/* Class linkedList */
class linkedList
{
protected Node start;
protected Node end ;
public int size;
/* Constructor */
public linkedList()
{
start = null;
end = null;
size = 0;
}
/* Function to check if list is empty */
public boolean isE.
File LinkedList.java Defines a doubly-l.pdf
File LinkedList.java Defines a doubly-l.pdfConint29 File: LinkedList.java
/**
* Defines a doubly-linked list class
*/
import java.util.NoSuchElementException;
public class LinkedList {
private class Node {
private T data;
private Node next;
private Node prev;
public Node(T data) {
this.data = data;
this.next = null;
this.prev = null;
}
}
private int length;
private Node first;
private Node last;
private Node iterator;
/**** CONSTRUCTORS ****/
/**
* Instantiates a new LinkedList with default values
* @postcondition
*/
public LinkedList() {
}
/**
* Converts the given array into a LinkedList
* @param array the array of values to insert into this LinkedList
* @postcondition
*/
public LinkedList(T[] array) {
}
/**
* Instantiates a new LinkedList by copying another List
* @param original the LinkedList to copy
* @postcondition a new List object, which is an identical,
* but separate, copy of the LinkedList original
*/
public LinkedList(LinkedList original) {
}
/**** ACCESSORS ****/
/**
* Returns the value stored in the first node
* @precondition
* @return the value stored at node first
* @throws NoSuchElementException
*/
public T getFirst() throws NoSuchElementException {
return null;
}
/**
* Returns the value stored in the last node
* @precondition
* @return the value stored in the node last
* @throws NoSuchElementException
*/
public T getLast() throws NoSuchElementException {
return null;
}
/**
* Returns the data stored in the iterator node
* @precondition
* @return the data stored in the iterator node
* @throw NullPointerException
*/
public T getIterator() throws NullPointerException {
return null;
}
/**
* Returns the current length of the LinkedList
* @return the length of the LinkedList from 0 to n
*/
public int getLength() {
return -1;
}
/**
* Returns whether the LinkedList is currently empty
* @return whether the LinkedList is empty
*/
public boolean isEmpty() {
return false;
}
/**
* Returns whether the iterator is offEnd, i.e. null
* @return whether the iterator is null
*/
public boolean offEnd() {
return false;
}
/**** MUTATORS ****/
/**
* Creates a new first element
* @param data the data to insert at the front of the LinkedList
* @postcondition
*/
public void addFirst(T data) {
return;
}
/**
* Creates a new last element
* @param data the data to insert at the end of the LinkedList
* @postcondition
*/
public void addLast(T data) {
return;
}
/**
* Inserts a new element after the iterator
* @param data the data to insert
* @precondition
* @throws NullPointerException
*/
public void addIterator(T data) throws NullPointerException{
return;
}
/**
* removes the element at the front of the LinkedList
* @precondition
* @postcondition
* @throws NoSuchElementException
*/
public void removeFirst() throws NoSuchElementException {
return;
}
/**
* removes the element at the end of the LinkedList
* @precondition
* @postcondition
* @throws NoSuchElementException
*/
public void removeLast() throws NoSuchElementException {
return;
}
/**
* removes the element referenced by the iterator
* @precondition
* @pos.
LabProgram.javaimport java.util.NoSuchElementException;public .pdf
LabProgram.javaimport java.util.NoSuchElementException;public .pdffantasiatheoutofthef LabProgram.java
import java.util.NoSuchElementException;
public class LinkedList {
private class Node {
private T data;
private Node next;
private Node prev;
public Node(T data) {
this.data = data;
this.next = null;
this.prev = null;
}
}
private int length;
private Node first;
private Node last;
private Node iterator;
/**** CONSTRUCTORS ****/
/**
* Instantiates a new LinkedList with default values
* @postcondition
*/
public LinkedList() {
first = null;
last = null;
iterator = null;
length = 0;
}
/**
* Converts the given array into a LinkedList
* @param array the array of values to insert into this LinkedList
* @postcondition
*/
public LinkedList(T[] array) {
}
/**
* Instantiates a new LinkedList by copying another List
* @param original the LinkedList to copy
* @postcondition a new List object, which is an identical,
* but separate, copy of the LinkedList original
*/
public LinkedList(LinkedList original) {
}
/**** ACCESSORS ****/
/**
* Returns the value stored in the first node
* @precondition <>
* @return the value stored at node first
* @throws NoSuchElementException <>
*/
public T getFirst() throws NoSuchElementException {
if (isEmpty()){
throw new NoSuchElementException("The list is empty");
}
return first.data;
}
/**
* Returns the value stored in the last node
* @precondition <>
* @return the value stored in the node last
* @throws NoSuchElementException <>
*/
public T getLast() throws NoSuchElementException {
if (isEmpty()){
throw new NoSuchElementException("The list is empty");
}
return last.data;
}
/**
* Returns the data stored in the iterator node
* @precondition
* @return the data stored in the iterator node
* @throw NullPointerException
*/
public T getIterator() throws NullPointerException {
return iterator.data;
}
/**
* Returns the current length of the LinkedList
* @return the length of the LinkedList from 0 to n
*/
public int getLength() {
return length;
}
/**
* Returns whether the LinkedList is currently empty
* @return whether the LinkedList is empty
*/
public boolean isEmpty() {
return length == 0;
}
/**
* Returns whether the iterator is offEnd, i.e. null
* @return whether the iterator is null
*/
public boolean offEnd() {
return iterator == null;
}
/**** MUTATORS ****/
/**
* Creates a new first element
* @param data the data to insert at the front of the LinkedList
* @postcondition <>
*/
public void addFirst(T data) {
Node newNode = new Node(data);
if(isEmpty()){
first = newNode;
last = newNode;
}
else{
newNode.next = first;
first.prev = newNode;
first = newNode;
}
length++;
}
/**
* Creates a new last element
* @param data the data to insert at the end of the LinkedList
* @postcondition <>
*/
public void addLast(T data) {
Node newNode = new Node(data);
if(isEmpty()){
first = newNode;
last = newNode;
}
else{
last.next = newNode;
newNode.prev = last;
last = newNode;
}
length++;
}
/**
* Inserts a new element after the iterator
* @param data the data to insert
* @precondition
* @throws NullPointerException
*/
public void addIter.
This assignment and the next (#5) involve design and development of a.pdf
This assignment and the next (#5) involve design and development of a.pdfEricvtJFraserr This assignment and the next (#5) involve design and development of a sequential
non contiguous and dynamic datastructure called LinkedList. A linked list object is
a container consisting of connected ListNode objects. As before, we are not going
to use pre-fabricated classes from the c++ library, but construct the LinkedList
ADT from scratch.
The first step is construction and testing of the ListNode class. A ListNode object
contains a data field and a pointer to the next ListNode object (note the recursive
definition).
#This assignment requires you to
1. Read the Assignment 4 Notes
2. Watch the Assignment 4 Support video
3. Implement the following methods of the ListNode class
-custom constructor
-setters for next pointer and data
4. Implement the insert and remove method in the main program
5. Scan the given template to find the above //TODO and implement the code
needed
//TODO in ListNodecpp.h file
public: ListNode(T idata, ListNode<T> * newNext);
public: void setNext(ListNode<T> * newNext);
public: void setData(T newData);
// TODO in main program
void remove(ListNode<int> * &front,int value)
void insert(ListNode<int> * &front,int value)
# The driver is given ListNodeMain.cpp is given to you that does the following
tests
1. Declares a pointer called front to point to a ListNode of datatype integer
2. Constructs four ListNodes with data 1,2,4 and adds them to form a linked
list.
3. Inserts ListNode with data 3 to the list
4. Removes node 1 and adds it back to test removing and adding the first
element
5. Removes node 3 to test removing a middle node
6. Removes node 4 to test removing the last node
7. Attempt to remove a non existent node
8. Remove all existing nodes to empty the list
9. Insert node 4 and then node 1 to test if insertions preserve order
10.Print the list
Main.cpp
#include <iostream>
#include "ListNodecpp.h"
// REMEMBER each ListNode has two parts : a data field
// and an address field. The address is either null or points to the next node
//in the chain
//Requires: integer value for searching, address of front
//Effects: traverses the list node chain starting from front until the end comparing search value
with listnode getData. Returns the original search value if found, if not adds +1 to indicate not
found
//Modifies: Nothing
int search(ListNode<int> * front, int value);
//Requires: integer value for inserting, address of front
//Effects: creates a new ListNode with value and inserts in proper position (increasing order)in
the chain. If chain is empty, adds to the beginning
//Modifies: front, if node is added at the beginning.
//Also changes the next pointer of the previous node to point to the
//newly inserted list node. the next pointer of the newly inserted pointer
//points to what was the next of the previous node.
//This way both previous and current links are adjusted
//******** NOTE the use of & in passing pointer to front as parameter -
// Why do you think this is needed ?**********
void insert(ListNode<int> * &fr.
In C++Write a recursive function to determine whether or not a Lin.pdf
In C++Write a recursive function to determine whether or not a Lin.pdfflashfashioncasualwe In C++
Write a recursive function to determine whether or not a Linked List is in sorted order (smallest
value to largest value).
Add the following function prototypes to your List class under the section for access functions,
then implement the functions below the class definition:
public:
/**Access Functions*/
bool isSorted();
//Wrapper function that calls the isSorted helper function to determine whether
//a list is sorted in ascending order.
//We will consider that a list is trivially sorted if it is empty.
//Therefore, no precondition is needed for this function
private:
bool isSorted(Nodeptr node);
//Helper function for the public isSorted() function.
//Recursively determines whether a list is sorted in ascending order.
#include //for NULL
#include
#include
using namespace std;
template //list stores generic list data, not any specific C++ type
class List
{
private:
struct Node
{
listdata data;
Node* next;
Node* previous;
Node(listdata data): data(data), next(NULL), previous(NULL){}
};
typedef struct Node* Nodeptr;
Nodeptr first;
Nodeptr last;
Nodeptr iterator;
int size;
public:
/**Constructors and Destructors*/
List();
//Default constructor; initializes and empty list
//Postcondition: numeric values equated to zero, or strings should be empty.
List(const List &list);
~List();
//Destructor. Frees memory allocated to the list
//Postcondition: position NodePtr at next Node
/**Accessors*/
listdata getFirst();
//Returns the first element in the list
//Precondition:NodePtr points to the first node on list
listdata getLast();
//Returns the last element in the list
//Precondition: make new node first on the list
listdata getIterator();
bool isEmpty();
//Determines whether a list is empty.
int getSize();
//Returns the size of the list
/**Manipulation Procedures*/
void startIterator();
void advanceIterator();
void removeLast();
//Removes the value of the last element in the list
//Precondition: list is not empty, not the first element.
//Postcondition: one remaining node
void removeIterator();
void removeFirst();
//Removes the value of the first element in the list
//Precondition: list is not empty
//Postcondition: no nodes left
void insertLast(listdata data);
//Inserts a new element at the end of the list
//If the list is empty, the new element becomes both first and last
//Postcondition: next equal to null
void insertFirst(listdata data);
//Inserts a new element at the start of the list
//If the list is empty, the new element becomes both first and last
//Postcondition:point nodePtr next node on list
/**Additional List Operations*/
bool offEnd();
void printList();
//Prints to the console the value of each element in the list sequentially
//and separated by a blank space
//Prints nothing if the list is empty
void insertIterator(listdata data);
bool operator==(const List &list);
};
// constructor definition
template
List::List(): first(NULL), last(NULL), iterator(NULL), size(0) {}
template
List::List(const List &list): size(list.size)
{
if(list..
PROBLEM STATEMENTIn this assignment, you will complete DoubleEnde.pdf
PROBLEM STATEMENTIn this assignment, you will complete DoubleEnde.pdfclimatecontrolsv 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.
How do you stop infinite loop Because I believe that it is making a.pdf
How do you stop infinite loop Because I believe that it is making a.pdffeelinggift How do you stop infinite loop? Because I believe that it is making an infinite circular list.
c++ code:
Here is the list class:
#ifndef LIN_J_LIST
#define LIN_J_LIST
typedef unsigned int uint;
#include
#include
using namespace std;
/**
* a simplified generic singly linked list class to illustrate C++ concepts
* @author Jerry Lin
* @version 2/17/17
*/
template< typename Object >
class List
{
private:
/**
* A class to store data and provide a link to the next node in the list
*/
class Node
{
public:
/**
* The constructor
* @param data the data to be stored in this node
*/
explicit Node( const Object & data )
: data{ data }, next{ nullptr } {}
Object data;
Node * next;
};
public:
/**
* The constructor for an empty list
*/
List()
: size{ 0 }, first{ nullptr }, last{ nullptr } {}
/**
* the copy constructor-creates and copy the list
*/
List( List && rhs ) = delete;
List( const List & rhs )
{
count = 0;
size = 0;
if(rhs.size != 0)
{
push_front(rhs.front());
Node * current = rhs.first;
Node * tempNode = first;
size++;
while(current->next != nullptr)
{
current = current->next;
Node *newNode = new Node(current->data); //transfer the data. basic op.
count++;
tempNode->next = newNode;
last = newNode;
tempNode = tempNode->next;
size++;
}
}
// you document and implement this method
}
/**
* the operator= method-copies the list
*/
List & operator=( List && rhs) = delete;
List & operator=( const List & rhs )
{
count = 0;
size = 0;
if( size != 0 )
{
Node * current = first;
Node * temp;
while( current != nullptr )
{
temp = current;
current = current->next;
delete temp;
}
}
if(rhs.size!= 0)
{
push_front(rhs.front());
Node * current = rhs.first;
Node * tempNode = first; //create a temporary to store
size++;
while(current -> next != nullptr)
{
current = current->next;
Node *newNode = new Node(current->data); //transfer the data. basic op
count++;
tempNode->next = newNode;
last = newNode;
tempNode = tempNode -> next;
size++;
}
}
return *this;
// you document and implement this method
}
/**
* accessor
* @return count
*/
int get_count() const
{
return count;
}
/**
* The destructor that gets rid of everything that\'s in the list and
* resets it to empty. If the list is already empty, do nothing.
*/
~List()
{
if( size != 0 )
{
Node * current = first;
Node * temp;
while( current != nullptr )
{
temp = current;
current = current->next;
delete temp;
}
}
}
/**
* Put a new element onto the beginning of the list
* @param item the data the new element will contain
*/
void push_front( const Object& item )
{
Node * new_node = new Node( item );//basic op.
if(is_empty())
{
last = new_node;
}
else
{
new_node->next = first;
}
first = new_node;
size++;
/* you complete the rest */
}
/**
* Remove the element that\'s at the front of the list. Causes an
* assertion error if the list is empty.
*/
void pop_front()
{
assert( !is_empty() );
Node * temp = first;
if( first == last )
{
first = last = nullptr;
}
else
{
first = first->next;
}
delete temp;
size--;
}
/**
* Accessor to return the da.
How do I fix it in javaLinkedList.java Defines a doubl.pdf
How do I fix it in javaLinkedList.java Defines a doubl.pdffmac5 How do I fix it in java?
LinkedList.java:
/**
* Defines a doubly-linked list class
* @author
* @author
*/
import java.util.NoSuchElementException;
public class LinkedList {
private class Node {
private T data;
private Node next;
private Node prev;
public Node(T data) {
this.data = data;
this.next = null;
this.prev = null;
}
}
private int length;
private Node first;
private Node last;
private Node iterator;
/**** CONSTRUCTORS ****/
/**
* Instantiates a new LinkedList with default values
* @postcondition
*/
public LinkedList() {
first = null;
last = null;
iterator = null;
length = 0;
}
/**
* Converts the given array into a LinkedList
* @param array the array of values to insert into this LinkedList
* @postcondition
*/
public LinkedList(T[] array) {
}
/**
* Instantiates a new LinkedList by copying another List
* @param original the LinkedList to copy
* @postcondition a new List object, which is an identical,
* but separate, copy of the LinkedList original
*/
public LinkedList(LinkedList original) {
}
/**** ACCESSORS ****/
public T getFirst() throws NoSuchElementException {
if (isEmpty()){
throw new NoSuchElementException("The list is empty");
}
return first.data;
}
public T getLast() throws NoSuchElementException {
if (isEmpty()){
throw new NoSuchElementException("The list is empty");
}
return last.data;
}
/**
* Returns the data stored in the iterator node
* @precondition
* @return the data stored in the iterator node
* @throw NullPointerException
*/
public T getIterator() throws NullPointerException {
if (iterator != null){
return iterator.data;
}else{
throw new NullPointerException("Iterator is off the end opf the list.");
}
}
/**
* Returns the current length of the LinkedList
* @return the length of the LinkedList from 0 to n
*/
public int getLength() {
return length;
}
/**
* Returns whether the LinkedList is currently empty
* @return whether the LinkedList is empty
*/
public boolean isEmpty() {
return length == 0;
}
/**
* Returns whether the iterator is offEnd, i.e. null
* @return whether the iterator is null
*/
public boolean offEnd() {
return iterator == null;
}
/**** MUTATORS ****/
public void addFirst(T data) {
Node newNode = new Node(data);
if(isEmpty()){
first = newNode;
last = newNode;
}
else{
newNode.next = first;
first.prev = newNode;
first = newNode;
}
length++;
}
public void addLast(T data) {
Node newNode = new Node(data);
if(isEmpty()){
first = newNode;
last = newNode;
}
else{
last.next = newNode;
newNode.prev = last;
last = newNode;
}
length++;
}
/**
* Inserts a new element after the iterator
* @param data the data to insert
* @precondition
* @throws NullPointerException
*/
public void addIterator(T data) throws NullPointerException{
if(iterator != null){
Node newNode = new Node(data);
newNode.next = iterator.next;
iterator.next = newNode;
if (iterator == first){
first = newNode;
}
}else{
throw new NullPointerException("Iterator is off the end opf the list.");
}
}
/
public void removeFirst() throws NoSuchElementException {
if(is.
The LinkedList1 class implements a Linked list. class.pdf
The LinkedList1 class implements a Linked list. class.pdfmalavshah9013 /**
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.
How do I fix it in LinkedList.javaLinkedList.java Define.pdf
How do I fix it in LinkedList.javaLinkedList.java Define.pdfmail931892 How do I fix it in LinkedList.java?
LinkedList.java:
/**
* Defines a doubly-linked list class
* @author
* @author
*/
import java.util.NoSuchElementException;
public class LinkedList {
private class Node {
private T data;
private Node next;
private Node prev;
public Node(T data) {
this.data = data;
this.next = null;
this.prev = null;
}
}
private int length;
private Node first;
private Node last;
private Node iterator;
/**** CONSTRUCTORS ****/
/**
* Instantiates a new LinkedList with default values
* @postcondition
*/
public LinkedList() {
first = null;
last = null;
iterator = null;
length = 0;
}
/**
* Converts the given array into a LinkedList
* @param array the array of values to insert into this LinkedList
* @postcondition
*/
public LinkedList(T[] array) {
}
/**
* Instantiates a new LinkedList by copying another List
* @param original the LinkedList to copy
* @postcondition a new List object, which is an identical,
* but separate, copy of the LinkedList original
*/
public LinkedList(LinkedList original) {
}
/**** ACCESSORS ****/
public T getFirst() throws NoSuchElementException {
if (isEmpty()){
throw new NoSuchElementException("The list is empty");
}
return first.data;
}
public T getLast() throws NoSuchElementException {
if (isEmpty()){
throw new NoSuchElementException("The list is empty");
}
return last.data;
}
/**
* Returns the data stored in the iterator node
* @precondition
* @return the data stored in the iterator node
* @throw NullPointerException
*/
public T getIterator() throws NullPointerException {
if (iterator != null){
return iterator.data;
}else{
throw new NullPointerException("Iterator is off the end opf the list.");
}
}
/**
* Returns the current length of the LinkedList
* @return the length of the LinkedList from 0 to n
*/
public int getLength() {
return length;
}
/**
* Returns whether the LinkedList is currently empty
* @return whether the LinkedList is empty
*/
public boolean isEmpty() {
return length == 0;
}
/**
* Returns whether the iterator is offEnd, i.e. null
* @return whether the iterator is null
*/
public boolean offEnd() {
return iterator == null;
}
/**** MUTATORS ****/
public void addFirst(T data) {
Node newNode = new Node(data);
if(isEmpty()){
first = newNode;
last = newNode;
}
else{
newNode.next = first;
first.prev = newNode;
first = newNode;
}
length++;
}
public void addLast(T data) {
Node newNode = new Node(data);
if(isEmpty()){
first = newNode;
last = newNode;
}
else{
last.next = newNode;
newNode.prev = last;
last = newNode;
}
length++;
}
/**
* Inserts a new element after the iterator
* @param data the data to insert
* @precondition
* @throws NullPointerException
*/
public void addIterator(T data) throws NullPointerException{
if(iterator != null){
Node newNode = new Node(data);
newNode.next = iterator.next;
iterator.next = newNode;
if (iterator == first){
first = newNode;
}
}else{
throw new NullPointerException("Iterator is off the end opf the list.");
}
}
/
public void removeFirst() throws NoSuchElementExcept.
mainpublic class AssignmentThree { public static void ma.pdf
mainpublic class AssignmentThree { public static void ma.pdffathimafancyjeweller // main
public class AssignmentThree
{
public static void main(String[] args)
{
List myList = new List(15);
// Cause List Empty Message
myList.removeFront();
myList.removeRear();
myList.removeItem(\"a\");
// Cause Not found message
myList.addToFront(\"x\");
myList.removeItem(\"y\");
myList.removeItem(\"x\");
myList.addAfterItem(\"x\", \"z\");
myList.addBeforeItem(\"x\", \"z\");
// Normal behavior
myList.addToFront(\"not.\");
myList.addToFront(\"or\");
myList.addToRear(\"is\");
myList.addToRear(\"try.\");
myList.addAfterItem(\"is\", \"no\");
myList.addBeforeItem(\"is\", \"There\");
myList.addToFront(\"Do\");
myList.addAfterItem(\"or\", \"do\");
myList.print(\"Original list\");
myList.printSorted(\"Sorted Original List\");
sop(\"\ Front is \" + myList.getFront());
sop(\"Rear is \" + myList.getRear());
sop(\"Count is \" + myList.askCount());
sop(\"Is There present? \" + myList.isPresent(\"There\"));
sop(\"Is Dog present? \" + myList.isPresent(\"Dog\"));
myList.addToFront(\"junk\");
myList.addToRear(\"morejunk\");
myList.addAfterItem(\"or\", \"moremorejunk\");
myList.print(\"List with junk\");
sop(\"Count is \" + myList.askCount());
myList.removeFront();
myList.removeRear();
myList.removeItem(\"moremorejunk\");
myList.print(\"List with junk removed\");
sop(\"Count is \" + myList.askCount());
sop(\"\");
// Cause List Full message
for(int ii = 0; ii < 10; ++ii)
{
myList.addToFront(DUMMY);
}
myList.addToRear(DUMMY);
myList.addBeforeItem(\"no\", DUMMY);
myList.addAfterItem(\"There\", DUMMY);
myList.print(\"After filling List\");
sop(\"Count is \" + myList.askCount());
while(myList.isPresent(DUMMY)) myList.removeItem(DUMMY);
myList.print(\"After removing \" + DUMMY );
sop(\"Count is \" + myList.askCount());
}
private static void sop(String s)
{
System.out.println(s);
}
private static final String DUMMY = \"dummy\";
}
Solution
Following is MyList implementation for your output as:
Java Code:
import java.util.Comparator;
public class MyList {
private Node start;
private Node end;
private int size;
private int capacity;
public MyList(int capacity) {
start = null;
end = null;
size = 0;
this.capacity = capacity;
}
/* Function to check if list is empty */
public boolean isEmpty() {
return start == null;
}
public void removeFront() {
if (isEmpty()) {
System.out.println(\"List Empty\");
return;
} else {
start = start.next;
size--;
return;
}
}
public void removeRear() {
if (size == 0) {
System.out.println(\"List Empty\");
return;
}
if (start.next == null) {
start=null;
end=null;
size=0;
}
Node node = start.next;
while (node.next != null) {
node = node.next;
}
node.next = null;
end = node;
size--;
}
public void removeItem(String key) {
if (size == 0) {
System.out.println(\"List Empty\");
return;
}
if (start.next == null) {
if (start.key.equals(key)) {
start=null;
end=null;
size=0;
} else {
System.out.println(\"\");
}
return;
}
Node node = start;
Node nodeNext = node.next;
while (nodeNext.next != null) {
if (nodeNext.key.equals(key)) {
node.next=nodeNext.next;
}.
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 .
Csphtp1 23
Csphtp1 23HUST This document outlines key concepts related to data structures including linked lists, stacks, queues, and trees. It provides code examples of a Node class that is self-referential, allowing objects to link to one another. A LinkedListLibrary class is defined, with methods for inserting and removing nodes from linked lists. A ListTest class tests the functionality of the List class.
Csphtp1 23
Csphtp1 23HUST The document outlines key concepts about data structures including linked lists, stacks, queues, and trees. It provides code examples for a Node class that is self-referential, allowing objects to link to each other. It also includes a List class that implements basic linked list functionality through methods like InsertAtFront, InsertAtBack, RemoveFromFront, and RemoveFromBack. The code examples demonstrate how to create and manipulate linked lists through a List object.
Implement a queue using a linkedlist (java)SolutionLinkedQueue.pdf
Implement a queue using a linkedlist (java)SolutionLinkedQueue.pdfkostikjaylonshaewe47 Implement a queue using a linkedlist (java)
Solution
LinkedQueueImplement.java
import java.util.*;
class Node
{
protected int data;
protected Node link;
public Node()
{
link = null;
data = 0;
}
public Node(int d,Node n)
{
data = d;
link = n;
}
public void setLink(Node n)
{
link = n;
}
public void setData(int d)
{
data = d;
}
public Node getLink()
{
return link;
}
public int getData()
{
return data;
}
}
class linkedQueue
{
protected Node front, rear;
public int size;
public linkedQueue()
{
front = null;
rear = null;
size = 0;
}
public boolean isEmpty()
{
return front == null;
}
public int getSize()
{
return size;
}
/* Function to insert an element to the queue */
public void insert(int data)
{
Node nptr = new Node(data, null);
if (rear == null)
{
front = nptr;
rear = nptr;
}
else
{
rear.setLink(nptr);
rear = rear.getLink();
}
size++ ;
}
/* Function to remove front element from the queue */
public int remove()
{
if (isEmpty() )
throw new NoSuchElementException(\"Underflow Exception\");
Node ptr = front;
front = ptr.getLink();
if (front == null)
rear = null;
size-- ;
return ptr.getData();
}
/* Function to check the front element of the queue */
public int peek()
{
if (isEmpty() )
throw new NoSuchElementException(\"Underflow Exception\");
return front.getData();
}
/* Function to display the status of the queue */
public void display()
{
System.out.print(\"\ Queue = \");
if (size == 0)
{
System.out.print(\"Empty\ \");
return ;
}
Node ptr = front;
while (ptr != rear.getLink() )
{
System.out.print(ptr.getData()+\" \");
ptr = ptr.getLink();
}
System.out.println();
}
}
/* Class LinkedQueueImplement */
public class LinkedQueueImplement
{
public static void main(String[] args)
{
Scanner scan = new Scanner(System.in);
/* Creating object of class linkedQueue */
linkedQueue lq = new linkedQueue();
/* Perform Queue Operations */
System.out.println(\"Linked Queue Test\ \");
char ch;
do
{
System.out.println(\"\ Queue Operations\");
System.out.println(\"1. insert\");
System.out.println(\"2. remove\");
System.out.println(\"3. peek\");
System.out.println(\"4. check empty\");
System.out.println(\"5. size\");
int choice = scan.nextInt();
switch (choice)
{
case 1 :
System.out.println(\"Enter integer element to insert\");
lq.insert( scan.nextInt() );
break;
case 2 :
try
{
System.out.println(\"Removed Element = \"+ lq.remove());
}
catch (Exception e)
{
System.out.println(\"Error : \" + e.getMessage());
}
break;
case 3 :
try
{
System.out.println(\"Peek Element = \"+ lq.peek());
}
catch (Exception e)
{
System.out.println(\"Error : \" + e.getMessage());
}
break;
case 4 :
System.out.println(\"Empty status = \"+ lq.isEmpty());
break;
case 5 :
System.out.println(\"Size = \"+ lq.getSize());
break;
default :
System.out.println(\"Wrong Entry \ \");
break;
}
/* display queue */
lq.display();
System.out.println(\"\ Do you want to continue (Type y or n) \ \");
ch = scan.next().charAt(0);
} while (ch == \'Y\'|| ch == \'y\');
}
}
Output :
Linked Queue Test
Queue Operations
1. inse.
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.
Jhtp5 20 Datastructures
Jhtp5 20 Datastructuresmartha leon The document outlines different data structures including linked lists, stacks, and queues. It describes how linked lists use self-referential nodes connected by links and can dynamically grow and shrink. Stacks are described as a constrained version of linked lists that only allow adding and removing from one end, with the push and pop methods.
Write the following using javaGiven a class ‘Node’ and ‘NodeList’,.pdf
Write the following using javaGiven a class ‘Node’ and ‘NodeList’,.pdffathimalinks 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..
How do I fix it in LinkedList.javathis is what i didLabProgra.pdf
How do I fix it in LinkedList.javathis is what i didLabProgra.pdfmail931892 The document provides instructions for implementing iterator methods in a LinkedList class. It describes updating the default constructor to initialize the iterator field to null, and modifying removeFirst() and removeLast() methods to handle cases where the iterator is at the first or last node. It then lists 8 steps to implement iterator methods like positionIterator(), offEnd(), getIterator(), advanceIterator(), reverseIterator(), addIterator(), and removeIterator(). The main() method creates a linked list and calls the iterator methods to test their functionality.
Labprogram.javaLinkedList.javaimport java.util.NoSuchElementEx.pdf
Labprogram.javaLinkedList.javaimport java.util.NoSuchElementEx.pdffreddysarabia1 Labprogram.java
LinkedList.java
import java.util.NoSuchElementException;
public class LinkedList {
private class Node {
private T data;
private Node next;
private Node prev;
public Node(T data) {
this.data = data;
this.next = null;
this.prev = null;
}
}
private int length;
private Node first;
private Node last;
private Node iterator;
/**** CONSTRUCTORS ****/
public LinkedList() {
first = null;
last = null;
iterator = null;
length = 0;
}
/**
* Converts the given array into a LinkedList
*
* @param array the array of values to insert into this LinkedList
* @postcondition
*/
public LinkedList(T[] array) {
}
/**
* Instantiates a new LinkedList by copying another List
*
* @param original the LinkedList to copy
* @postcondition a new List object, which is an identical,
* but separate, copy of the LinkedList original
*/
public LinkedList(LinkedList original) {
}
public T getFirst() throws NoSuchElementException {
if (isEmpty()) {
throw new NoSuchElementException("The list is empty");
}
return first.data;
}
public T getLast() throws NoSuchElementException {
if (isEmpty()) {
throw new NoSuchElementException("The list is empty");
}
return last.data;
}
public T getIterator() throws NullPointerException {
if (iterator != null) {
return iterator.data;
} else {
throw new NullPointerException("Iterator is off the end opf the list.");
}
}
public int getLength() {
return length;
}
public boolean isEmpty() {
return length == 0;
}
public boolean offEnd() {
return iterator == null;
}
public void addFirst(T data) {
Node newNode = new Node(data);
if (isEmpty()) {
first = newNode;
last = newNode;
} else {
newNode.next = first;
first.prev = newNode;
first = newNode;
}
length++;
}
public void addLast(T data) {
Node newNode = new Node(data);
if (isEmpty()) {
first = newNode;
last = newNode;
} else {
last.next = newNode;
newNode.prev = last;
last = newNode;
}
length++;
}
public void addIterator(T data) throws NullPointerException {
if (offEnd()) {
throw new NullPointerException("addIterator Iterator is off end.");
}
if (iterator == last) {
addLast(data);
} else {
Node newNode = new Node(data);
Node next = iterator.next;
newNode.next = next;
newNode.prev = iterator;
iterator.next = newNode;
next.prev = newNode;
length++;
}
}
public void removeFirst() throws NoSuchElementException {
if (isEmpty()) {
throw new NoSuchElementException("The list is empty");
}
if (length == 1) {
first = null;
last = null;
iterator = null;
} else {
if (iterator == first) {
iterator = null;
}
first = first.next;
first.prev = null;
}
length--;
}
public void removeLast() throws NoSuchElementException {
if (isEmpty()) {
throw new NoSuchElementException("The list is empty");
}
if (length == 1) {
first = null;
last = null;
iterator = null;
} else {
if (iterator == last) {
iterator = null;
}
last = last.prev;
last.next = null;
}
length--;
}
public void removeIterator() throws NullPointerException {
if (offEnd()) {
throw new NullPointerException("Iterator is off the end opf the list.");
}
if (iterator .
StackInterface An interface for the ADT stack. Do not modif.pdf
StackInterface An interface for the ADT stack. Do not modif.pdfARCHANASTOREKOTA StackInterface
/**
An interface for the ADT stack.
Do not modify this file
*/
package PJ2;
public interface StackInterface
{
/** Gets the current number of data in this stack.
@return the integer number of entries currently in the stack*/
public int size();
/** Adds a new data to the top of this stack.
@param aData an object to be added to the stack */
public void push(T aData);
/** Removes and returns this stack\'s top data.
@return either the object at the top of the stack or,
if the stack is empty before the operation, null */
public T pop();
/** Retrieves this stack\'s top data.
@return either the data at the top of the stack or
null if the stack is empty */
public T peek();
/** Detects whether this stack is empty.
@return true if the stack is empty */
public boolean empty();
/** Removes all data from this stack */
public void clear();
} // end StackInterface
SimpleLinkedStack.java
/**
A class of stacks whose entries are stored in a chain of nodes.
Implement all methods in SimpleLinkedStack class using
the inner Node class.
Main Reference : text book or class notes
Do not change or add data fields
Do not add new methods
You may access Node object fields directly, i.e. data and next
*/
package PJ2;
public class SimpleLinkedStack implements StackInterface
{
// Data fields
private Node topNode; // references the first node in the chain
private int count; // number of data in this stack
public SimpleLinkedStack()
{
// add stataments
} // end default constructor
public void push(T newData)
{
// add stataments
} // end push
public T peek()
{
// add stataments
return null;
} // end peek
public T pop()
{
// add stataments
return null;
} // end pop
public boolean empty()
{
// add stataments
return false;
} // end empty
public int size()
{
// add stataments
return -1;
} // end isEmpty
public void clear()
{
// add stataments
} // end clear
public String toString()
{
// add stataments
// note: data class in stack must implement toString() method
// return a list of data in Stack, separate them with \',\'
return \"\";
}
/****************************************************
private inner node class
Do not modify this class!!
you may access data and next directly
***************************************************/
private class Node
{
private T data; // entry in list
private Node next; // link to next node
private Node (T dataPortion)
{
data = dataPortion;
next = null; // set next to NULL
} // end constructor
private Node (T dataPortion, Node nextNode)
{
data = dataPortion;
next = nextNode; // set next to refer to nextNode
} // end constructor
} // end Node
/****************************************************
Do not modify: Stack test
****************************************************/
public static void main (String args[])
{
System.out.println(\"\ \"+
\"*******************************************************\ \"+
\"Sample Expected output:\ \"+
\"\ \"+
\"OK: stack is empty\ \"+
\"Push 3 data: 10, 30, 50\ \"+
\"Print stack [50,30,10,]\ \"+
\"OK: sta.
THE CODE HAS A SEGMENTATION FAULT BUT I CANNOT FIND OUT WHERE. NEED .pdf
THE CODE HAS A SEGMENTATION FAULT BUT I CANNOT FIND OUT WHERE. NEED .pdffathimahardwareelect THE CODE HAS A SEGMENTATION FAULT BUT I CANNOT FIND OUT WHERE. NEED
HELP FIXING THIS CODE?
THIS IS THE PROBLEM
Write a program that allows the user to enter two positive integers and outputs their sum. Sounds
simple? Here\'s the catch: The numbers may be any size! They may be way too large to store in a
single variable. You may not assume any particular maximum number of digits.
HERE IS THE CODE
#include
#include
struct node /* Linked list node*/
{
int data;
struct node* next;
};
struct node *newNode(int data) /* Function to create a new node with giving the data*/
{
struct node *new_node = (struct node *) malloc(sizeof(struct node));
new_node->data = data;
new_node->next = NULL;
return new_node;
}
void push(struct node** head_ref, int new_data) /* Function to insert a node at the beginning of
the Doubly Linked List*/
{
struct node* new_node = newNode(new_data); /*allocate a node*/
new_node->next = (*head_ref); /* link the old list off to the new node*/
(*head_ref) = new_node; /*move the head to point to the new node*/
}
/* Adding the contents of two linked lists and return the head node of resultant list*/
struct node* addTwoLists (struct node* first, struct node* second)
{
struct node* res = NULL; /* res is head node of the resultant list*/
struct node *temp, *prev = NULL;
int carry = 0, sum;
while (first != NULL || second != NULL) /*while both the lists exists*/
{
/* Calculate value of next digit in resultant list.
// The next digit is sum of following things
// (i) Carry
// (ii) Next digit of first list (if there is a next digit)
// (ii) Next digit of second list (if there is a next digit)*/
sum = carry + (first? first->data: 0) + (second? second->data: 0);
carry = (sum >= 10)? 1 : 0; /* update carry for next calulation*/
sum = sum % 10; /*update sum if it is greater than 10*/
temp = newNode(sum); /*Create a new node with sum as data*/
if(res == NULL) /*if this is the first node then set it as head of the resultant list*/
res = temp;
else /* If this is not the first node then connect it to the rest.*/
prev->next = temp;
prev = temp; /* Set prev for next insertion*/
if (first) first = first->next; /* Move first pointers to next node*/
if (second) second = second->next; /*Move second pointer to the next node*/
}
if (carry > 0)
temp->next = newNode(carry);
return res; /* return head of the resultant list*/
}
void printList(struct node *node) /* function to print a linked list*/
{
while(node != NULL)
{
printf(\"%d \", node->data);
node = node->next;
}
printf(\"\ \");
}
int main(void) /* program to test above function*/
{
struct node* res = NULL;
struct node* first = NULL;
struct node* second = NULL;
printf(\"Enter first positive integer: \");
scanf(\"%d\",&first);
printList(first);
printf(\"Enter second positive integer: \");
scanf(\"%d\",&second);
printList(second);
/*Add the two lists and see result*/
res = addTwoLists(first, second);
printf(\"Sum is: %d\");
printList(res);
return 0;
}
Solution
#include
#include
typedef struct Node
{
int da.
Data Structures and Agorithm: DS 04 Linked List.pptx
Data Structures and Agorithm: DS 04 Linked List.pptxRashidFaridChishti Data Structures and Agorithm: DS 04 Linked List.pptx
Electronegativity - Electronegativity is an atom.pdf
Electronegativity - Electronegativity is an atom.pdfaravlitraders2012 Electronegativity - Electronegativity is an atom\'s \'desire\' to grab another atom\'s
electrons. In terms of ionization energy \"noble gas status\" is the golden standard. Elements in
group one only need to give up one electron to reach that status. For this reason they are highly
reactive and want go give up an electron to some other atom. Group 1 elements are the most
reactive followed by group 2. In order of increasing reactivity: Calcium, Magnesium, Sodium,
Potassium
Solution
Electronegativity - Electronegativity is an atom\'s \'desire\' to grab another atom\'s
electrons. In terms of ionization energy \"noble gas status\" is the golden standard. Elements in
group one only need to give up one electron to reach that status. For this reason they are highly
reactive and want go give up an electron to some other atom. Group 1 elements are the most
reactive followed by group 2. In order of increasing reactivity: Calcium, Magnesium, Sodium,
Potassium.
Sequence.h#ifndef MAIN #define MAIN #include cstdlibclass .pdf
Sequence.h#ifndef MAIN #define MAIN #include cstdlibclass .pdfaravlitraders2012 Sequence.h
#ifndef MAIN
#define MAIN
#include
class Sequence
{
public:
//TYPEDEFS and MEMBER CONSTANTS
typedef double value;
typedef std::size_t size_type;
static const size_type DEFAULT_CAPACITY = 30;
// CONSTRUCTORS and DESTRUCTOR
Sequence(size_type initial_capacity = DEFAULT_CAPACITY); //constructor
Sequence(const Sequence& start); // COPY CONSTRUCTOR
~Sequence( ); // DESTRUCTOR
// MODIFICATION MEMBER FUNCTIONS
void resize(size_type new_capacity);
void start( );
void advance( );
void insert(const value& entry);
void attach(const value& entry);
void remove_current( );
void operator =(const Sequence& start);
// CONSTANT MEMBER FUNCTIONS
size_type size( ) const;
bool is_item( ) const;
value current( ) const;
bool operator ==(const Sequence& other);
bool operator !=(const Sequence& other);
private:
void shift_down(size_type index);
void shift_up(size_type index);
value* data;
size_type used;
size_type current_index;
size_type capacity;
};
#endif
Sequence.cpp
#include
#include
#include \"Sequence.h\"
using namespace std;
Sequence::Sequence(size_type initial_capacity)
{
data= new value [initial_capacity];
current_index=0;
capacity=initial_capacity;
used=0;
}
Sequence::Sequence(const Sequence& start)
{
data=new value[start.capacity];
capacity=start.capacity;
current_index=start.current_index;
used=start.used;
copy(start.data,start.data+used,data);
}
Sequence::~Sequence( )
{
delete [] data;//it releases dynamic memory afterwards.
}
void Sequence::resize(size_type new_capacity)
{
assert(new_capacity > size ()); // capacity is less than the number of items
data=new double [size()];
delete [] data;
double *tempdata;// temporary array
tempdata=new double[size()];
for (unsigned int i=0; icurrent_index;i--)
data[i]=data[i-1];
data[current_index]=entry;
used++;
}
void Sequence::shift_down(size_type index)
{
}
void Sequence::attach(const value& entry)
{
if(used == capacity)
resize(used+1);
if(current_index >= used)
{
start();
advance();
advance();
}
if(used!=0)
{
for(size_type i = used; i > current_index+1; i--)
{
data[i] = data[i-1];
}
data[current_index+1] = entry;
current_index++;
}
data[current_index] = entry;
++used;
}
void Sequence::shift_up(size_type index)
{
}
void Sequence::remove_current( )
{
assert(is_item()==true);
for (unsigned int i=0; i
#include \"Sequence.h\"
using namespace std;
int main ( )
{
Sequence s;
s.insert(1);
s.insert(2);
s.insert(3);
s.insert(4);
s.insert(5);
s.start( );
cout << s.current( ) << endl;
system (\"pause\");
return 0;
}
Solution
Sequence.h
#ifndef MAIN
#define MAIN
#include
class Sequence
{
public:
//TYPEDEFS and MEMBER CONSTANTS
typedef double value;
typedef std::size_t size_type;
static const size_type DEFAULT_CAPACITY = 30;
// CONSTRUCTORS and DESTRUCTOR
Sequence(size_type initial_capacity = DEFAULT_CAPACITY); //constructor
Sequence(const Sequence& start); // COPY CONSTRUCTOR
~Sequence( ); // DESTRUCTOR
// MODIFICATION MEMBER FUNCTIONS
void resize(size_type new_capacity);
void start( );
void advance( );
void inser.
Ad
More Related Content
Similar to Exception to indicate that Singly LinkedList is empty. .pdf (20)
In C++Write a recursive function to determine whether or not a Lin.pdf
In C++Write a recursive function to determine whether or not a Lin.pdfflashfashioncasualwe In C++
Write a recursive function to determine whether or not a Linked List is in sorted order (smallest
value to largest value).
Add the following function prototypes to your List class under the section for access functions,
then implement the functions below the class definition:
public:
/**Access Functions*/
bool isSorted();
//Wrapper function that calls the isSorted helper function to determine whether
//a list is sorted in ascending order.
//We will consider that a list is trivially sorted if it is empty.
//Therefore, no precondition is needed for this function
private:
bool isSorted(Nodeptr node);
//Helper function for the public isSorted() function.
//Recursively determines whether a list is sorted in ascending order.
#include //for NULL
#include
#include
using namespace std;
template //list stores generic list data, not any specific C++ type
class List
{
private:
struct Node
{
listdata data;
Node* next;
Node* previous;
Node(listdata data): data(data), next(NULL), previous(NULL){}
};
typedef struct Node* Nodeptr;
Nodeptr first;
Nodeptr last;
Nodeptr iterator;
int size;
public:
/**Constructors and Destructors*/
List();
//Default constructor; initializes and empty list
//Postcondition: numeric values equated to zero, or strings should be empty.
List(const List &list);
~List();
//Destructor. Frees memory allocated to the list
//Postcondition: position NodePtr at next Node
/**Accessors*/
listdata getFirst();
//Returns the first element in the list
//Precondition:NodePtr points to the first node on list
listdata getLast();
//Returns the last element in the list
//Precondition: make new node first on the list
listdata getIterator();
bool isEmpty();
//Determines whether a list is empty.
int getSize();
//Returns the size of the list
/**Manipulation Procedures*/
void startIterator();
void advanceIterator();
void removeLast();
//Removes the value of the last element in the list
//Precondition: list is not empty, not the first element.
//Postcondition: one remaining node
void removeIterator();
void removeFirst();
//Removes the value of the first element in the list
//Precondition: list is not empty
//Postcondition: no nodes left
void insertLast(listdata data);
//Inserts a new element at the end of the list
//If the list is empty, the new element becomes both first and last
//Postcondition: next equal to null
void insertFirst(listdata data);
//Inserts a new element at the start of the list
//If the list is empty, the new element becomes both first and last
//Postcondition:point nodePtr next node on list
/**Additional List Operations*/
bool offEnd();
void printList();
//Prints to the console the value of each element in the list sequentially
//and separated by a blank space
//Prints nothing if the list is empty
void insertIterator(listdata data);
bool operator==(const List &list);
};
// constructor definition
template
List::List(): first(NULL), last(NULL), iterator(NULL), size(0) {}
template
List::List(const List &list): size(list.size)
{
if(list..
PROBLEM STATEMENTIn this assignment, you will complete DoubleEnde.pdf
PROBLEM STATEMENTIn this assignment, you will complete DoubleEnde.pdfclimatecontrolsv 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.
How do you stop infinite loop Because I believe that it is making a.pdf
How do you stop infinite loop Because I believe that it is making a.pdffeelinggift How do you stop infinite loop? Because I believe that it is making an infinite circular list.
c++ code:
Here is the list class:
#ifndef LIN_J_LIST
#define LIN_J_LIST
typedef unsigned int uint;
#include
#include
using namespace std;
/**
* a simplified generic singly linked list class to illustrate C++ concepts
* @author Jerry Lin
* @version 2/17/17
*/
template< typename Object >
class List
{
private:
/**
* A class to store data and provide a link to the next node in the list
*/
class Node
{
public:
/**
* The constructor
* @param data the data to be stored in this node
*/
explicit Node( const Object & data )
: data{ data }, next{ nullptr } {}
Object data;
Node * next;
};
public:
/**
* The constructor for an empty list
*/
List()
: size{ 0 }, first{ nullptr }, last{ nullptr } {}
/**
* the copy constructor-creates and copy the list
*/
List( List && rhs ) = delete;
List( const List & rhs )
{
count = 0;
size = 0;
if(rhs.size != 0)
{
push_front(rhs.front());
Node * current = rhs.first;
Node * tempNode = first;
size++;
while(current->next != nullptr)
{
current = current->next;
Node *newNode = new Node(current->data); //transfer the data. basic op.
count++;
tempNode->next = newNode;
last = newNode;
tempNode = tempNode->next;
size++;
}
}
// you document and implement this method
}
/**
* the operator= method-copies the list
*/
List & operator=( List && rhs) = delete;
List & operator=( const List & rhs )
{
count = 0;
size = 0;
if( size != 0 )
{
Node * current = first;
Node * temp;
while( current != nullptr )
{
temp = current;
current = current->next;
delete temp;
}
}
if(rhs.size!= 0)
{
push_front(rhs.front());
Node * current = rhs.first;
Node * tempNode = first; //create a temporary to store
size++;
while(current -> next != nullptr)
{
current = current->next;
Node *newNode = new Node(current->data); //transfer the data. basic op
count++;
tempNode->next = newNode;
last = newNode;
tempNode = tempNode -> next;
size++;
}
}
return *this;
// you document and implement this method
}
/**
* accessor
* @return count
*/
int get_count() const
{
return count;
}
/**
* The destructor that gets rid of everything that\'s in the list and
* resets it to empty. If the list is already empty, do nothing.
*/
~List()
{
if( size != 0 )
{
Node * current = first;
Node * temp;
while( current != nullptr )
{
temp = current;
current = current->next;
delete temp;
}
}
}
/**
* Put a new element onto the beginning of the list
* @param item the data the new element will contain
*/
void push_front( const Object& item )
{
Node * new_node = new Node( item );//basic op.
if(is_empty())
{
last = new_node;
}
else
{
new_node->next = first;
}
first = new_node;
size++;
/* you complete the rest */
}
/**
* Remove the element that\'s at the front of the list. Causes an
* assertion error if the list is empty.
*/
void pop_front()
{
assert( !is_empty() );
Node * temp = first;
if( first == last )
{
first = last = nullptr;
}
else
{
first = first->next;
}
delete temp;
size--;
}
/**
* Accessor to return the da.
How do I fix it in javaLinkedList.java Defines a doubl.pdf
How do I fix it in javaLinkedList.java Defines a doubl.pdffmac5 How do I fix it in java?
LinkedList.java:
/**
* Defines a doubly-linked list class
* @author
* @author
*/
import java.util.NoSuchElementException;
public class LinkedList {
private class Node {
private T data;
private Node next;
private Node prev;
public Node(T data) {
this.data = data;
this.next = null;
this.prev = null;
}
}
private int length;
private Node first;
private Node last;
private Node iterator;
/**** CONSTRUCTORS ****/
/**
* Instantiates a new LinkedList with default values
* @postcondition
*/
public LinkedList() {
first = null;
last = null;
iterator = null;
length = 0;
}
/**
* Converts the given array into a LinkedList
* @param array the array of values to insert into this LinkedList
* @postcondition
*/
public LinkedList(T[] array) {
}
/**
* Instantiates a new LinkedList by copying another List
* @param original the LinkedList to copy
* @postcondition a new List object, which is an identical,
* but separate, copy of the LinkedList original
*/
public LinkedList(LinkedList original) {
}
/**** ACCESSORS ****/
public T getFirst() throws NoSuchElementException {
if (isEmpty()){
throw new NoSuchElementException("The list is empty");
}
return first.data;
}
public T getLast() throws NoSuchElementException {
if (isEmpty()){
throw new NoSuchElementException("The list is empty");
}
return last.data;
}
/**
* Returns the data stored in the iterator node
* @precondition
* @return the data stored in the iterator node
* @throw NullPointerException
*/
public T getIterator() throws NullPointerException {
if (iterator != null){
return iterator.data;
}else{
throw new NullPointerException("Iterator is off the end opf the list.");
}
}
/**
* Returns the current length of the LinkedList
* @return the length of the LinkedList from 0 to n
*/
public int getLength() {
return length;
}
/**
* Returns whether the LinkedList is currently empty
* @return whether the LinkedList is empty
*/
public boolean isEmpty() {
return length == 0;
}
/**
* Returns whether the iterator is offEnd, i.e. null
* @return whether the iterator is null
*/
public boolean offEnd() {
return iterator == null;
}
/**** MUTATORS ****/
public void addFirst(T data) {
Node newNode = new Node(data);
if(isEmpty()){
first = newNode;
last = newNode;
}
else{
newNode.next = first;
first.prev = newNode;
first = newNode;
}
length++;
}
public void addLast(T data) {
Node newNode = new Node(data);
if(isEmpty()){
first = newNode;
last = newNode;
}
else{
last.next = newNode;
newNode.prev = last;
last = newNode;
}
length++;
}
/**
* Inserts a new element after the iterator
* @param data the data to insert
* @precondition
* @throws NullPointerException
*/
public void addIterator(T data) throws NullPointerException{
if(iterator != null){
Node newNode = new Node(data);
newNode.next = iterator.next;
iterator.next = newNode;
if (iterator == first){
first = newNode;
}
}else{
throw new NullPointerException("Iterator is off the end opf the list.");
}
}
/
public void removeFirst() throws NoSuchElementException {
if(is.
The LinkedList1 class implements a Linked list. class.pdf
The LinkedList1 class implements a Linked list. class.pdfmalavshah9013 /**
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.
How do I fix it in LinkedList.javaLinkedList.java Define.pdf
How do I fix it in LinkedList.javaLinkedList.java Define.pdfmail931892 How do I fix it in LinkedList.java?
LinkedList.java:
/**
* Defines a doubly-linked list class
* @author
* @author
*/
import java.util.NoSuchElementException;
public class LinkedList {
private class Node {
private T data;
private Node next;
private Node prev;
public Node(T data) {
this.data = data;
this.next = null;
this.prev = null;
}
}
private int length;
private Node first;
private Node last;
private Node iterator;
/**** CONSTRUCTORS ****/
/**
* Instantiates a new LinkedList with default values
* @postcondition
*/
public LinkedList() {
first = null;
last = null;
iterator = null;
length = 0;
}
/**
* Converts the given array into a LinkedList
* @param array the array of values to insert into this LinkedList
* @postcondition
*/
public LinkedList(T[] array) {
}
/**
* Instantiates a new LinkedList by copying another List
* @param original the LinkedList to copy
* @postcondition a new List object, which is an identical,
* but separate, copy of the LinkedList original
*/
public LinkedList(LinkedList original) {
}
/**** ACCESSORS ****/
public T getFirst() throws NoSuchElementException {
if (isEmpty()){
throw new NoSuchElementException("The list is empty");
}
return first.data;
}
public T getLast() throws NoSuchElementException {
if (isEmpty()){
throw new NoSuchElementException("The list is empty");
}
return last.data;
}
/**
* Returns the data stored in the iterator node
* @precondition
* @return the data stored in the iterator node
* @throw NullPointerException
*/
public T getIterator() throws NullPointerException {
if (iterator != null){
return iterator.data;
}else{
throw new NullPointerException("Iterator is off the end opf the list.");
}
}
/**
* Returns the current length of the LinkedList
* @return the length of the LinkedList from 0 to n
*/
public int getLength() {
return length;
}
/**
* Returns whether the LinkedList is currently empty
* @return whether the LinkedList is empty
*/
public boolean isEmpty() {
return length == 0;
}
/**
* Returns whether the iterator is offEnd, i.e. null
* @return whether the iterator is null
*/
public boolean offEnd() {
return iterator == null;
}
/**** MUTATORS ****/
public void addFirst(T data) {
Node newNode = new Node(data);
if(isEmpty()){
first = newNode;
last = newNode;
}
else{
newNode.next = first;
first.prev = newNode;
first = newNode;
}
length++;
}
public void addLast(T data) {
Node newNode = new Node(data);
if(isEmpty()){
first = newNode;
last = newNode;
}
else{
last.next = newNode;
newNode.prev = last;
last = newNode;
}
length++;
}
/**
* Inserts a new element after the iterator
* @param data the data to insert
* @precondition
* @throws NullPointerException
*/
public void addIterator(T data) throws NullPointerException{
if(iterator != null){
Node newNode = new Node(data);
newNode.next = iterator.next;
iterator.next = newNode;
if (iterator == first){
first = newNode;
}
}else{
throw new NullPointerException("Iterator is off the end opf the list.");
}
}
/
public void removeFirst() throws NoSuchElementExcept.
mainpublic class AssignmentThree { public static void ma.pdf
mainpublic class AssignmentThree { public static void ma.pdffathimafancyjeweller // main
public class AssignmentThree
{
public static void main(String[] args)
{
List myList = new List(15);
// Cause List Empty Message
myList.removeFront();
myList.removeRear();
myList.removeItem(\"a\");
// Cause Not found message
myList.addToFront(\"x\");
myList.removeItem(\"y\");
myList.removeItem(\"x\");
myList.addAfterItem(\"x\", \"z\");
myList.addBeforeItem(\"x\", \"z\");
// Normal behavior
myList.addToFront(\"not.\");
myList.addToFront(\"or\");
myList.addToRear(\"is\");
myList.addToRear(\"try.\");
myList.addAfterItem(\"is\", \"no\");
myList.addBeforeItem(\"is\", \"There\");
myList.addToFront(\"Do\");
myList.addAfterItem(\"or\", \"do\");
myList.print(\"Original list\");
myList.printSorted(\"Sorted Original List\");
sop(\"\ Front is \" + myList.getFront());
sop(\"Rear is \" + myList.getRear());
sop(\"Count is \" + myList.askCount());
sop(\"Is There present? \" + myList.isPresent(\"There\"));
sop(\"Is Dog present? \" + myList.isPresent(\"Dog\"));
myList.addToFront(\"junk\");
myList.addToRear(\"morejunk\");
myList.addAfterItem(\"or\", \"moremorejunk\");
myList.print(\"List with junk\");
sop(\"Count is \" + myList.askCount());
myList.removeFront();
myList.removeRear();
myList.removeItem(\"moremorejunk\");
myList.print(\"List with junk removed\");
sop(\"Count is \" + myList.askCount());
sop(\"\");
// Cause List Full message
for(int ii = 0; ii < 10; ++ii)
{
myList.addToFront(DUMMY);
}
myList.addToRear(DUMMY);
myList.addBeforeItem(\"no\", DUMMY);
myList.addAfterItem(\"There\", DUMMY);
myList.print(\"After filling List\");
sop(\"Count is \" + myList.askCount());
while(myList.isPresent(DUMMY)) myList.removeItem(DUMMY);
myList.print(\"After removing \" + DUMMY );
sop(\"Count is \" + myList.askCount());
}
private static void sop(String s)
{
System.out.println(s);
}
private static final String DUMMY = \"dummy\";
}
Solution
Following is MyList implementation for your output as:
Java Code:
import java.util.Comparator;
public class MyList {
private Node start;
private Node end;
private int size;
private int capacity;
public MyList(int capacity) {
start = null;
end = null;
size = 0;
this.capacity = capacity;
}
/* Function to check if list is empty */
public boolean isEmpty() {
return start == null;
}
public void removeFront() {
if (isEmpty()) {
System.out.println(\"List Empty\");
return;
} else {
start = start.next;
size--;
return;
}
}
public void removeRear() {
if (size == 0) {
System.out.println(\"List Empty\");
return;
}
if (start.next == null) {
start=null;
end=null;
size=0;
}
Node node = start.next;
while (node.next != null) {
node = node.next;
}
node.next = null;
end = node;
size--;
}
public void removeItem(String key) {
if (size == 0) {
System.out.println(\"List Empty\");
return;
}
if (start.next == null) {
if (start.key.equals(key)) {
start=null;
end=null;
size=0;
} else {
System.out.println(\"\");
}
return;
}
Node node = start;
Node nodeNext = node.next;
while (nodeNext.next != null) {
if (nodeNext.key.equals(key)) {
node.next=nodeNext.next;
}.
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 .
Csphtp1 23
Csphtp1 23HUST This document outlines key concepts related to data structures including linked lists, stacks, queues, and trees. It provides code examples of a Node class that is self-referential, allowing objects to link to one another. A LinkedListLibrary class is defined, with methods for inserting and removing nodes from linked lists. A ListTest class tests the functionality of the List class.
Csphtp1 23
Csphtp1 23HUST The document outlines key concepts about data structures including linked lists, stacks, queues, and trees. It provides code examples for a Node class that is self-referential, allowing objects to link to each other. It also includes a List class that implements basic linked list functionality through methods like InsertAtFront, InsertAtBack, RemoveFromFront, and RemoveFromBack. The code examples demonstrate how to create and manipulate linked lists through a List object.
Implement a queue using a linkedlist (java)SolutionLinkedQueue.pdf
Implement a queue using a linkedlist (java)SolutionLinkedQueue.pdfkostikjaylonshaewe47 Implement a queue using a linkedlist (java)
Solution
LinkedQueueImplement.java
import java.util.*;
class Node
{
protected int data;
protected Node link;
public Node()
{
link = null;
data = 0;
}
public Node(int d,Node n)
{
data = d;
link = n;
}
public void setLink(Node n)
{
link = n;
}
public void setData(int d)
{
data = d;
}
public Node getLink()
{
return link;
}
public int getData()
{
return data;
}
}
class linkedQueue
{
protected Node front, rear;
public int size;
public linkedQueue()
{
front = null;
rear = null;
size = 0;
}
public boolean isEmpty()
{
return front == null;
}
public int getSize()
{
return size;
}
/* Function to insert an element to the queue */
public void insert(int data)
{
Node nptr = new Node(data, null);
if (rear == null)
{
front = nptr;
rear = nptr;
}
else
{
rear.setLink(nptr);
rear = rear.getLink();
}
size++ ;
}
/* Function to remove front element from the queue */
public int remove()
{
if (isEmpty() )
throw new NoSuchElementException(\"Underflow Exception\");
Node ptr = front;
front = ptr.getLink();
if (front == null)
rear = null;
size-- ;
return ptr.getData();
}
/* Function to check the front element of the queue */
public int peek()
{
if (isEmpty() )
throw new NoSuchElementException(\"Underflow Exception\");
return front.getData();
}
/* Function to display the status of the queue */
public void display()
{
System.out.print(\"\ Queue = \");
if (size == 0)
{
System.out.print(\"Empty\ \");
return ;
}
Node ptr = front;
while (ptr != rear.getLink() )
{
System.out.print(ptr.getData()+\" \");
ptr = ptr.getLink();
}
System.out.println();
}
}
/* Class LinkedQueueImplement */
public class LinkedQueueImplement
{
public static void main(String[] args)
{
Scanner scan = new Scanner(System.in);
/* Creating object of class linkedQueue */
linkedQueue lq = new linkedQueue();
/* Perform Queue Operations */
System.out.println(\"Linked Queue Test\ \");
char ch;
do
{
System.out.println(\"\ Queue Operations\");
System.out.println(\"1. insert\");
System.out.println(\"2. remove\");
System.out.println(\"3. peek\");
System.out.println(\"4. check empty\");
System.out.println(\"5. size\");
int choice = scan.nextInt();
switch (choice)
{
case 1 :
System.out.println(\"Enter integer element to insert\");
lq.insert( scan.nextInt() );
break;
case 2 :
try
{
System.out.println(\"Removed Element = \"+ lq.remove());
}
catch (Exception e)
{
System.out.println(\"Error : \" + e.getMessage());
}
break;
case 3 :
try
{
System.out.println(\"Peek Element = \"+ lq.peek());
}
catch (Exception e)
{
System.out.println(\"Error : \" + e.getMessage());
}
break;
case 4 :
System.out.println(\"Empty status = \"+ lq.isEmpty());
break;
case 5 :
System.out.println(\"Size = \"+ lq.getSize());
break;
default :
System.out.println(\"Wrong Entry \ \");
break;
}
/* display queue */
lq.display();
System.out.println(\"\ Do you want to continue (Type y or n) \ \");
ch = scan.next().charAt(0);
} while (ch == \'Y\'|| ch == \'y\');
}
}
Output :
Linked Queue Test
Queue Operations
1. inse.
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.
Jhtp5 20 Datastructures
Jhtp5 20 Datastructuresmartha leon The document outlines different data structures including linked lists, stacks, and queues. It describes how linked lists use self-referential nodes connected by links and can dynamically grow and shrink. Stacks are described as a constrained version of linked lists that only allow adding and removing from one end, with the push and pop methods.
Write the following using javaGiven a class ‘Node’ and ‘NodeList’,.pdf
Write the following using javaGiven a class ‘Node’ and ‘NodeList’,.pdffathimalinks 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..
How do I fix it in LinkedList.javathis is what i didLabProgra.pdf
How do I fix it in LinkedList.javathis is what i didLabProgra.pdfmail931892 The document provides instructions for implementing iterator methods in a LinkedList class. It describes updating the default constructor to initialize the iterator field to null, and modifying removeFirst() and removeLast() methods to handle cases where the iterator is at the first or last node. It then lists 8 steps to implement iterator methods like positionIterator(), offEnd(), getIterator(), advanceIterator(), reverseIterator(), addIterator(), and removeIterator(). The main() method creates a linked list and calls the iterator methods to test their functionality.
Labprogram.javaLinkedList.javaimport java.util.NoSuchElementEx.pdf
Labprogram.javaLinkedList.javaimport java.util.NoSuchElementEx.pdffreddysarabia1 Labprogram.java
LinkedList.java
import java.util.NoSuchElementException;
public class LinkedList {
private class Node {
private T data;
private Node next;
private Node prev;
public Node(T data) {
this.data = data;
this.next = null;
this.prev = null;
}
}
private int length;
private Node first;
private Node last;
private Node iterator;
/**** CONSTRUCTORS ****/
public LinkedList() {
first = null;
last = null;
iterator = null;
length = 0;
}
/**
* Converts the given array into a LinkedList
*
* @param array the array of values to insert into this LinkedList
* @postcondition
*/
public LinkedList(T[] array) {
}
/**
* Instantiates a new LinkedList by copying another List
*
* @param original the LinkedList to copy
* @postcondition a new List object, which is an identical,
* but separate, copy of the LinkedList original
*/
public LinkedList(LinkedList original) {
}
public T getFirst() throws NoSuchElementException {
if (isEmpty()) {
throw new NoSuchElementException("The list is empty");
}
return first.data;
}
public T getLast() throws NoSuchElementException {
if (isEmpty()) {
throw new NoSuchElementException("The list is empty");
}
return last.data;
}
public T getIterator() throws NullPointerException {
if (iterator != null) {
return iterator.data;
} else {
throw new NullPointerException("Iterator is off the end opf the list.");
}
}
public int getLength() {
return length;
}
public boolean isEmpty() {
return length == 0;
}
public boolean offEnd() {
return iterator == null;
}
public void addFirst(T data) {
Node newNode = new Node(data);
if (isEmpty()) {
first = newNode;
last = newNode;
} else {
newNode.next = first;
first.prev = newNode;
first = newNode;
}
length++;
}
public void addLast(T data) {
Node newNode = new Node(data);
if (isEmpty()) {
first = newNode;
last = newNode;
} else {
last.next = newNode;
newNode.prev = last;
last = newNode;
}
length++;
}
public void addIterator(T data) throws NullPointerException {
if (offEnd()) {
throw new NullPointerException("addIterator Iterator is off end.");
}
if (iterator == last) {
addLast(data);
} else {
Node newNode = new Node(data);
Node next = iterator.next;
newNode.next = next;
newNode.prev = iterator;
iterator.next = newNode;
next.prev = newNode;
length++;
}
}
public void removeFirst() throws NoSuchElementException {
if (isEmpty()) {
throw new NoSuchElementException("The list is empty");
}
if (length == 1) {
first = null;
last = null;
iterator = null;
} else {
if (iterator == first) {
iterator = null;
}
first = first.next;
first.prev = null;
}
length--;
}
public void removeLast() throws NoSuchElementException {
if (isEmpty()) {
throw new NoSuchElementException("The list is empty");
}
if (length == 1) {
first = null;
last = null;
iterator = null;
} else {
if (iterator == last) {
iterator = null;
}
last = last.prev;
last.next = null;
}
length--;
}
public void removeIterator() throws NullPointerException {
if (offEnd()) {
throw new NullPointerException("Iterator is off the end opf the list.");
}
if (iterator .
StackInterface An interface for the ADT stack. Do not modif.pdf
StackInterface An interface for the ADT stack. Do not modif.pdfARCHANASTOREKOTA StackInterface
/**
An interface for the ADT stack.
Do not modify this file
*/
package PJ2;
public interface StackInterface
{
/** Gets the current number of data in this stack.
@return the integer number of entries currently in the stack*/
public int size();
/** Adds a new data to the top of this stack.
@param aData an object to be added to the stack */
public void push(T aData);
/** Removes and returns this stack\'s top data.
@return either the object at the top of the stack or,
if the stack is empty before the operation, null */
public T pop();
/** Retrieves this stack\'s top data.
@return either the data at the top of the stack or
null if the stack is empty */
public T peek();
/** Detects whether this stack is empty.
@return true if the stack is empty */
public boolean empty();
/** Removes all data from this stack */
public void clear();
} // end StackInterface
SimpleLinkedStack.java
/**
A class of stacks whose entries are stored in a chain of nodes.
Implement all methods in SimpleLinkedStack class using
the inner Node class.
Main Reference : text book or class notes
Do not change or add data fields
Do not add new methods
You may access Node object fields directly, i.e. data and next
*/
package PJ2;
public class SimpleLinkedStack implements StackInterface
{
// Data fields
private Node topNode; // references the first node in the chain
private int count; // number of data in this stack
public SimpleLinkedStack()
{
// add stataments
} // end default constructor
public void push(T newData)
{
// add stataments
} // end push
public T peek()
{
// add stataments
return null;
} // end peek
public T pop()
{
// add stataments
return null;
} // end pop
public boolean empty()
{
// add stataments
return false;
} // end empty
public int size()
{
// add stataments
return -1;
} // end isEmpty
public void clear()
{
// add stataments
} // end clear
public String toString()
{
// add stataments
// note: data class in stack must implement toString() method
// return a list of data in Stack, separate them with \',\'
return \"\";
}
/****************************************************
private inner node class
Do not modify this class!!
you may access data and next directly
***************************************************/
private class Node
{
private T data; // entry in list
private Node next; // link to next node
private Node (T dataPortion)
{
data = dataPortion;
next = null; // set next to NULL
} // end constructor
private Node (T dataPortion, Node nextNode)
{
data = dataPortion;
next = nextNode; // set next to refer to nextNode
} // end constructor
} // end Node
/****************************************************
Do not modify: Stack test
****************************************************/
public static void main (String args[])
{
System.out.println(\"\ \"+
\"*******************************************************\ \"+
\"Sample Expected output:\ \"+
\"\ \"+
\"OK: stack is empty\ \"+
\"Push 3 data: 10, 30, 50\ \"+
\"Print stack [50,30,10,]\ \"+
\"OK: sta.
THE CODE HAS A SEGMENTATION FAULT BUT I CANNOT FIND OUT WHERE. NEED .pdf
THE CODE HAS A SEGMENTATION FAULT BUT I CANNOT FIND OUT WHERE. NEED .pdffathimahardwareelect THE CODE HAS A SEGMENTATION FAULT BUT I CANNOT FIND OUT WHERE. NEED
HELP FIXING THIS CODE?
THIS IS THE PROBLEM
Write a program that allows the user to enter two positive integers and outputs their sum. Sounds
simple? Here\'s the catch: The numbers may be any size! They may be way too large to store in a
single variable. You may not assume any particular maximum number of digits.
HERE IS THE CODE
#include
#include
struct node /* Linked list node*/
{
int data;
struct node* next;
};
struct node *newNode(int data) /* Function to create a new node with giving the data*/
{
struct node *new_node = (struct node *) malloc(sizeof(struct node));
new_node->data = data;
new_node->next = NULL;
return new_node;
}
void push(struct node** head_ref, int new_data) /* Function to insert a node at the beginning of
the Doubly Linked List*/
{
struct node* new_node = newNode(new_data); /*allocate a node*/
new_node->next = (*head_ref); /* link the old list off to the new node*/
(*head_ref) = new_node; /*move the head to point to the new node*/
}
/* Adding the contents of two linked lists and return the head node of resultant list*/
struct node* addTwoLists (struct node* first, struct node* second)
{
struct node* res = NULL; /* res is head node of the resultant list*/
struct node *temp, *prev = NULL;
int carry = 0, sum;
while (first != NULL || second != NULL) /*while both the lists exists*/
{
/* Calculate value of next digit in resultant list.
// The next digit is sum of following things
// (i) Carry
// (ii) Next digit of first list (if there is a next digit)
// (ii) Next digit of second list (if there is a next digit)*/
sum = carry + (first? first->data: 0) + (second? second->data: 0);
carry = (sum >= 10)? 1 : 0; /* update carry for next calulation*/
sum = sum % 10; /*update sum if it is greater than 10*/
temp = newNode(sum); /*Create a new node with sum as data*/
if(res == NULL) /*if this is the first node then set it as head of the resultant list*/
res = temp;
else /* If this is not the first node then connect it to the rest.*/
prev->next = temp;
prev = temp; /* Set prev for next insertion*/
if (first) first = first->next; /* Move first pointers to next node*/
if (second) second = second->next; /*Move second pointer to the next node*/
}
if (carry > 0)
temp->next = newNode(carry);
return res; /* return head of the resultant list*/
}
void printList(struct node *node) /* function to print a linked list*/
{
while(node != NULL)
{
printf(\"%d \", node->data);
node = node->next;
}
printf(\"\ \");
}
int main(void) /* program to test above function*/
{
struct node* res = NULL;
struct node* first = NULL;
struct node* second = NULL;
printf(\"Enter first positive integer: \");
scanf(\"%d\",&first);
printList(first);
printf(\"Enter second positive integer: \");
scanf(\"%d\",&second);
printList(second);
/*Add the two lists and see result*/
res = addTwoLists(first, second);
printf(\"Sum is: %d\");
printList(res);
return 0;
}
Solution
#include
#include
typedef struct Node
{
int da.
Data Structures and Agorithm: DS 04 Linked List.pptx
Data Structures and Agorithm: DS 04 Linked List.pptxRashidFaridChishti Data Structures and Agorithm: DS 04 Linked List.pptx
More from aravlitraders2012 (20)
Electronegativity - Electronegativity is an atom.pdf
Electronegativity - Electronegativity is an atom.pdfaravlitraders2012 Electronegativity - Electronegativity is an atom\'s \'desire\' to grab another atom\'s
electrons. In terms of ionization energy \"noble gas status\" is the golden standard. Elements in
group one only need to give up one electron to reach that status. For this reason they are highly
reactive and want go give up an electron to some other atom. Group 1 elements are the most
reactive followed by group 2. In order of increasing reactivity: Calcium, Magnesium, Sodium,
Potassium
Solution
Electronegativity - Electronegativity is an atom\'s \'desire\' to grab another atom\'s
electrons. In terms of ionization energy \"noble gas status\" is the golden standard. Elements in
group one only need to give up one electron to reach that status. For this reason they are highly
reactive and want go give up an electron to some other atom. Group 1 elements are the most
reactive followed by group 2. In order of increasing reactivity: Calcium, Magnesium, Sodium,
Potassium.
Sequence.h#ifndef MAIN #define MAIN #include cstdlibclass .pdf
Sequence.h#ifndef MAIN #define MAIN #include cstdlibclass .pdfaravlitraders2012 Sequence.h
#ifndef MAIN
#define MAIN
#include
class Sequence
{
public:
//TYPEDEFS and MEMBER CONSTANTS
typedef double value;
typedef std::size_t size_type;
static const size_type DEFAULT_CAPACITY = 30;
// CONSTRUCTORS and DESTRUCTOR
Sequence(size_type initial_capacity = DEFAULT_CAPACITY); //constructor
Sequence(const Sequence& start); // COPY CONSTRUCTOR
~Sequence( ); // DESTRUCTOR
// MODIFICATION MEMBER FUNCTIONS
void resize(size_type new_capacity);
void start( );
void advance( );
void insert(const value& entry);
void attach(const value& entry);
void remove_current( );
void operator =(const Sequence& start);
// CONSTANT MEMBER FUNCTIONS
size_type size( ) const;
bool is_item( ) const;
value current( ) const;
bool operator ==(const Sequence& other);
bool operator !=(const Sequence& other);
private:
void shift_down(size_type index);
void shift_up(size_type index);
value* data;
size_type used;
size_type current_index;
size_type capacity;
};
#endif
Sequence.cpp
#include
#include
#include \"Sequence.h\"
using namespace std;
Sequence::Sequence(size_type initial_capacity)
{
data= new value [initial_capacity];
current_index=0;
capacity=initial_capacity;
used=0;
}
Sequence::Sequence(const Sequence& start)
{
data=new value[start.capacity];
capacity=start.capacity;
current_index=start.current_index;
used=start.used;
copy(start.data,start.data+used,data);
}
Sequence::~Sequence( )
{
delete [] data;//it releases dynamic memory afterwards.
}
void Sequence::resize(size_type new_capacity)
{
assert(new_capacity > size ()); // capacity is less than the number of items
data=new double [size()];
delete [] data;
double *tempdata;// temporary array
tempdata=new double[size()];
for (unsigned int i=0; icurrent_index;i--)
data[i]=data[i-1];
data[current_index]=entry;
used++;
}
void Sequence::shift_down(size_type index)
{
}
void Sequence::attach(const value& entry)
{
if(used == capacity)
resize(used+1);
if(current_index >= used)
{
start();
advance();
advance();
}
if(used!=0)
{
for(size_type i = used; i > current_index+1; i--)
{
data[i] = data[i-1];
}
data[current_index+1] = entry;
current_index++;
}
data[current_index] = entry;
++used;
}
void Sequence::shift_up(size_type index)
{
}
void Sequence::remove_current( )
{
assert(is_item()==true);
for (unsigned int i=0; i
#include \"Sequence.h\"
using namespace std;
int main ( )
{
Sequence s;
s.insert(1);
s.insert(2);
s.insert(3);
s.insert(4);
s.insert(5);
s.start( );
cout << s.current( ) << endl;
system (\"pause\");
return 0;
}
Solution
Sequence.h
#ifndef MAIN
#define MAIN
#include
class Sequence
{
public:
//TYPEDEFS and MEMBER CONSTANTS
typedef double value;
typedef std::size_t size_type;
static const size_type DEFAULT_CAPACITY = 30;
// CONSTRUCTORS and DESTRUCTOR
Sequence(size_type initial_capacity = DEFAULT_CAPACITY); //constructor
Sequence(const Sequence& start); // COPY CONSTRUCTOR
~Sequence( ); // DESTRUCTOR
// MODIFICATION MEMBER FUNCTIONS
void resize(size_type new_capacity);
void start( );
void advance( );
void inser.
In the 1st Question, As the polymorphisms occur in the non-coding se.pdf
In the 1st Question, As the polymorphisms occur in the non-coding se.pdfaravlitraders2012 In the 1st Question, As the polymorphisms occur in the non-coding sequence, thus, they does
not contribute to phenotypic variations. As the polymorphisms are also neutral, thus, they are
selectively neutral because during the course of evolution, the non-coding sequences are
conserved and any polymorphisms in them become selectively neutral as they do not
contribution to phenotypic variations. Hence, the answer is b. In the 2nd Question, according to
the given data, at all loci the same polymorphism was found in nearly all of the tested species
from lake victoria both lacustrine and riverine but different polymorphims at these loci were
found in cichlids at other african lakes. This suggests that all african lakes cichlids are related by
recent ancestry because the genetic loci where these polymorphism occur remains same and also
that lake victoria was repopulated by a relatively small sample of cichlids because lake victoria
cichlids have the same polymorphism at all the loci in the tested species. Hence, the answer is a
and d (both apply).
Solution
In the 1st Question, As the polymorphisms occur in the non-coding sequence, thus, they does
not contribute to phenotypic variations. As the polymorphisms are also neutral, thus, they are
selectively neutral because during the course of evolution, the non-coding sequences are
conserved and any polymorphisms in them become selectively neutral as they do not
contribution to phenotypic variations. Hence, the answer is b. In the 2nd Question, according to
the given data, at all loci the same polymorphism was found in nearly all of the tested species
from lake victoria both lacustrine and riverine but different polymorphims at these loci were
found in cichlids at other african lakes. This suggests that all african lakes cichlids are related by
recent ancestry because the genetic loci where these polymorphism occur remains same and also
that lake victoria was repopulated by a relatively small sample of cichlids because lake victoria
cichlids have the same polymorphism at all the loci in the tested species. Hence, the answer is a
and d (both apply)..
I noticed that temperature is not mentioned. A) .pdf
I noticed that temperature is not mentioned. A) .pdfaravlitraders2012 I noticed that temperature is not mentioned. A) Entropy of fusion = heat of fusion /
melting temperature = (10.59kJ/mol) / melting temperature B) Sicne, fusion is a reversible
process, delS (surroundings) + delS (system) = 0 so delS (surroundings) = -delS (system) = -
(10.59kJ/mol) / melting temperature
Solution
I noticed that temperature is not mentioned. A) Entropy of fusion = heat of fusion /
melting temperature = (10.59kJ/mol) / melting temperature B) Sicne, fusion is a reversible
process, delS (surroundings) + delS (system) = 0 so delS (surroundings) = -delS (system) = -
(10.59kJ/mol) / melting temperature.
1. Briefly describe the structured design approach and the object-or.pdf
1. Briefly describe the structured design approach and the object-or.pdfaravlitraders2012 1. Briefly describe the structured design approach and the object-oriented design.
structured desing:
1)here it will divide the problem into small subparts or subproblems
2)it is also known as top-down approach
3)it will do step by step refinement and do basic programming
4)here the problems are divided in to smaller pieces and find the solution for each problem and
combine
them together to solve entire problem
object oriented programming:
1)here each component is detrmined as an object
2)the main task is to fiding objects and doing required operations on them
3)each objects which change it state while doing operations
4)by combining and communicating with all required objects get an overall solution to the
problem
2. How are these approaches similar? How do they differ?
sol:
one of the similar thing is both will divide problem in to small thing whiel structured desing will
divided into sub problems and oop is divided in to objects
1)sturtured programming will save time instead of writing complex function in oop
2)as they are small program they are very easy to maintain by oop are not
3)structured programming are easy to understand
3. Which approach do you feel is most beneficial? Why?
sol:i feel obejct oriented desing is more comfartable and benificial than structed desing ,because
in object oriented desing every real world problem in to model of objects and by doing it will
become easier to solve the problem in natural way
Solution
1. Briefly describe the structured design approach and the object-oriented design.
structured desing:
1)here it will divide the problem into small subparts or subproblems
2)it is also known as top-down approach
3)it will do step by step refinement and do basic programming
4)here the problems are divided in to smaller pieces and find the solution for each problem and
combine
them together to solve entire problem
object oriented programming:
1)here each component is detrmined as an object
2)the main task is to fiding objects and doing required operations on them
3)each objects which change it state while doing operations
4)by combining and communicating with all required objects get an overall solution to the
problem
2. How are these approaches similar? How do they differ?
sol:
one of the similar thing is both will divide problem in to small thing whiel structured desing will
divided into sub problems and oop is divided in to objects
1)sturtured programming will save time instead of writing complex function in oop
2)as they are small program they are very easy to maintain by oop are not
3)structured programming are easy to understand
3. Which approach do you feel is most beneficial? Why?
sol:i feel obejct oriented desing is more comfartable and benificial than structed desing ,because
in object oriented desing every real world problem in to model of objects and by doing it will
become easier to solve the problem in natural way.
1) Protocols are needed so your computer can interact with other com.pdf
1) Protocols are needed so your computer can interact with other com.pdfaravlitraders2012 1) Protocols are needed so your computer can interact with other computers for things such as
using the internet and sending and receiving files and emails. Protocols are the \"language\"
computers use to talk to each other. Standards are important so all networks have to follow the
same rules. Standards are a set of guidelines on how different companies need to make their
equipment.
2) a protocol is the special set of rules that end points in a telecommunication connection use
when they communicate. Protocols specify interactions between the communicating entities.
Protocols exist at several levels in a telecommunication connection. For example, there are
protocols for the data interchange at the hardware device level and protocols for data interchange
at the application program level. In the standard model known as Open Systems Interconnection
(OSI), there are one or more protocols at each layer in the telecommunication exchange that both
ends of the exchange must recognize and observe.
Transmission Control Protocol (TCP), which uses a set of rules to exchange messages with other
Internet points at the information packet level
Internet Protocol (IP), which uses a set of rules to send and receive messages at the Internet
address level
Others are Hypertext Transfer Protocol (HTTP) and File Transfer Protocol (FTP), each with
defined sets of rules to use with corresponding programs elsewhere on the Internet
3)
Standards play an important role in networking. Without standards, manufacturers of networking
products have no common ground on which to build their systems. Interconnecting products
from various vendors would be difficult, if not impossible.
Standardization can make or break networking products. These days many vendors are hesitant
to support new technology unless there is a standardization base from which to work. Vendors
want to know there will be some measure of interoperability for their hardware and software.
Examples :
IEEE 802.1 (LAN/MAN)
IEEE 802.3 (Ethernet)
IEEE 802.5 (Token Ring)
IEEE 802.11 (Wireless LAN)
4)
IEEE 802 group of standards
https://en.m.wikipedia.org/wiki/IEEE_802
5)
File transfer protocol ( ftp)
https://en.m.wikipedia.org/wiki/File_Transfer_Protocol
Solution
1) Protocols are needed so your computer can interact with other computers for things such as
using the internet and sending and receiving files and emails. Protocols are the \"language\"
computers use to talk to each other. Standards are important so all networks have to follow the
same rules. Standards are a set of guidelines on how different companies need to make their
equipment.
2) a protocol is the special set of rules that end points in a telecommunication connection use
when they communicate. Protocols specify interactions between the communicating entities.
Protocols exist at several levels in a telecommunication connection. For example, there are
protocols for the data interchange at the hardware device level and protocols for data interchange
at t.
argon is inert gas , doesnot chemically reacts wi.pdf
argon is inert gas , doesnot chemically reacts wi.pdfaravlitraders2012 argon is inert gas , doesnot chemically reacts with air . for gases vol% is = to their
mol% vol% of Ar= mol% of Ar= ((no 0f mol of Ar)/(no of mol of Ar+no of mol of air))
Solution
argon is inert gas , doesnot chemically reacts with air . for gases vol% is = to their
mol% vol% of Ar= mol% of Ar= ((no 0f mol of Ar)/(no of mol of Ar+no of mol of air)).
#include sstream #include linkylist.h #include iostream.pdf
#include sstream #include linkylist.h #include iostream.pdfaravlitraders2012 #include
#include \"linkylist.h\"
#include
#include
#include
#include
using namespace std;
int main(int argc, char *argv[])
{
//node* head = new node;
LinkedList list(1);
ifstream infile1 (argv[1]);
//make sure the file opens properly and read the contents of the file in to a list
if(!infile1)
{
cout<<\"Your Testfile could not be opened!\"<>users;
if (users.find(\"I\")!=string::npos)
{
//int spot = atoi((users[3]).c_str());
string pot = string(users.substr(2));
stringstream spot(pot);
string data;
cin>>data;
insertAfter(list.getNode(spot),data);
}
/*else if (users.find(\"D\")!=string::npos)
{
int spoty = atoi((users[3]).c_str());
deleteNode(spoty);
}*/
else if (users==\"L\")
{
list.traverse_and_print();
}
}
return 0;
#include
using namespace std;
class Node
{
friend class LinkedList;
private:
int value; /* data, can be any data type, but use integer for easiness */
Node *Next; /* pointer to the next node */
public:
/* Constructors with No Arguments */
Node(void)
: Next(NULL)
{ }
/* Constructors with a given value */
Node(int val)
: value(val), Next(NULL)
{ }
/* Constructors with a given value and a link of the next node */
Node(int val, Node* next)
: value(val), Next(next)
{}
/* Getters */
int getValue(void)
{ return value; }
Node* getNext(void)
{ return Next; }
};
/* definition of the linked list class */
class LinkedList
{
private:
/* pointer of head node */
Node *Head;
/* pointer of tail node */
Node *Tail;
public:
/* Constructors with a given value of a list node */
LinkedList(int val);
/* Destructor */
~LinkedList(void);
/* Function to append a node to the end of a linked list */
void tailAppend(string val);
/* Remove a node with a specific value if it exists */
void remove(int val);
void insertAfter(Node* afterMe, string val);
Node* getNode(int pos);
/* Traversing the list and printing the value of each node */
void traverse_and_print();
};
#include
#include \"linkylist.h\"
#include
using namespace std;
LinkedList::LinkedList(int val)
{
/* Create a new node, acting as both the head and tail node */
Head = new Node(val);
Tail = Head;
}
Node* LinkedList::getNode(int pos)
{
Node* p = Head;
/* Counter */
while (pos--) {
if (p != NULL)
p = p->Next;
else
return NULL;
}
return p;
}
void LinkedList::insertAfter(Node* afterMe, string val)
{
if(afterme != NULL)
{
afterMe->Next = new Node(val, afterMe->Next);
}
}
LinkedList::~LinkedList()
{
}
void LinkedList::tailAppend(string val)
{
/* The list is empty? */
if (Head == NULL) {
/* the same to create a new list with a given value */
Tail = Head = new Node(val);
}
else
{
/* Append the new node to the tail */
Tail->Next = new Node(val);
/* Update the tail pointer */
Tail = Tail->Next;
}
}
void LinkedList::remove(int val)
{
Node *pPre = NULL, *pDel = NULL;
/* Check whether it is the head node?
if it is, delete and update the head node */
if (Head->value == val) {
/* point to the node to be deleted */
pDel = Head;
/* update */
Head = pDel->Next;
delete pDel;
return;
}
pPre = Head;
pDel = Head->Next;
/*.
Function header If a program contain a function definition, that .pdf
Function header If a program contain a function definition, that .pdfaravlitraders2012 Function header :
If a program contain a function definition, that function defnition consist of a
Function header write by taking pointers or in the absense of pointers.
Example :
A function header look like that includes pointers.
void (*current_menu1)(int)
// here current_menu1 is a pointer
void (*payment_details)(int);
// here payment_details is a pointer
void (*payments_receipts)(double );
/ /payments_receipts is a pointer
Solution
Function header :
If a program contain a function definition, that function defnition consist of a
Function header write by taking pointers or in the absense of pointers.
Example :
A function header look like that includes pointers.
void (*current_menu1)(int)
// here current_menu1 is a pointer
void (*payment_details)(int);
// here payment_details is a pointer
void (*payments_receipts)(double );
/ /payments_receipts is a pointer.
GameOfLife.cs using System; using System.Collections.Generic;.pdf
GameOfLife.cs using System; using System.Collections.Generic;.pdfaravlitraders2012 GameOfLife.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
namespace A03LeeJoe
{
class GameOfLife
{
private int[, ,] grid;
private int displayedGrid = 0;
private int tempGrid = 1;
private const int DEAD = 0;
private const int ALIVE = 1;
private const int TOP = 5;
private const int LEFT = 20;
//constructor
public GameOfLife()
{
grid = CreateGrid();
}
//methods
private int[, ,] CreateGrid()
{
int[, ,] newGrid = new int[25, 40, 2];
for (int col = 14; col < 27; col++)
{
newGrid[13, col, 0] = ALIVE;
}
for (int row = 8; row < 11; row++)
{
newGrid[row, 12, 0] = ALIVE;
newGrid[row, 20, 0] = ALIVE;
newGrid[row, 28, 0] = ALIVE;
}
return newGrid;
}
public void Start()
{
//Display Grid
Console.SetWindowSize(80, 40);
Setup();
//loop until user presses a key
while (!Console.KeyAvailable)
{
Thread.Sleep(1000);
//perform next move
NextMove();
DisplayGrid();
SetColor(1);
Console.WriteLine();
Console.CursorLeft = LEFT;
Console.WriteLine(\" Press any key to end \", displayedGrid);
}
}
private void Setup()
{
CreateHeader();
DisplayGrid();
//prompt user to press enter
Console.WriteLine();
Console.CursorLeft = LEFT;
SetColor(1);
Console.WriteLine(\" Please press enter to begin \");
Console.ReadLine();
}
private void CreateHeader()
{
Console.SetCursorPosition(LEFT, TOP);
SetColor(1);
Console.WriteLine(\"{0,40}\", \" \");
Console.CursorLeft = LEFT;
Console.WriteLine(\" G A M E O F L I F E \");
Console.CursorLeft = LEFT;
Console.WriteLine(\"{0,40}\", \" \");
}
private void NextMove()
{
//iterate through grid
for (int row = 0; row <= grid.GetUpperBound(0); row++)
{
for (int col = 0; col <= grid.GetUpperBound(1); col++)
{
//each iteration check neighbor count
int neighborCount = GetNeighborCount(row, col);
//determine new life or death and update on temp grid\'
grid[row, col, tempGrid] = UpdateCell(grid[row, col, displayedGrid],
neighborCount);
}
}
//switch the grid\'s 3rd dimension to display new grid
SwitchGrid();
}
private void SwitchGrid()
{
if (displayedGrid == 0)
{
displayedGrid = 1;
tempGrid = 0;
}
else
{
displayedGrid = 0;
tempGrid = 1;
}
}
private int UpdateCell(int stateOfCell, int neighborCount)
{
if (stateOfCell == ALIVE)
{
switch (neighborCount)
{
case 0:
case 1:
return DEAD;
case 2:
case 3:
return ALIVE;
default:
return DEAD;
}
}
else if (neighborCount == 3)
{
return ALIVE;
}
return stateOfCell;
}
private void DisplayGrid()
{
Console.SetCursorPosition(LEFT, TOP + 4);
for (int row = 0; row <= grid.GetUpperBound(0); row++)
{
Console.CursorLeft = LEFT;
for (int col = 0; col <= grid.GetUpperBound(1); col++)
{
SetColor(grid[row, col, displayedGrid]);
Console.Write(\".\");
}
Console.WriteLine();
}
}
private void SetColor(int state)
{
if (state == 1)
{
Console.BackgroundColor = ConsoleColor.Red;
Console.ForegroundColor = ConsoleColor.Yellow;
}
else
{
Console.BackgroundColor = ConsoleColor.Blue;
Console.ForegroundColor = ConsoleColor.Black;
}
}
private int GetNeighborCount(int row, int col)
{
int ne.
With the vast increase in technology, the number of ways that the us.pdf
With the vast increase in technology, the number of ways that the us.pdfaravlitraders2012 With the vast increase in technology, the number of ways that the use of cybertechnology impact
the personalities are also increasing. Many of the social scientists has proofs for this.
One incident, in the 1980s, that quickly caught their attention involved a male psychologist who
joined an online forum for disabled persons, where he identified himself as a woman who had
become crippled as a result of an automobile accident.
Mitch Parsell (2008) describes the Internet as a \"powerful new force\" for what he calls \"the
manufacture of identity.\" He believes that this technological medium offers an unparalleled
ability to create ourselves in our own image. It gives users an unprecedented capacity to
determine their initial presentations to others.In short, it enables users to be masters of their
identity.
Now when we talk about Ethics and Technology: Controversies, Questions, and Strategies for
Ethical Computing:
Cybertechnology as a \"Medium of Self-Expression\" Sherry Turkle (2005) notes that by the
mid-1980s, computers had become an \"evocative object\"—i.e., an object that \"provoked self-
reflection.\" Turkle suggested that a computer could be viewed as a model for analyzing and
constructing one\'s identity. She also noted that the computer has become a medium through
which people could discover their personal identity; for example, computers provide a context in
which individuals can try out different cognitive styles and different methods of problem solving
to ultimately discover which style or method they prefer. Because people develop their own
unique style of computing, Turkle argues that the computational environment becomes an
extension of themselves, in much the same way that their manner of dress is an extension of their
personality. So, in her view, a computer can function as a \"medium for self-expression\" as well
as for \"self-discovery.
Impact of cybertechnology on Sense of Self
We have examined some effects that one\'s interactions in virtual or computer-mediated
environments, including MOOs and MUDs, can have for one\'s personal identity.
2 main factors are:
our relation to nature,
our relation to (and sense of place in) the universe.
Williams notes that in the aftermath of these milestones, we have a much humbler view of our
place in the universe than our ancestors did.
How, exactly, has cybertechnology also has influenced the way that we see ourselves in relation
to both the factors—i.e., how has this relatively recent technology already begun to define us as
human beings?
To support Bolter\'s thesis that we have come to see ourselves more and more in computer-like
ways, we have only to reflect for a moment on some of the expressions that we now use to
describe ourselves. For example, Bolter points out that when psychologists speak of \"input and
output states of the brain,\" or of the brain\'s hardware and software, they exemplify Turing\'s
men. And when cognitive psychologists study the \"mind\'s algorithm for searchi.
Let n = size of the hash table hashTable = array of size n, w.pdf
Let n = size of the hash table hashTable = array of size n, w.pdfaravlitraders2012 //Let n = size of the hash table
// hashTable = array of size n, which represents the hash table
// hashIndex = represents the index of array
// If the list is EMPTY, we add the element into the list
/*If the list is NOT EMPTY then we compare the newNode to the node already in the list in such
a way to get sorted.*/
struct node
{
int key;
T value;
struct node *next;
};
struct node *hashTable[n] = {NULL};
struct node * createNode(int key, char *name, int age)
{
struct node *newnode;
newnode = (struct node *)malloc(sizeof(struct node));
newnode->key = key;
newnode->value = value;
newnode->next = NULL;
return newnode;
}
add(int key, T value)
{
int hashIndex = key % n;
struct node *newNode = creteNode(key,value);
/*Adding new node to the list with No element */
if (hashTable[hashIndex] == NULL)
{
hashTable[hashIndex] = newnode;
return;
}
/*Adding new node to the sorted list */
struct node *temp1;
struct node *temp2 = hashTable[hashIndex];
temp1 = temp2;
while(temp2 -> key < newNode -> key)
{
temp1 = temp2;
temp2 = temp2 ->next;
}
newnode->next = temp2;
temp1->next = newNode;
return;
}
Solution
//Let n = size of the hash table
// hashTable = array of size n, which represents the hash table
// hashIndex = represents the index of array
// If the list is EMPTY, we add the element into the list
/*If the list is NOT EMPTY then we compare the newNode to the node already in the list in such
a way to get sorted.*/
struct node
{
int key;
T value;
struct node *next;
};
struct node *hashTable[n] = {NULL};
struct node * createNode(int key, char *name, int age)
{
struct node *newnode;
newnode = (struct node *)malloc(sizeof(struct node));
newnode->key = key;
newnode->value = value;
newnode->next = NULL;
return newnode;
}
add(int key, T value)
{
int hashIndex = key % n;
struct node *newNode = creteNode(key,value);
/*Adding new node to the list with No element */
if (hashTable[hashIndex] == NULL)
{
hashTable[hashIndex] = newnode;
return;
}
/*Adding new node to the sorted list */
struct node *temp1;
struct node *temp2 = hashTable[hashIndex];
temp1 = temp2;
while(temp2 -> key < newNode -> key)
{
temp1 = temp2;
temp2 = temp2 ->next;
}
newnode->next = temp2;
temp1->next = newNode;
return;
}.
What is the need of the t Distribution According to the central.pdf
What is the need of the t Distribution According to the central.pdfaravlitraders2012 What is the need of the t Distribution?
According to the central limit theorem, the sampling distribution of a statistic (like a sample
mean) will follow a normal distribution, as long as the sample size is sufficiently large.
Therefore, when we know the standard deviation of the population, we can compute a z-score,
and use the normal distribution to evaluate probabilities with the sample mean.
But sample sizes are sometimes small, and often we do not know the standard deviation of the
population. When either of these problems occur, statisticians rely on the distribution of the t
statistic (also known as the t score), whose values are given by:
t = [ x - ? ] / [ s / sqrt( n ) ]
where x is the sample mean, ? is the population mean, s is the standard deviation of the sample,
and n is the sample size. The distribution of the t statistic is called the t distribution or the
Student t distribution.
The t distribution allows us to conduct statistical analyses on certain data sets that are not
appropriate for analysis, using the normal distribution.
Degrees of Freedom
There are actually many different t distributions. The particular form of the t distribution is
determined by its degrees of freedom. The degrees of freedom refers to the number of
independent observations in a set of data.
When estimating a mean score or a proportion from a single sample, the number of independent
observations is equal to the sample size minus one. Hence, the distribution of the t statistic from
samples of size 8 would be described by a t distribution having 8 - 1 or 7 degrees of freedom.
Similarly, a t distribution having 15 degrees of freedom would be used with a sample of size 16.
Solution
What is the need of the t Distribution?
According to the central limit theorem, the sampling distribution of a statistic (like a sample
mean) will follow a normal distribution, as long as the sample size is sufficiently large.
Therefore, when we know the standard deviation of the population, we can compute a z-score,
and use the normal distribution to evaluate probabilities with the sample mean.
But sample sizes are sometimes small, and often we do not know the standard deviation of the
population. When either of these problems occur, statisticians rely on the distribution of the t
statistic (also known as the t score), whose values are given by:
t = [ x - ? ] / [ s / sqrt( n ) ]
where x is the sample mean, ? is the population mean, s is the standard deviation of the sample,
and n is the sample size. The distribution of the t statistic is called the t distribution or the
Student t distribution.
The t distribution allows us to conduct statistical analyses on certain data sets that are not
appropriate for analysis, using the normal distribution.
Degrees of Freedom
There are actually many different t distributions. The particular form of the t distribution is
determined by its degrees of freedom. The degrees of freedom refers to the number of
independent observations in a set of da.
We can see in course of evolution of plant there was a transition fr.pdf
We can see in course of evolution of plant there was a transition fr.pdfaravlitraders2012 We can see in course of evolution of plant there was a transition from aquatic to terrestrial life
has taken place.They have adapted lots of features to servive on land.
1.Thay became so large comparative ao aquatic plants.This feature evolve to colonise the land.
2.They have developed well organised vascular system allowing plant to absorb water from soil.
3 .They have evolved strong roots to adhere by the substratum.They can go few meters inside the
soil.
Solution
We can see in course of evolution of plant there was a transition from aquatic to terrestrial life
has taken place.They have adapted lots of features to servive on land.
1.Thay became so large comparative ao aquatic plants.This feature evolve to colonise the land.
2.They have developed well organised vascular system allowing plant to absorb water from soil.
3 .They have evolved strong roots to adhere by the substratum.They can go few meters inside the
soil..
Wave CharacterMany of the things that light does are only expla.pdf
Wave CharacterMany of the things that light does are only expla.pdfaravlitraders2012 >> Wave Character
Many of the things that light does are only explained sufficiently by thinking of light as a wave.
Refraction and diffraction are two examples. Light refracts when it travels from one medium to
another, because waves travel at different speeds through different media. In a similar way, light
diffracts when it travels between or around objects, because obstacles make the light waves bend.
So, obviously we\'re not wrong about light behaving like a wave. We even use the wave
diffraction of light by reading interference patterns in X-ray crystallography.
>> Particle Behaviour
photoelectric effect, which describes the way electrons are excited and emitted from matter when
they absorb the energy from light. In 1887, Heinrich Hertz observed that a charged object would
create a bigger, faster spark if it was treated with ultraviolet light because the light was actually
exciting the electrons. Further studies by other scientists showed that electrons really could be
knocked out of a metal in response to a beam of light. For a while, scientists thought that the
electrons were just absorbing the energy in the light wave, and then using that energy to jump out
of the metal. The more energy the electrons could absorb, the more energy they could use to
jump out.
A photon is a nearly massless particle carrying a small amount of energy. We use photons to
quantify, or measure the amount of, the energy in light and other electromagnetic waves. Each
photon can excite only one electron at a time. When the intensity of light is increased, then the
number of photons is increased, so a higher number of electrons are knocked loose from the
metal. The energy of electrons does not change because the energy of each photon is still the
same.
Solution
>> Wave Character
Many of the things that light does are only explained sufficiently by thinking of light as a wave.
Refraction and diffraction are two examples. Light refracts when it travels from one medium to
another, because waves travel at different speeds through different media. In a similar way, light
diffracts when it travels between or around objects, because obstacles make the light waves bend.
So, obviously we\'re not wrong about light behaving like a wave. We even use the wave
diffraction of light by reading interference patterns in X-ray crystallography.
>> Particle Behaviour
photoelectric effect, which describes the way electrons are excited and emitted from matter when
they absorb the energy from light. In 1887, Heinrich Hertz observed that a charged object would
create a bigger, faster spark if it was treated with ultraviolet light because the light was actually
exciting the electrons. Further studies by other scientists showed that electrons really could be
knocked out of a metal in response to a beam of light. For a while, scientists thought that the
electrons were just absorbing the energy in the light wave, and then using that energy to jump out
of the metal. The more energy the electr.
The solvent doesnt interfere with the purification processOil Bath.pdf
The solvent doesnt interfere with the purification processOil Bath.pdfaravlitraders2012 The solvent doesnt interfere with the purification process
Oil Bath Assembly
Mineral oil or silicone oil is typically used for oil baths in research labs for reactions that require
heating/reflux temperatures up to 200 °C. Oil baths provide more uniform heat in comparison to
other heating devices. A laboratory oil bath is made of an aluminum or stainless steel pan, a
heavy porcelain dish or thick walled Pyrex® glass to withstand breakage and accidental spill.
The electric heating coil (or oil bath on a hot plate) is controlled using a variable voltage
controller (i.e., Variac). The voltage controller is adjusted to increase or decrease the temperature
setting of the oil bath. Heating mantles should NEVER be plugged directly into an outlet.
Bath Material
Useful Range
Flash Point
Advantage/Disadvantage
Risk
Silicone Oil
25 °C to 230 °C
150 °C to
350 °C
Acceptable
MODERATE
Water (rotary evaporator)
0 °C to 70 °C
Acceptable.
LOW
Sand
25°C to 500+ °C
NA
Acceptable.
LOW
Hazards
Hazards associated with the use of oil baths include hot temperatures and fire.
Medical Attention and Emergency Treatment
Use cold water and rinse the affected skin immediately for at least for 15 minutes; remove any
hot oil residue without rubbing the skin. If the affected area is on the hand, wrap with a clean
bandage to prevent further irritation and injury. DO NOT apply any ointments and avoid
breaking blisters. Seek medical attention as necessary. Medical Attention and Emergency
Treatment information is provided on the EHS website.
Personal Protective Equipment (PPE)
Slip-resistant insulated thermal gloves.
Safety glasses with side shields or a face shield.
Lab coat (and wear pants that cover the legs).
Prudent Safety Practices
Storage
Spill Cleanup
Granular clay absorbents, universal polypropylene sorbent pads, or other oil-specific absorbent
pads can be used for cleanup of small incidental spills of both bath oil and vacuum pump oil.
Solid waste from the cleanup can be scooped, bagged, and placed in a metal container or other
compatible container. Oil-specific absorbents absorb only oil and not aqueous materials. For
questions, contact EHS for proper cleanup and disposal procedures.
Disposal of Used Oil
advantages
techniques are understandably used only for samples containing a significant amount of
combustible or organic material as the matrix. With this in mind, let\'s look at the major
advantages
· The ability to decompose large sample sizes.
· The need for little or no reagents.
· The technique is relatively safe.
· The ability to prepare samples containing volatile combustion elements such as sulfur,
fluorine and chlorine (the Schöniger oxygen flask combustion technique is very popular in this
case).
· The technique lends itself to mass production.
The technique of graphite furnace atomic absorption spectrometry (GFAA) incorporates sample
ashing as part of an automatic measurement cycle. Trace analysts have learned a great deal about
the loss of volatile componen.
An object of class StatCalc can be used to compute several simp.pdf
An object of class StatCalc can be used to compute several simp.pdfaravlitraders2012 /*
An object of class StatCalc can be used to compute several simple statistics
for a set of numbers. Numbers are entered into the dataset using
the enter(double) method. Methods are provided to return the following
statistics for the set of numbers that have been entered: The number
of items, the sum of the items, the average, the standard deviation,
the maximum, and the minimum.
*/
public class Stats {
private int count; // Number of numbers that have been entered.
private double sum; // The sum of all the items that have been entered.
private double squareSum; // The sum of the squares of all the items.
private double max = Double.NEGATIVE_INFINITY; // Largest item seen.
private double min = Double.POSITIVE_INFINITY; // Smallest item seen.
int[] myList;
public int getCount() {
System.out.println(myList.size());
count = myList.size().
// Return number of items that have been entered.
return count;
}
public double getSum() {
int sum = 0;
for (int i = 0; i < myList.length; i++)
{
sum +=mylist[i];
}
return sum;
}
public double getMean() {
int sum = 0;
for (int i = 0; i < myList.length; i++)
{
sum +=mylist[i];
}
if(count > 0)
return sum / count;
else
return -1;
}
public double getMin() {
int smallest = myList[0];
int largetst = myList[0];
for(int i=1; i< mylist.length; i++)
{
if(mylist[i] > largetst)
largetst = numbers[i];
else if (mylist[i] < smallest)
smallest = numbers[i];
}
return smallest;
}
public double getMax() {
int smallest = myList[0];
int largetst = myList[0];
for(int i=1; i< mylist.length; i++)
{
if(mylist[i] > largetst)
largetst = numbers[i];
else if (mylist[i] < smallest)
smallest = numbers[i];
}
return largetst;
}
stats(int [] data)
{
if(data.count <= count)
{
if(myList.size() > 0)
System.arraycopy( myList, 0, data, 0, count );
}
}
stats()
{
Scanner s = new Scanner(System.in);
int count = s.nextInt();
s.nextLine(); // throw away the newline.
int [] numbers = new int[count];
Scanner numScanner = new Scanner(s.nextLine());
for (int i = 0; i < count; i++) {
if (numScanner.hasNextInt()) {
numbers[i] = numScanner.nextInt();
} else {
System.out.println(\"You didn\'t provide enough numbers\");
break;
}
}
System.arraycopy( myList, 0, numbers, 0, count );
}
stats(int size)
{
setValue(size);
}
private void setValue(int size)
{
count = size;
myList = new int[size];
}
} // end class StatCalc
public class SimpleStats {
public static void main(String[] args) {
Stat calc; // Computes stats for numbers entered by user.
calc = new Stat(100);
int arry[] = {20.20.40,30.80,,70,4,5,6,7,10}
calc.setvalue(array);
double item; // One number entered by the user.
TextIO.putln(\"Enter your numbers. Enter 0 to end.\");
TextIO.putln();
do {
TextIO.put(\"? \");
item = TextIO.getlnDouble();
if (item != 0)
calc.enter(item);
} while ( item != 0 );
TextIO.putln(\"\ Statistics about your calc:\ \");
TextIO.putln(\" Count: \" + calc.getCount());
TextIO.putln(\" Sum: \" + calc.getSum());
TextIO.putln(\" Minimum: \" + calc.getMin());
TextIO.putln(\" Maximum: \" + ca.
The answers can be found below as discussedPart 1)The human gen.pdf
The answers can be found below as discussedPart 1)The human gen.pdfaravlitraders2012 The answers can be found below as discussed:
Part 1)
The human genome is highly vast in nature and hence there are some complicating factors in the
study of human genetics:
1: Size and packing: The human genome is enoromously large in linear seqeunce which makes it
highly difficult to be analysed as a whole. Moreover, the DNA is wounded in complex primary,
secondary and tertiary structures which makes is difficult to isolate intact i.e. formation of
nucleosomes over histones, solenoid formation, high writhe and twist etc. The human genome is
highly compact and along with it, chemical modifications such as
acetylation/methylation/sumoylation/phosphorylation of the DNA-associated proteins also occur.
Similarly, post-transcriptional modifications of mRNA also occur only in eukaryotes.
Compensation: These structural features of the human genome have been well exploited for their
analysis. The size cannot be reduced directly but the complexity of packing can be used by
action of relaxation enzymes such as topoisomerases.
Part 2)
The coding sequences: The human genome is not continuously coding in nature, but it has been
differentiated into stretches of coding euchromatin exons and non-coding intervening
heterochromatin intron sequences. This makes the linearity of the coding sequence highly
compromised and a single mechanism of linear transcription or translation cannot take place.
Compensation: The human genome contains the intron sequences only in the DNA. These
sequences are effectively removed out of the DNA after transcription by mRNA splicing and
thus only exons are remained in the mRNA. Thus, this ensures that only exons can reach the
translation process.
3. Polymorphism: The human genome shows very high degree of single nucleotide
polymorphism (SNP) which shows pattern of inheritance and can be transitted form one person
to another genetically. These SNPs are crucial for providing discrete phenotypic features to
individuals which can be difficult to assess and identify due to large size of human genome.
Compensation: Although there occur SNPs in human genome, the modern techniques such as
next-generation seqeuncing have made it possible to effectively, efficiently and quickly screen
the whole genome for such targets.
Answer part 2)
Variations in Mendelian genetics in humans can be described as below:
1. Co-dominance: Unlike Mendelian genetics, the blood group system of humans show co-
dominance between the allele A and allele B and both of these alleles are completely dominant
over the allele O. This makes occurance of various phenotypes in blood groups i.e. A, B, AB and
O.
2. Incomplete dominance: On contrary to Mendel\'s pattern of inheritance, the texture of hair in
human is inherited genetically following a pattern of incomplete dominance. This deciphers that
an offspring of parents having straight and curly hair will have softly curled hair.
3. Quantitative traits: Unlike Mendel\'s patterns of inheritance, some genes show quantitative.
Solution (3)The smallest respiratory bronchioles subdivide into t.pdf
Solution (3)The smallest respiratory bronchioles subdivide into t.pdfaravlitraders2012 Solution
:
(3)The smallest respiratory bronchioles subdivide into thin airways called alveolar
ducts.Alveolar sacs are connected to respiratory bronchioles by alveolar ducts.It helps alveoli in
process of gas exchange.Alveolar duct transport inhaled air filled in it to the alveoli and after the
process of gas exchange completed alveolar duct exhibit carbon dioxide gas..
An asset manager of a hedge fund or a mutual funds is the one who di.pdf
An asset manager of a hedge fund or a mutual funds is the one who di.pdfaravlitraders2012 An asset manager of a hedge fund or a mutual funds is the one who directly handles the client
money and is responsible for acting in an ethical manner while discharging their duties.
Some of the major ways in which asset managers breach their fiduciary duties are as follows :
(i) Asset Managers generally have access to private information of companies\' profits, next
business move, major public announcements which have direct effect on the stock price. In order
to make their judgement about stocks right, fund managers use manupulative techniques to
inflate stock prices with the help of insider information.
(ii) Fund managers in normal practice met out prefrential treatment to clients whose asset volume
being managed is higher than the rest of the group. In this way only a group of clients gets all the
attention of the fund manager.
(iii) Fund managers usually undertake complex financial transactions and disclose less of these
to the clients and regulators.
(iv) Fund managers engage in activities which more oftem result in conflict of interest. Conflicts
of interest can be in the form of raise larger funds when insufficient opportunities exist, taking
over undisclosed and inappropriate risk in the investment etc.
Solution
An asset manager of a hedge fund or a mutual funds is the one who directly handles the client
money and is responsible for acting in an ethical manner while discharging their duties.
Some of the major ways in which asset managers breach their fiduciary duties are as follows :
(i) Asset Managers generally have access to private information of companies\' profits, next
business move, major public announcements which have direct effect on the stock price. In order
to make their judgement about stocks right, fund managers use manupulative techniques to
inflate stock prices with the help of insider information.
(ii) Fund managers in normal practice met out prefrential treatment to clients whose asset volume
being managed is higher than the rest of the group. In this way only a group of clients gets all the
attention of the fund manager.
(iii) Fund managers usually undertake complex financial transactions and disclose less of these
to the clients and regulators.
(iv) Fund managers engage in activities which more oftem result in conflict of interest. Conflicts
of interest can be in the form of raise larger funds when insufficient opportunities exist, taking
over undisclosed and inappropriate risk in the investment etc..
Ad
Recently uploaded (20)
How to Manage Opening & Closing Controls in Odoo 17 POS
How to Manage Opening & Closing Controls in Odoo 17 POSCeline George In Odoo 17 Point of Sale, the opening and closing controls are key for cash management. At the start of a shift, cashiers log in and enter the starting cash amount, marking the beginning of financial tracking. Throughout the shift, every transaction is recorded, creating an audit trail.
Link your Lead Opportunities into Spreadsheet using odoo CRM
Link your Lead Opportunities into Spreadsheet using odoo CRMCeline George In Odoo 17 CRM, linking leads and opportunities to a spreadsheet can be done by exporting data or using Odoo’s built-in spreadsheet integration. To export, navigate to the CRM app, filter and select the relevant records, and then export the data in formats like CSV or XLSX, which can be opened in external spreadsheet tools such as Excel or Google Sheets.
APM Midlands Region April 2025 Sacha Hind Circulated.pdf
APM Midlands Region April 2025 Sacha Hind Circulated.pdfAssociation for Project Management APM event hosted by the Midlands Network on 30 April 2025.
Speaker: Sacha Hind, Senior Programme Manager, Network Rail
With fierce competition in today’s job market, candidates need a lot more than a good CV and interview skills to stand out from the crowd.
Based on her own experience of progressing to a senior project role and leading a team of 35 project professionals, Sacha shared not just how to land that dream role, but how to be successful in it and most importantly, how to enjoy it!
Sacha included her top tips for aspiring leaders – the things you really need to know but people rarely tell you!
We also celebrated our Midlands Regional Network Awards 2025, and presenting the award for Midlands Student of the Year 2025.
This session provided the opportunity for personal reflection on areas attendees are currently focussing on in order to be successful versus what really makes a difference.
Sacha answered some common questions about what it takes to thrive at a senior level in a fast-paced project environment: Do I need a degree? How do I balance work with family and life outside of work? How do I get leadership experience before I become a line manager?
The session was full of practical takeaways and the audience also had the opportunity to get their questions answered on the evening with a live Q&A session.
Attendees hopefully came away feeling more confident, motivated and empowered to progress their careers
Ancient Stone Sculptures of India: As a Source of Indian History
Ancient Stone Sculptures of India: As a Source of Indian HistoryVirag Sontakke This Presentation is prepared for Graduate Students. A presentation that provides basic information about the topic. Students should seek further information from the recommended books and articles. This presentation is only for students and purely for academic purposes. I took/copied the pictures/maps included in the presentation are from the internet. The presenter is thankful to them and herewith courtesy is given to all. This presentation is only for academic purposes.
Form View Attributes in Odoo 18 - Odoo Slides
Form View Attributes in Odoo 18 - Odoo SlidesCeline George Odoo is a versatile and powerful open-source business management software, allows users to customize their interfaces for an enhanced user experience. A key element of this customization is the utilization of Form View attributes.
Biophysics Chapter 3 Methods of Studying Macromolecules.pdf
Biophysics Chapter 3 Methods of Studying Macromolecules.pdfPKLI-Institute of Nursing and Allied Health Sciences Lahore , Pakistan. This chapter provides an in-depth overview of the viscosity of macromolecules, an essential concept in biophysics and medical sciences, especially in understanding fluid behavior like blood flow in the human body.
Key concepts covered include:
✅ Definition and Types of Viscosity: Dynamic vs. Kinematic viscosity, cohesion, and adhesion.
⚙️ Methods of Measuring Viscosity:
Rotary Viscometer
Vibrational Viscometer
Falling Object Method
Capillary Viscometer
🌡️ Factors Affecting Viscosity: Temperature, composition, flow rate.
🩺 Clinical Relevance: Impact of blood viscosity in cardiovascular health.
🌊 Fluid Dynamics: Laminar vs. turbulent flow, Reynolds number.
🔬 Extension Techniques:
Chromatography (adsorption, partition, TLC, etc.)
Electrophoresis (protein/DNA separation)
Sedimentation and Centrifugation methods.
BỘ ĐỀ TUYỂN SINH VÀO LỚP 10 TIẾNG ANH - 25 ĐỀ THI BÁM SÁT CẤU TRÚC MỚI NHẤT, ...
BỘ ĐỀ TUYỂN SINH VÀO LỚP 10 TIẾNG ANH - 25 ĐỀ THI BÁM SÁT CẤU TRÚC MỚI NHẤT, ...Nguyen Thanh Tu Collection https://app.box.com/s/n8nl163m8v9ou7xil944pod44a5wi43h
How to Configure Scheduled Actions in odoo 18
How to Configure Scheduled Actions in odoo 18Celine George Scheduled actions in Odoo 18 automate tasks by running specific operations at set intervals. These background processes help streamline workflows, such as updating data, sending reminders, or performing routine tasks, ensuring smooth and efficient system operations.
APGAR SCORE BY sweety Tamanna Mahapatra MSc Pediatric
APGAR SCORE BY sweety Tamanna Mahapatra MSc PediatricSweetytamannaMohapat Learn about the APGAR SCORE , a simple yet effective method to evaluate a newborn's physical condition immediately after birth ....this presentation covers .....
what is apgar score ?
Components of apgar score.
Scoring system
Indications of apgar score........
PHYSIOLOGY MCQS By DR. NASIR MUSTAFA (PHYSIOLOGY)
PHYSIOLOGY MCQS By DR. NASIR MUSTAFA (PHYSIOLOGY)Dr. Nasir Mustafa PHYSIOLOGY MCQS By DR. NASIR MUSTAFA (PHYSIOLOGY)
apa-style-referencing-visual-guide-2025.pdf
apa-style-referencing-visual-guide-2025.pdfIshika Ghosh Title: A Quick and Illustrated Guide to APA Style Referencing (7th Edition)
This visual and beginner-friendly guide simplifies the APA referencing style (7th edition) for academic writing. Designed especially for commerce students and research beginners, it includes:
✅ Real examples from original research papers
✅ Color-coded diagrams for clarity
✅ Key rules for in-text citation and reference list formatting
✅ Free citation tools like Mendeley & Zotero explained
Whether you're writing a college assignment, dissertation, or academic article, this guide will help you cite your sources correctly, confidently, and consistent.
Created by: Prof. Ishika Ghosh,
Faculty.
📩 For queries or feedback: [email protected]
How to Configure Public Holidays & Mandatory Days in Odoo 18
How to Configure Public Holidays & Mandatory Days in Odoo 18Celine George In this slide, we’ll explore the steps to set up and manage Public Holidays and Mandatory Days in Odoo 18 effectively. Managing Public Holidays and Mandatory Days is essential for maintaining an organized and compliant work schedule in any organization.
Tax evasion, Tax planning & Tax avoidance.pptx
Tax evasion, Tax planning & Tax avoidance.pptxmanishbaidya2017 Tax evasion, Tax planning & Tax avoidance are not same
Grade 3 - English - Printable Worksheet (PDF Format)
Grade 3 - English - Printable Worksheet (PDF Format)Sritoma Majumder Grade 3 - English - Printable Worksheet (PDF Format)
Debunking the Myths behind AI - v1, Carl Dalby
Debunking the Myths behind AI - v1, Carl DalbyAssociation for Project Management APM webinar hosted by the South Wales and West of England Network on 1 May 2025.
Speaker: Carl Dalby, Group Head of AI/Digital, NDA
So, what does AI mean for you as a project professional, how can you take advantage of it to improve the success of your project? This webinar was held on 1 May 2025.
There is a lot of misinformation, myth, and misconception surrounding Artificial Intelligence in the press and on social media. Using real world examples and case studies around project and risk management, Carl Dalby looked at what AI is and is not, and how Project Professionals can use AI to help augment their decision making by gaining valuable insights into what their data is actually telling them.
Carl adapted his talk to reflect the very latest thinking in this very fast-moving sector
https://www.apm.org.uk/news/debunking-the-myths-behind-ai-what-it-really-means-for-you-as-a-project-professional/
How to Create A Todo List In Todo of Odoo 18
How to Create A Todo List In Todo of Odoo 18Celine George In this slide, we’ll discuss on how to create a Todo List In Todo of Odoo 18. Odoo 18’s Todo module provides a simple yet powerful way to create and manage your to-do lists, ensuring that no task is overlooked.
Rock Art As a Source of Ancient Indian History
Rock Art As a Source of Ancient Indian HistoryVirag Sontakke This Presentation is prepared for Graduate Students. A presentation that provides basic information about the topic. Students should seek further information from the recommended books and articles. This presentation is only for students and purely for academic purposes. I took/copied the pictures/maps included in the presentation are from the internet. The presenter is thankful to them and herewith courtesy is given to all. This presentation is only for academic purposes.
How to Manage Upselling in Odoo 18 Sales
How to Manage Upselling in Odoo 18 SalesCeline George In this slide, we’ll discuss on how to manage upselling in Odoo 18 Sales module. Upselling in Odoo is a powerful sales technique that allows you to increase the average order value by suggesting additional or more premium products or services to your customers.
Biophysics Chapter 3 Methods of Studying Macromolecules.pdf
Biophysics Chapter 3 Methods of Studying Macromolecules.pdfPKLI-Institute of Nursing and Allied Health Sciences Lahore , Pakistan.
BỘ ĐỀ TUYỂN SINH VÀO LỚP 10 TIẾNG ANH - 25 ĐỀ THI BÁM SÁT CẤU TRÚC MỚI NHẤT, ...
BỘ ĐỀ TUYỂN SINH VÀO LỚP 10 TIẾNG ANH - 25 ĐỀ THI BÁM SÁT CẤU TRÚC MỚI NHẤT, ...Nguyen Thanh Tu Collection
Ad
Exception to indicate that Singly LinkedList is empty. .pdf
- 1. /** * Exception to indicate that Singly LinkedList is empty. */ class LinkedListEmptyException extends RuntimeException { public LinkedListEmptyException() { super(); } public LinkedListEmptyException(String message) { super(message); } } /** * Node class, which holds data and contains next which points to next Node. */ class Node { public int data; // data in Node. public Node next; // points to next Node in list. /** * Constructor */ public Node(int data) { this.data = data; } /** * Display Node's data */ public void displayNode() { System.out.print(data + " "); } } /** * Singly LinkedList class */ class LinkedList { private Node first; // ref to first link on list
- 2. /** * LinkedList constructor */ public LinkedList() { first = null; } /** * Insert New Node at first position */ public void insertFirst(int data) { Node newNode = new Node(data); // Creation of New Node. newNode.next = first; // newLink ---> old first first = newNode; // first ---> newNode } /** * Method deletes specific Node from Singly LinkedList in java. */ public Node deleteSpecificNode(int deleteKey) { // Case1: when there is no element in LinkedList if (first == null) { // means LinkedList in empty, throw exception. throw new LinkedListEmptyException( "LinkedList doesn't contain any Nodes."); } // Case2: when there is only one element in LinkedList- check whether we // have to delete that Node or not. if (first.data == deleteKey) { // means LinkedList consists of only one // element, delete that. Node tempNode = first; // save reference to first Node in tempNode- // so that we could return saved reference. first = first.next; System.out.println("Node with data=" + tempNode.data + " was found on first and has been deleted."); return tempNode; // return deleted Node. } // Case3: when there are atLeast two elements in LinkedList Node previous = null;
- 3. Node current = first; while (current != null) { if (current.data == deleteKey) { System.out.println("Node with data=" + current.data + " has been deleted."); previous.next = current.next; // make previous node's next point // to current node's next. return current; // return deleted Node. } else { if (current.next == null) { // Means Node wasn't found. System.out.println("Node with data=" + deleteKey + " wasn't found for deletion."); return null; } previous = current; current = current.next; // move to next node. } } return null; } /** * Display Singly LinkedList */ public void displayLinkedList() { System.out.print("Displaying LinkedList [first--->last]: "); Node tempDisplay = first; // start at the beginning of linkedList while (tempDisplay != null) { // Executes until we don't find end of // list. tempDisplay.displayNode(); tempDisplay = tempDisplay.next; // move to next Node System.out.print("-->"); } System.out.println(); } } /**
- 4. * Main class - To test LinkedList. */ public class SinglyLinkedListDeleteNodeExample { public static void main(String[] args) { LinkedList linkedList = new LinkedList(); // creation of Linked List linkedList.insertFirst(92); linkedList.insertFirst(20); linkedList.insertFirst(19); linkedList.insertFirst(29); linkedList.displayLinkedList(); // display LinkedList linkedList.deleteSpecificNode(20); linkedList.displayLinkedList(); // Again display LinkedList } } OUTPUT: Displaying LinkedList [first--->last]: 29 -->19 -->20 -->92 --> Node with data=20 has been deleted. Node with data=11 wasn't found for deletion. Displaying LinkedList [first--->last]: 29 -->19 -->92 --> Solution /** * Exception to indicate that Singly LinkedList is empty. */ class LinkedListEmptyException extends RuntimeException { public LinkedListEmptyException() { super(); } public LinkedListEmptyException(String message) { super(message); } } /** * Node class, which holds data and contains next which points to next Node. */
- 5. class Node { public int data; // data in Node. public Node next; // points to next Node in list. /** * Constructor */ public Node(int data) { this.data = data; } /** * Display Node's data */ public void displayNode() { System.out.print(data + " "); } } /** * Singly LinkedList class */ class LinkedList { private Node first; // ref to first link on list /** * LinkedList constructor */ public LinkedList() { first = null; } /** * Insert New Node at first position */ public void insertFirst(int data) { Node newNode = new Node(data); // Creation of New Node. newNode.next = first; // newLink ---> old first first = newNode; // first ---> newNode } /**
- 6. * Method deletes specific Node from Singly LinkedList in java. */ public Node deleteSpecificNode(int deleteKey) { // Case1: when there is no element in LinkedList if (first == null) { // means LinkedList in empty, throw exception. throw new LinkedListEmptyException( "LinkedList doesn't contain any Nodes."); } // Case2: when there is only one element in LinkedList- check whether we // have to delete that Node or not. if (first.data == deleteKey) { // means LinkedList consists of only one // element, delete that. Node tempNode = first; // save reference to first Node in tempNode- // so that we could return saved reference. first = first.next; System.out.println("Node with data=" + tempNode.data + " was found on first and has been deleted."); return tempNode; // return deleted Node. } // Case3: when there are atLeast two elements in LinkedList Node previous = null; Node current = first; while (current != null) { if (current.data == deleteKey) { System.out.println("Node with data=" + current.data + " has been deleted."); previous.next = current.next; // make previous node's next point // to current node's next. return current; // return deleted Node. } else { if (current.next == null) { // Means Node wasn't found. System.out.println("Node with data=" + deleteKey + " wasn't found for deletion."); return null; } previous = current;
- 7. current = current.next; // move to next node. } } return null; } /** * Display Singly LinkedList */ public void displayLinkedList() { System.out.print("Displaying LinkedList [first--->last]: "); Node tempDisplay = first; // start at the beginning of linkedList while (tempDisplay != null) { // Executes until we don't find end of // list. tempDisplay.displayNode(); tempDisplay = tempDisplay.next; // move to next Node System.out.print("-->"); } System.out.println(); } } /** * Main class - To test LinkedList. */ public class SinglyLinkedListDeleteNodeExample { public static void main(String[] args) { LinkedList linkedList = new LinkedList(); // creation of Linked List linkedList.insertFirst(92); linkedList.insertFirst(20); linkedList.insertFirst(19); linkedList.insertFirst(29); linkedList.displayLinkedList(); // display LinkedList linkedList.deleteSpecificNode(20); linkedList.displayLinkedList(); // Again display LinkedList } } OUTPUT:
- 8. Displaying LinkedList [first--->last]: 29 -->19 -->20 -->92 --> Node with data=20 has been deleted. Node with data=11 wasn't found for deletion. Displaying LinkedList [first--->last]: 29 -->19 -->92 -->