I need help in writing the test cases of the below methods i.pdf
•
0 likes•2 views
I need help in writing the test cases of the below methods in java. The test cases must test both empty and non empty deque.PLS HELP ME WITH WRITING THE TEST CASES IN JAVA.ITS URGENT. package deque; /** * A deque implemented using a doubly-linked chain. * * @param <T> * The type of elements contained in the deque. */ public class Lab08Deque<T> extends DLinkedDeque<T> { /** * Inserts a new item at the front of the deque. * * @param newEntry * the item to insert. */ public void addToFront(T newEntry) { DLNode<T> newNode = new DLNode<T>(newEntry); if (isEmpty()) { lastNode = newNode; } else { firstNode.setPreviousNode(newNode); } newNode.setNextNode(firstNode); firstNode = newNode; size++; throw new UnsupportedOperationException( "You have not implemented addToFront() yet"); } /** * Insert a new item at the rear of the deque. * * @param newEntry * the item to insert. */ public void addToBack(T newEntry) { DLNode<T> newNode = new DLNode<T>(newEntry); if (isEmpty()) { firstNode = newNode; } else { lastNode.setPreviousNode(newNode); newNode.setPreviousNode(lastNode); } lastNode = newNode; size++; throw new UnsupportedOperationException( "You have not implemented addToBack() yet"); } /** * Remove the item at the front of the deque. * * @return The item that was removed * @throws EmptyQueueException * if there is not an element at the front */ public T removeFront() { if (isEmpty()) { throw new EmptyQueueException(); } T front = firstNode.getData(); firstNode = firstNode.getNextNode(); if (firstNode == null) { lastNode = null; } else { firstNode.setPreviousNode(null); } throw new UnsupportedOperationException( "You have not implemented removeFront() yet"); } /** * Remove the item at the rear of the deque. * * @return The item that was removed * @throws EmptyQueueException * if there is no element at the front */ public T removeBack() { if (isEmpty()) { throw new EmptyQueueException(); } T data = lastNode.getData(); lastNode = lastNode.getPreviousNode(); if (lastNode == null) { firstNode = null; } else { lastNode.setPreviousNode(null); } throw new UnsupportedOperationException( "You have not implemented removeBack() yet"); } /** * Get the item at the front (the head) of the deque. Does not alter the * deque. * * @return the item at the front of the deque. * @throws EmptyQueueException * if no element at the front */ public T getFront() { if (isEmpty()) { throw new EmptyQueueException(); } return firstNode.getData(); } /** * Get the item at the rear (the tail) of the deque. Does not alter the * deque. * * @return the item at the rear of the deque. * @throws EmptyQueueException * if no element at rear * */ public T getBack() { if (isEmpty()) { throw new EmptyQueueException(); } return lastNode.getData(); } /** * Check if the deque is empty * * @return true if the deque has no items */ public boolean isEmpty() { return size() == 0; } /** * Empty the deque. */ public void clear() { while (!isEmpty()) { removeFront(); } } // -------------------------------.
Report
Share
Report
Share
Download to read offline
Recommended
Java Foundations StackADT-java --- - Defines the interface to a stack.docx
Java Foundations
StackADT.java
/**
* Defines the interface to a stack collection.
*
* @author Java Foundations
* @version 4.0
*/
public interface StackADT<T> {
/**
* Adds the specified element to the top of this stack.
*
* @param element element to be pushed onto the stack
*/
public void push(T element);
/**
* Removes and returns the top element from this stack.
*
* @return the element removed from the stack
* @throws EmptyCollectionException if the stack is empty
*/
public T pop();
/**
* Returns the top element of this stack without removing it from the stack.
*
* @return the element on top of the stack. It is not removed from the stack
* @throws EmptyCollectionException if the stack is empty
*/
public T peek();
/**
* Returns true if this stack contains no elements.
*
* @return true if the stack is empty, false if the stack is not empty
*/
public boolean isEmpty();
/**
* Returns the number of elements in this stack.
*
* @return the number of elements in the stack
*/
public int size();
}
QueueADT.java
/**
* QueueADT defines the interface to a queue collection.
*
* @author Java Foundation
* @version 4.0
*/
public interface QueueADT<T> {
/**
* Adds one element to the rear of this queue.
*
* @param element the element to be added to the rear of the queue
*/
public void enqueue(T element);
/**
* Removes and returns the element at the front of this queue.
*
* @return the element at the front of the queue
* @throws EmptyCollectionException if the queue is empty
*/
public T dequeue();
/**
* Returns without removing the element at the front of this queue.
*
* @return the first element in the queue
* @throws EmptyCollectionException if the queue is empty
*/
public T first();
/**
* Returns true if this queue contains no elements.
*
* @return true if the queue is empty, false if the queue is not empty
*/
public boolean isEmpty();
/**
* Returns the number of elements in this queue.
*
* @return the number of elements in the queue
*/
public int size();
}
LinkedDeque.java
public class LinkedDeque<T> implements QueueADT<T>, StackADT<T>, DequeADT<T> {
// inner class for a double linked list node
private class DNode<T> {
private T element;
private DNode<T> prev, next;
}
// data fields for the LinkedDeque class
private DNode<T> front, rear;
private int size;
// deque interface methods
@Override
public void addFirst(T element) {
// create a new node and set it up
DNode<T> newNode = new DNode<T>();
newNode.element = element; // from param to new node obj
newNode.prev = newNode.next = null;
if(this.isEmpty()) {
// we are making the only node in the deque
this.rear = this.front = newNode;
} else {
// there already exists a new node
// so, put the new node before the front node
newNode.next = this.front;
this.front.prev = newNode;
this.front = newNode;
}
this.size++;
}
@Override
public T removeFirst() {
T grabbedElt = this.getFirst(); // checks for empty for us
if.
So I have this code(StackInAllSocks) and I implemented the method but.pdf
So I have this code( StackInAllSocks ) and I implemented the method but I can't seem to figure
out why there isn't anything showing up on the console. It should pop,peek and push b using the
methods from the class called ArrayListTen . The ArrayListTen works fine and compiles the
tested code of Rigth# but for StackInAllSocks it doesn't complete at all. note that file
VodeDodeis not to be changed is just a Node storage area of the array list.
Did I implement the method on StackInAllSocks correctly? if so, should I not use the method
from the ArrayListTen .?
__________________________________________________________________________
: the code is : VodeDodeis
class VodeDode<T> {
private T data;
private VodeDode<T> next;
private VodeDode<T> prev;
public VodeDode(T data) {
this.data = data;
this.next = null;
this.prev = null;}
public T getData() {
return data;}
public void setData(T data) {
this.data = data;}
public VodeDode<T> getNext() {
return this.next;}
public void setNext(VodeDode<T> next) {
this.next = next;}
public VodeDode<T> getPrev() {
return this.prev;}
public void setPrev(VodeDode<T> prev) {
this.prev = prev;}
@Override
public String toString() {
return data.toString();}}
_________________________________________________________________________
CODE that works fine called ArrayListTen:
import java.util.Iterator;
public class ArrayListTen<T> implements Iterable<T> {
private VodeDode<T> head; //beginning of list
private VodeDode<T> tail; //end of list
private int size;
private VodeDode<T> new_item;
public ArrayListTen( ){
this.head = null;
this.tail = null;
this.size = 0;}
public int lenght() {
return size ;}
public T getBegin() {
if (this.head != null) {
return head.getData();}
else { return null;}}
public void addBegin(T value) {
VodeDode<T> newVodeDode =new VodeDode<T>(value);
if (this.head== null) {
head = newVodeDode;
tail =newVodeDode;}
else {VodeDode<T> temp = head;
head = newVodeDode;
head.setNext(temp);}
size++;}
public T removeBegin() {
if(this.head == null) {
return null;}
else {T current = head.getData();
if (tail == head) {
tail = null;
head = null;
} else {
head = head.getNext();
head.setPrev(null);}size--;
return current;}}
public T getEnd() {
if (tail != null) {
return tail.getData();
} else {
return null;}}
public void addEnd(T value) {
VodeDode<T> newVodeDode = new VodeDode<T>(value);
if (this.tail == null) {
head = newVodeDode;
tail = newVodeDode;
} else {
newVodeDode.setPrev(tail);
tail.setNext(newVodeDode);
tail = newVodeDode;}
size++;}
public T removeEnd() {
if(this.tail == null) {
return null;}
else {
T current = tail.getData();//was head.
if (head == tail) {
head = null;
tail = null;
} else {
tail = tail.getPrev();
tail.setNext(null);}
size--;
return current;}}
public T removeBN(T value) {
VodeDode<T> currVodeDode = head;
VodeDode<T> prevVodeDode = null;
while(currVodeDode != null){
if(currVodeDode.getData().equals(value)){
if(prevVodeDode != null){
prevVodeDode.setNext(currVodeDode.getNext());}
else{
head = curr.
Help please!!(Include your modified DList.java source code file in.pdf
Help please!!
(Include your modified DList.java source code file in your homework solution zip archive)
Using
whatever Java IDE you prefer, create a project and add DList.java and DListTest.java to it (these
files are provided
in the Week 6 Source zip archive). Modify DList to implement a method that removes all
occurrences of a specific
integer from the list. Here is the pseudocode:
Method removeAll(In: Integer pData) Returns Nothing
Define index variable i and initialize i to 0
While i < the size of this Dlist Do
If get(i) equals pData Then
remove(i)
Else
Increment i
End If
End While
End Method removeAll
Next, modify DListTest() to add test case 21 which tests that removeAll() works correctly.
WHat more do i need to provide to get help on this???
Solution
/* DListNode.java */
/**
* A DListNode is a node in a DList (doubly-linked list).
*/
class DListNode {
/**
* item references the item stored in the current node.
* prev references the previous node in the DList.
* next references the next node in the DList.
*
* DO NOT CHANGE THE FOLLOWING FIELD DECLARATIONS.
*/
public Object item;
protected DListNode prev;
protected DListNode next;
/**
* DListNode() constructor.
* @param i the item to store in the node.
* @param p the node previous to this node.
* @param n the node following this node.
*/
DListNode(Object i, DListNode p, DListNode n) {
item = i;
prev = p;
next = n;
}
}
/* DList.java */
/**
* A DList is a mutable doubly-linked list ADT. Its implementation is
* circularly-linked and employs a sentinel (dummy) node at the head
* of the list.
*
* DO NOT CHANGE ANY METHOD PROTOTYPES IN THIS FILE.
*/
class DList {
/**
* head references the sentinel node.
* size is the number of items in the list. (The sentinel node does not
* store an item.)
*
* DO NOT CHANGE THE FOLLOWING FIELD DECLARATIONS.
*/
protected DListNode head;
protected int size;
/* DList invariants:
* 1) head != null.
* 2) For any DListNode x in a DList, x.next != null.
* 3) For any DListNode x in a DList, x.prev != null.
* 4) For any DListNode x in a DList, if x.next == y, then y.prev == x.
* 5) For any DListNode x in a DList, if x.prev == y, then y.next == x.
* 6) size is the number of DListNodes, NOT COUNTING the sentinel,
* that can be accessed from the sentinel (head) by a sequence of
* \"next\" references.
*/
/**
* newNode() calls the DListNode constructor. Use this class to allocate
* new DListNodes rather than calling the DListNode constructor directly.
* That way, only this method needs to be overridden if a subclass of DList
* wants to use a different kind of node.
* @param item the item to store in the node.
* @param prev the node previous to this node.
* @param next the node following this node.
*/
protected DListNode newNode(Object item, DListNode prev, DListNode next) {
return new DListNode(item, prev, next);
}
/**
* DList() constructor for an empty DList.
*/
public DList() {
// Your solution here.
head = newNode(null, head, head);
head.prev = head;
head.next = head;
si.
I need help implementing a Stack with this java programming assignme.pdf
I need help implementing a Stack with this java programming assignment:
Given a doubly linked list (code provided below) implement a Stack. You must use the doubly
link list class and utilize it as an object in your implementation of the stack.
A Stack is a Last in First Out (LiFO) structure which translates to the processes of outputting the
last element which was inputted in the collection. The Stack is based on the process of putting
things on top of one another and taking the item on top (think of a stack of papers).
Operations to implement:
push (E): Add an element to the start of the sequence
pop: Remove an element from the start of the sequence
Peek: Return the first element of the sequence without removing it
atIndex(x): Return the element at the given index (x) Or throw an exception if it is out of bound
(if you can control the user input then do that instead)
Size: Return the size of the Stack
isEmpty: Boolean, returns true if the Stack is empty
Empty: Empty the Stack
Code Part 1:
public class DoublyLinkedList{
private DNode head;
private DNode tail;
private int size;
public DoublyLinkedList(){ // construct an empty list
this.tail = new DNode (null, null, this.head);
this.head = new DNode (null, this.tail, null);
this.size = 0;
}
public DoublyLinkedList(DNode next){ // constructs a list
// out of a single node
this.tail = new DNode (null, null, next);
this.head = new DNode (null, next, null);
next.changeNext(this.tail);
next.changePrev(this.head);
this.size = 1;
}
public DoublyLinkedList(Object [] objectArray){ // construct a list out of
// an array
this.tail = new DNode (null, null, this.head);
this.head = new DNode (null, this.tail, null);
DNode temp = this.head;
for (Object e : objectArray)
{
//Anonomus function
new DNode (e, temp.getNext(),temp).insertBetweenNodes(temp, temp.getNext());
temp = temp.getNext();
this.size += 1;
}
}
public void addToFrontofList(Object toAdd){ // Appends the begining
// of the list
DNode temp = new DNode (toAdd, this.head.getNext(), this.head);
this.head.getNext().changePrev(temp);
this.head.changeNext(temp);
this.size += 1;
}
public void addToendofList (Object toAdd) // appends the end of the list
// with a node
{
DNode temp = new DNode (toAdd, this.tail, this.tail.getPrev());
this.tail.getPrev().changeNext(temp);
this.tail.changePrev(temp);
this.size += 1;
}
public void insertAfterNode(DNode current, Object input)// Inserts a new
// a new node after
// current node
{
current.insertAfterNode(input);
this.size += 1;
}
public int getSize() // returns the size of the list
{
return this.size;
}
public String toString()
{
String result = \"\";
for (DNode temp = this.head.getNext();
temp.hasNext(); temp = temp.getNext())
{
result += temp.getValue();
result += \" -> \";
}
result += \"End of list\";
return result;
}
}
and code part2:
public class DNode{
private Object e; // place holder for the type of object the
//collection is storing
private DNode next; // reference to the next node in the sequence
// of.
A linked stack is implemented using a standard Node class as follows.pdf
A linked stack is implemented using a standard Node class as follows: import java.util.*; class
stack implements Iterable {private Node top; private int size; public stack () {top = null; size =
0;} public Object pop() {if (size == 0) throw new RuntimeException (\"\"); Object answer =
top.getData (); top = top.getNext (); Size --; return answer;} public void push (Object x) {Node
newNode = new Node (x top); top = newNode; size++;}//the iterator method is missing} Write a
class StackIterator to implement objects that can be returned by the stack iterator. Also write the
missing stack method called iterator. You can decide whether the iterator will run through the
data in the stack in LIFO or FIFO order (one choice is much easier).
Solution
Hi,
Pease find the program below:
import java.util.*;
import java.lang.Iterable;
@SuppressWarnings(\"rawtypes\")
public class LinkedStack implements Iterable{
private int n; // size of the stack
private Node first; // top of stack
// Helper linked list class
private class Node {
private Object item;
private Node next;
}
/**
* Initializes an empty stack.
*/
public LinkedStack() {
first = null;
n = 0;
}
/**
* Is this stack empty?
* @return true if this stack is empty; false otherwise
*/
public boolean isEmpty() {
return first == null;
}
/**
* Returns the number of items in the stack.
*/
public int size() {
return n;
}
/**
* Adds the item to this stack.
*/
public void push(Object item) {
Node oldfirst = first;
first = new Node();
first.item = item;
first.next = oldfirst;
n++;
}
/**
* Removes and returns the item most recently added to this stack.
* @return the item most recently added
*/
public Object pop() {
if (isEmpty()) throw new NoSuchElementException(\"Stack underflow\");
Object item = first.item; // save item to return
first = first.next; // delete first node
n--; //decreases the size by 1
return item; // return the saved item
}
/**
* Returns (but does not remove) the item most recently added to this stack.
* @return the item most recently added to this stack
*/
public Object peek() {
if (isEmpty()) throw new NoSuchElementException(\"Stack underflow\");
return first.item;
}
/**
* Returns an iterator to this stack that iterates through the items in LIFO order.
*/
public Iterator iterator() {
return new ListIterator();
}
// an iterator, doesn\'t implement remove() since it\'s optional
private class ListIterator implements Iterator {
private int i = n;
private Node first1 = first; //the first node
public boolean hasNext()
{
return (i > 0);
}
public Object next()
{
Object item = first1.item;
first1 = first1.next;
i--;
return item;
}
public void remove()
{
// not needed as this is optional
}
}
//Main method to implement the test
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
/* Creating object of class linkedStack */
LinkedStack ls = new LinkedStack();
/* Perform Stack Operations */
System.out.println(\"Linked Stack Test\ \");
char ch;
do
{
System.out.println(\"\ Linked Stack .
JAVA A double-ended queue is a list that allows the addition and.pdf
**JAVA** A double-ended queue is a list that allows the addition and removal of items from
either end. One end is arbitrarily called the front and other the rear, but the two ends behave
identically. Specify, design and implement a class for a double-ended queue. Include operations
to check if it is empty and to return the number of items in the list. For each end, include
operations for adding and deleting items. Use doubly linked list for your implementation. Call
your class Deque (pronounced \"deck\").
Solution
//package com.java2novice.ds.queue;
public class DequeDblLinkedListImpl {
private LinkedNode front;
private LinkedNode rear;
public void insertFront(T item){
//add element at the beginning of the queue
System.out.println(\"adding at front: \"+item);
LinkedNode nd = new LinkedNode();
nd.setValue(item);
nd.setNext(front);
if(front != null) front.setPrev(nd);
if(front == null) rear = nd;
front = nd;
}
public void insertRear(T item){
//add element at the end of the queue
System.out.println(\"adding at rear: \"+item);
LinkedNode nd = new LinkedNode();
nd.setValue(item);
nd.setPrev(rear);
if(rear != null) rear.setNext(nd);
if(rear == null) front = nd;
rear = nd;
}
public void removeFront(){
if(front == null){
System.out.println(\"Deque underflow!! unable to remove.\");
return;
}
//remove an item from the beginning of the queue
LinkedNode tmpFront = front.getNext();
if(tmpFront != null) tmpFront.setPrev(null);
if(tmpFront == null) rear = null;
System.out.println(\"removed from front: \"+front.getValue());
front = tmpFront;
}
public int size(){
if(front == null && rear ==null){
return 0;
}
//remove an item from the beginning of the queue
LinkedNode tmpFront = front;
LinkedNode tmpRear = rear;
int i=0;
while(tmpFront != rear)
{
i++;
tmpFront=tmpFront.getNext();
}
i++;
return i;
}
public void removeRear(){
if(rear == null){
System.out.println(\"Deque underflow!! unable to remove.\");
return;
}
//remove an item from the beginning of the queue
LinkedNode tmpRear = rear.getPrev();
if(tmpRear != null) tmpRear.setNext(null);
if(tmpRear == null) front = null;
System.out.println(\"removed from rear: \"+rear.getValue());
rear = tmpRear;
}
public static void main(String a[]){
DequeDblLinkedListImpl deque = new DequeDblLinkedListImpl();
deque.insertFront(34);
deque.insertFront(67);
System.out.println(\"Size of the queue : \"+deque.size());
deque.insertFront(29);
deque.insertFront(765);
deque.removeFront();
deque.removeFront();
deque.removeFront();
deque.insertRear(43);
deque.insertRear(83);
deque.insertRear(84);
deque.insertRear(546);
deque.insertRear(356);
deque.removeRear();
deque.removeRear();
deque.removeRear();
deque.removeRear();
deque.removeFront();
deque.removeFront();
deque.removeFront();
}
}
class LinkedNode{
private LinkedNode prev;
private LinkedNode next;
private T value;
public LinkedNode getPrev() {
return prev;
}
public void setPrev(LinkedNode prev) {
this.prev = prev;
}
public LinkedNode getNext() {
return next;
}
public void setNext(L.
Please write in C++ and should be able to compile and debug.Thank yo.pdf
Please write in C++ and should be able to compile and debug.Thank you
Create a class called BinaryTreeDeque. This binary tree implements all of the functionality of
the BinaryTree class, but instead of storing its values in a tree structure, the element values are
stored in a deque, using pointers to maintain the relationship between the binary tree and its node
values. Additionally: deque * getValues() - returns a copy of the deque the current array of
values (which should be in insertion order).
Solution
Following are steps to insert a new node in Complete Binary Tree.
1. If the tree is empty, initialize the root with new node.
2. Else, get the front node of the queue.
…….If the left child of this front node doesn’t exist, set the left child as the new node.
…….else if the right child of this front node doesn’t exist, set the right child as the new node.
3. If the front node has both the left child and right child, Dequeue() it.
4. Enqueue() the new node.
Code :-
-------------------------
binarytreedequeue.h
#ifndef BINARYTREEDEQUE_H
#define BINARYTREEDEQUE_H
// Program for linked implementation of complete binary tree
#include
#include
// For Queue Size
#define SIZE 50
// A tree node
struct node
{
int data;
struct node *right,*left;
};
// A queue node
struct Queue
{
int front, rear;
int size;
struct node* *array;
};
class BinaryTreeDeque
{
public:
BinaryTreeDeque();
struct node* newNode(int data);
struct Queue* createQueue(int size);
int isEmpty(struct Queue* queue);
int isFull(struct Queue* queue);
int hasOnlyOneItem(struct Queue* queue);
void Enqueue(struct node *root, struct Queue* queue);
struct node* Dequeue(struct Queue* queue);
struct node* getFront(struct Queue* queue);
int hasBothChild(struct node* temp);
void insert(struct node **root, int data, struct Queue* queue);
void display(struct Queue* queue);
node * getValues(struct Queue* queue);
};
#endif // BINARYTREEDEQUE_H
binarydequeue.cpp
---------------------------------------
#include \"binarytreedeque.h\"
BinaryTreeDeque::BinaryTreeDeque()
{
}
// A utility function to create a new tree node
struct node* BinaryTreeDeque::newNode(int data)
{
struct node* temp = (struct node*) malloc(sizeof( struct node ));
temp->data = data;
temp->left = temp->right = NULL;
return temp;
}
// A utility function to create a new Queue
struct Queue* BinaryTreeDeque::createQueue(int size)
{
struct Queue* queue = (struct Queue*) malloc(sizeof( struct Queue ));
queue->front = queue->rear = -1;
queue->size = size;
queue->array = (struct node**) malloc(queue->size * sizeof( struct node* ));
int i;
for (i = 0; i < size; ++i)
queue->array[i] = NULL;
return queue;
}
// Standard Queue Functions
int BinaryTreeDeque::isEmpty(struct Queue* queue)
{
return queue->front == -1;
}
int BinaryTreeDeque::isFull(struct Queue* queue)
{ return queue->rear == queue->size - 1; }
int BinaryTreeDeque::hasOnlyOneItem(struct Queue* queue)
{ return queue->front == queue->rear; }
void BinaryTreeDeque::Enqueue(struct node *root, s.
Recommended
Java Foundations StackADT-java --- - Defines the interface to a stack.docx
Java Foundations
StackADT.java
/**
* Defines the interface to a stack collection.
*
* @author Java Foundations
* @version 4.0
*/
public interface StackADT<T> {
/**
* Adds the specified element to the top of this stack.
*
* @param element element to be pushed onto the stack
*/
public void push(T element);
/**
* Removes and returns the top element from this stack.
*
* @return the element removed from the stack
* @throws EmptyCollectionException if the stack is empty
*/
public T pop();
/**
* Returns the top element of this stack without removing it from the stack.
*
* @return the element on top of the stack. It is not removed from the stack
* @throws EmptyCollectionException if the stack is empty
*/
public T peek();
/**
* Returns true if this stack contains no elements.
*
* @return true if the stack is empty, false if the stack is not empty
*/
public boolean isEmpty();
/**
* Returns the number of elements in this stack.
*
* @return the number of elements in the stack
*/
public int size();
}
QueueADT.java
/**
* QueueADT defines the interface to a queue collection.
*
* @author Java Foundation
* @version 4.0
*/
public interface QueueADT<T> {
/**
* Adds one element to the rear of this queue.
*
* @param element the element to be added to the rear of the queue
*/
public void enqueue(T element);
/**
* Removes and returns the element at the front of this queue.
*
* @return the element at the front of the queue
* @throws EmptyCollectionException if the queue is empty
*/
public T dequeue();
/**
* Returns without removing the element at the front of this queue.
*
* @return the first element in the queue
* @throws EmptyCollectionException if the queue is empty
*/
public T first();
/**
* Returns true if this queue contains no elements.
*
* @return true if the queue is empty, false if the queue is not empty
*/
public boolean isEmpty();
/**
* Returns the number of elements in this queue.
*
* @return the number of elements in the queue
*/
public int size();
}
LinkedDeque.java
public class LinkedDeque<T> implements QueueADT<T>, StackADT<T>, DequeADT<T> {
// inner class for a double linked list node
private class DNode<T> {
private T element;
private DNode<T> prev, next;
}
// data fields for the LinkedDeque class
private DNode<T> front, rear;
private int size;
// deque interface methods
@Override
public void addFirst(T element) {
// create a new node and set it up
DNode<T> newNode = new DNode<T>();
newNode.element = element; // from param to new node obj
newNode.prev = newNode.next = null;
if(this.isEmpty()) {
// we are making the only node in the deque
this.rear = this.front = newNode;
} else {
// there already exists a new node
// so, put the new node before the front node
newNode.next = this.front;
this.front.prev = newNode;
this.front = newNode;
}
this.size++;
}
@Override
public T removeFirst() {
T grabbedElt = this.getFirst(); // checks for empty for us
if.
So I have this code(StackInAllSocks) and I implemented the method but.pdf
So I have this code( StackInAllSocks ) and I implemented the method but I can't seem to figure
out why there isn't anything showing up on the console. It should pop,peek and push b using the
methods from the class called ArrayListTen . The ArrayListTen works fine and compiles the
tested code of Rigth# but for StackInAllSocks it doesn't complete at all. note that file
VodeDodeis not to be changed is just a Node storage area of the array list.
Did I implement the method on StackInAllSocks correctly? if so, should I not use the method
from the ArrayListTen .?
__________________________________________________________________________
: the code is : VodeDodeis
class VodeDode<T> {
private T data;
private VodeDode<T> next;
private VodeDode<T> prev;
public VodeDode(T data) {
this.data = data;
this.next = null;
this.prev = null;}
public T getData() {
return data;}
public void setData(T data) {
this.data = data;}
public VodeDode<T> getNext() {
return this.next;}
public void setNext(VodeDode<T> next) {
this.next = next;}
public VodeDode<T> getPrev() {
return this.prev;}
public void setPrev(VodeDode<T> prev) {
this.prev = prev;}
@Override
public String toString() {
return data.toString();}}
_________________________________________________________________________
CODE that works fine called ArrayListTen:
import java.util.Iterator;
public class ArrayListTen<T> implements Iterable<T> {
private VodeDode<T> head; //beginning of list
private VodeDode<T> tail; //end of list
private int size;
private VodeDode<T> new_item;
public ArrayListTen( ){
this.head = null;
this.tail = null;
this.size = 0;}
public int lenght() {
return size ;}
public T getBegin() {
if (this.head != null) {
return head.getData();}
else { return null;}}
public void addBegin(T value) {
VodeDode<T> newVodeDode =new VodeDode<T>(value);
if (this.head== null) {
head = newVodeDode;
tail =newVodeDode;}
else {VodeDode<T> temp = head;
head = newVodeDode;
head.setNext(temp);}
size++;}
public T removeBegin() {
if(this.head == null) {
return null;}
else {T current = head.getData();
if (tail == head) {
tail = null;
head = null;
} else {
head = head.getNext();
head.setPrev(null);}size--;
return current;}}
public T getEnd() {
if (tail != null) {
return tail.getData();
} else {
return null;}}
public void addEnd(T value) {
VodeDode<T> newVodeDode = new VodeDode<T>(value);
if (this.tail == null) {
head = newVodeDode;
tail = newVodeDode;
} else {
newVodeDode.setPrev(tail);
tail.setNext(newVodeDode);
tail = newVodeDode;}
size++;}
public T removeEnd() {
if(this.tail == null) {
return null;}
else {
T current = tail.getData();//was head.
if (head == tail) {
head = null;
tail = null;
} else {
tail = tail.getPrev();
tail.setNext(null);}
size--;
return current;}}
public T removeBN(T value) {
VodeDode<T> currVodeDode = head;
VodeDode<T> prevVodeDode = null;
while(currVodeDode != null){
if(currVodeDode.getData().equals(value)){
if(prevVodeDode != null){
prevVodeDode.setNext(currVodeDode.getNext());}
else{
head = curr.
Help please!!(Include your modified DList.java source code file in.pdf
Help please!!
(Include your modified DList.java source code file in your homework solution zip archive)
Using
whatever Java IDE you prefer, create a project and add DList.java and DListTest.java to it (these
files are provided
in the Week 6 Source zip archive). Modify DList to implement a method that removes all
occurrences of a specific
integer from the list. Here is the pseudocode:
Method removeAll(In: Integer pData) Returns Nothing
Define index variable i and initialize i to 0
While i < the size of this Dlist Do
If get(i) equals pData Then
remove(i)
Else
Increment i
End If
End While
End Method removeAll
Next, modify DListTest() to add test case 21 which tests that removeAll() works correctly.
WHat more do i need to provide to get help on this???
Solution
/* DListNode.java */
/**
* A DListNode is a node in a DList (doubly-linked list).
*/
class DListNode {
/**
* item references the item stored in the current node.
* prev references the previous node in the DList.
* next references the next node in the DList.
*
* DO NOT CHANGE THE FOLLOWING FIELD DECLARATIONS.
*/
public Object item;
protected DListNode prev;
protected DListNode next;
/**
* DListNode() constructor.
* @param i the item to store in the node.
* @param p the node previous to this node.
* @param n the node following this node.
*/
DListNode(Object i, DListNode p, DListNode n) {
item = i;
prev = p;
next = n;
}
}
/* DList.java */
/**
* A DList is a mutable doubly-linked list ADT. Its implementation is
* circularly-linked and employs a sentinel (dummy) node at the head
* of the list.
*
* DO NOT CHANGE ANY METHOD PROTOTYPES IN THIS FILE.
*/
class DList {
/**
* head references the sentinel node.
* size is the number of items in the list. (The sentinel node does not
* store an item.)
*
* DO NOT CHANGE THE FOLLOWING FIELD DECLARATIONS.
*/
protected DListNode head;
protected int size;
/* DList invariants:
* 1) head != null.
* 2) For any DListNode x in a DList, x.next != null.
* 3) For any DListNode x in a DList, x.prev != null.
* 4) For any DListNode x in a DList, if x.next == y, then y.prev == x.
* 5) For any DListNode x in a DList, if x.prev == y, then y.next == x.
* 6) size is the number of DListNodes, NOT COUNTING the sentinel,
* that can be accessed from the sentinel (head) by a sequence of
* \"next\" references.
*/
/**
* newNode() calls the DListNode constructor. Use this class to allocate
* new DListNodes rather than calling the DListNode constructor directly.
* That way, only this method needs to be overridden if a subclass of DList
* wants to use a different kind of node.
* @param item the item to store in the node.
* @param prev the node previous to this node.
* @param next the node following this node.
*/
protected DListNode newNode(Object item, DListNode prev, DListNode next) {
return new DListNode(item, prev, next);
}
/**
* DList() constructor for an empty DList.
*/
public DList() {
// Your solution here.
head = newNode(null, head, head);
head.prev = head;
head.next = head;
si.
I need help implementing a Stack with this java programming assignme.pdf
I need help implementing a Stack with this java programming assignment:
Given a doubly linked list (code provided below) implement a Stack. You must use the doubly
link list class and utilize it as an object in your implementation of the stack.
A Stack is a Last in First Out (LiFO) structure which translates to the processes of outputting the
last element which was inputted in the collection. The Stack is based on the process of putting
things on top of one another and taking the item on top (think of a stack of papers).
Operations to implement:
push (E): Add an element to the start of the sequence
pop: Remove an element from the start of the sequence
Peek: Return the first element of the sequence without removing it
atIndex(x): Return the element at the given index (x) Or throw an exception if it is out of bound
(if you can control the user input then do that instead)
Size: Return the size of the Stack
isEmpty: Boolean, returns true if the Stack is empty
Empty: Empty the Stack
Code Part 1:
public class DoublyLinkedList{
private DNode head;
private DNode tail;
private int size;
public DoublyLinkedList(){ // construct an empty list
this.tail = new DNode (null, null, this.head);
this.head = new DNode (null, this.tail, null);
this.size = 0;
}
public DoublyLinkedList(DNode next){ // constructs a list
// out of a single node
this.tail = new DNode (null, null, next);
this.head = new DNode (null, next, null);
next.changeNext(this.tail);
next.changePrev(this.head);
this.size = 1;
}
public DoublyLinkedList(Object [] objectArray){ // construct a list out of
// an array
this.tail = new DNode (null, null, this.head);
this.head = new DNode (null, this.tail, null);
DNode temp = this.head;
for (Object e : objectArray)
{
//Anonomus function
new DNode (e, temp.getNext(),temp).insertBetweenNodes(temp, temp.getNext());
temp = temp.getNext();
this.size += 1;
}
}
public void addToFrontofList(Object toAdd){ // Appends the begining
// of the list
DNode temp = new DNode (toAdd, this.head.getNext(), this.head);
this.head.getNext().changePrev(temp);
this.head.changeNext(temp);
this.size += 1;
}
public void addToendofList (Object toAdd) // appends the end of the list
// with a node
{
DNode temp = new DNode (toAdd, this.tail, this.tail.getPrev());
this.tail.getPrev().changeNext(temp);
this.tail.changePrev(temp);
this.size += 1;
}
public void insertAfterNode(DNode current, Object input)// Inserts a new
// a new node after
// current node
{
current.insertAfterNode(input);
this.size += 1;
}
public int getSize() // returns the size of the list
{
return this.size;
}
public String toString()
{
String result = \"\";
for (DNode temp = this.head.getNext();
temp.hasNext(); temp = temp.getNext())
{
result += temp.getValue();
result += \" -> \";
}
result += \"End of list\";
return result;
}
}
and code part2:
public class DNode{
private Object e; // place holder for the type of object the
//collection is storing
private DNode next; // reference to the next node in the sequence
// of.
A linked stack is implemented using a standard Node class as follows.pdf
A linked stack is implemented using a standard Node class as follows: import java.util.*; class
stack implements Iterable {private Node top; private int size; public stack () {top = null; size =
0;} public Object pop() {if (size == 0) throw new RuntimeException (\"\"); Object answer =
top.getData (); top = top.getNext (); Size --; return answer;} public void push (Object x) {Node
newNode = new Node (x top); top = newNode; size++;}//the iterator method is missing} Write a
class StackIterator to implement objects that can be returned by the stack iterator. Also write the
missing stack method called iterator. You can decide whether the iterator will run through the
data in the stack in LIFO or FIFO order (one choice is much easier).
Solution
Hi,
Pease find the program below:
import java.util.*;
import java.lang.Iterable;
@SuppressWarnings(\"rawtypes\")
public class LinkedStack implements Iterable{
private int n; // size of the stack
private Node first; // top of stack
// Helper linked list class
private class Node {
private Object item;
private Node next;
}
/**
* Initializes an empty stack.
*/
public LinkedStack() {
first = null;
n = 0;
}
/**
* Is this stack empty?
* @return true if this stack is empty; false otherwise
*/
public boolean isEmpty() {
return first == null;
}
/**
* Returns the number of items in the stack.
*/
public int size() {
return n;
}
/**
* Adds the item to this stack.
*/
public void push(Object item) {
Node oldfirst = first;
first = new Node();
first.item = item;
first.next = oldfirst;
n++;
}
/**
* Removes and returns the item most recently added to this stack.
* @return the item most recently added
*/
public Object pop() {
if (isEmpty()) throw new NoSuchElementException(\"Stack underflow\");
Object item = first.item; // save item to return
first = first.next; // delete first node
n--; //decreases the size by 1
return item; // return the saved item
}
/**
* Returns (but does not remove) the item most recently added to this stack.
* @return the item most recently added to this stack
*/
public Object peek() {
if (isEmpty()) throw new NoSuchElementException(\"Stack underflow\");
return first.item;
}
/**
* Returns an iterator to this stack that iterates through the items in LIFO order.
*/
public Iterator iterator() {
return new ListIterator();
}
// an iterator, doesn\'t implement remove() since it\'s optional
private class ListIterator implements Iterator {
private int i = n;
private Node first1 = first; //the first node
public boolean hasNext()
{
return (i > 0);
}
public Object next()
{
Object item = first1.item;
first1 = first1.next;
i--;
return item;
}
public void remove()
{
// not needed as this is optional
}
}
//Main method to implement the test
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
/* Creating object of class linkedStack */
LinkedStack ls = new LinkedStack();
/* Perform Stack Operations */
System.out.println(\"Linked Stack Test\ \");
char ch;
do
{
System.out.println(\"\ Linked Stack .
JAVA A double-ended queue is a list that allows the addition and.pdf
**JAVA** A double-ended queue is a list that allows the addition and removal of items from
either end. One end is arbitrarily called the front and other the rear, but the two ends behave
identically. Specify, design and implement a class for a double-ended queue. Include operations
to check if it is empty and to return the number of items in the list. For each end, include
operations for adding and deleting items. Use doubly linked list for your implementation. Call
your class Deque (pronounced \"deck\").
Solution
//package com.java2novice.ds.queue;
public class DequeDblLinkedListImpl {
private LinkedNode front;
private LinkedNode rear;
public void insertFront(T item){
//add element at the beginning of the queue
System.out.println(\"adding at front: \"+item);
LinkedNode nd = new LinkedNode();
nd.setValue(item);
nd.setNext(front);
if(front != null) front.setPrev(nd);
if(front == null) rear = nd;
front = nd;
}
public void insertRear(T item){
//add element at the end of the queue
System.out.println(\"adding at rear: \"+item);
LinkedNode nd = new LinkedNode();
nd.setValue(item);
nd.setPrev(rear);
if(rear != null) rear.setNext(nd);
if(rear == null) front = nd;
rear = nd;
}
public void removeFront(){
if(front == null){
System.out.println(\"Deque underflow!! unable to remove.\");
return;
}
//remove an item from the beginning of the queue
LinkedNode tmpFront = front.getNext();
if(tmpFront != null) tmpFront.setPrev(null);
if(tmpFront == null) rear = null;
System.out.println(\"removed from front: \"+front.getValue());
front = tmpFront;
}
public int size(){
if(front == null && rear ==null){
return 0;
}
//remove an item from the beginning of the queue
LinkedNode tmpFront = front;
LinkedNode tmpRear = rear;
int i=0;
while(tmpFront != rear)
{
i++;
tmpFront=tmpFront.getNext();
}
i++;
return i;
}
public void removeRear(){
if(rear == null){
System.out.println(\"Deque underflow!! unable to remove.\");
return;
}
//remove an item from the beginning of the queue
LinkedNode tmpRear = rear.getPrev();
if(tmpRear != null) tmpRear.setNext(null);
if(tmpRear == null) front = null;
System.out.println(\"removed from rear: \"+rear.getValue());
rear = tmpRear;
}
public static void main(String a[]){
DequeDblLinkedListImpl deque = new DequeDblLinkedListImpl();
deque.insertFront(34);
deque.insertFront(67);
System.out.println(\"Size of the queue : \"+deque.size());
deque.insertFront(29);
deque.insertFront(765);
deque.removeFront();
deque.removeFront();
deque.removeFront();
deque.insertRear(43);
deque.insertRear(83);
deque.insertRear(84);
deque.insertRear(546);
deque.insertRear(356);
deque.removeRear();
deque.removeRear();
deque.removeRear();
deque.removeRear();
deque.removeFront();
deque.removeFront();
deque.removeFront();
}
}
class LinkedNode{
private LinkedNode prev;
private LinkedNode next;
private T value;
public LinkedNode getPrev() {
return prev;
}
public void setPrev(LinkedNode prev) {
this.prev = prev;
}
public LinkedNode getNext() {
return next;
}
public void setNext(L.
Please write in C++ and should be able to compile and debug.Thank yo.pdf
Please write in C++ and should be able to compile and debug.Thank you
Create a class called BinaryTreeDeque. This binary tree implements all of the functionality of
the BinaryTree class, but instead of storing its values in a tree structure, the element values are
stored in a deque, using pointers to maintain the relationship between the binary tree and its node
values. Additionally: deque * getValues() - returns a copy of the deque the current array of
values (which should be in insertion order).
Solution
Following are steps to insert a new node in Complete Binary Tree.
1. If the tree is empty, initialize the root with new node.
2. Else, get the front node of the queue.
…….If the left child of this front node doesn’t exist, set the left child as the new node.
…….else if the right child of this front node doesn’t exist, set the right child as the new node.
3. If the front node has both the left child and right child, Dequeue() it.
4. Enqueue() the new node.
Code :-
-------------------------
binarytreedequeue.h
#ifndef BINARYTREEDEQUE_H
#define BINARYTREEDEQUE_H
// Program for linked implementation of complete binary tree
#include
#include
// For Queue Size
#define SIZE 50
// A tree node
struct node
{
int data;
struct node *right,*left;
};
// A queue node
struct Queue
{
int front, rear;
int size;
struct node* *array;
};
class BinaryTreeDeque
{
public:
BinaryTreeDeque();
struct node* newNode(int data);
struct Queue* createQueue(int size);
int isEmpty(struct Queue* queue);
int isFull(struct Queue* queue);
int hasOnlyOneItem(struct Queue* queue);
void Enqueue(struct node *root, struct Queue* queue);
struct node* Dequeue(struct Queue* queue);
struct node* getFront(struct Queue* queue);
int hasBothChild(struct node* temp);
void insert(struct node **root, int data, struct Queue* queue);
void display(struct Queue* queue);
node * getValues(struct Queue* queue);
};
#endif // BINARYTREEDEQUE_H
binarydequeue.cpp
---------------------------------------
#include \"binarytreedeque.h\"
BinaryTreeDeque::BinaryTreeDeque()
{
}
// A utility function to create a new tree node
struct node* BinaryTreeDeque::newNode(int data)
{
struct node* temp = (struct node*) malloc(sizeof( struct node ));
temp->data = data;
temp->left = temp->right = NULL;
return temp;
}
// A utility function to create a new Queue
struct Queue* BinaryTreeDeque::createQueue(int size)
{
struct Queue* queue = (struct Queue*) malloc(sizeof( struct Queue ));
queue->front = queue->rear = -1;
queue->size = size;
queue->array = (struct node**) malloc(queue->size * sizeof( struct node* ));
int i;
for (i = 0; i < size; ++i)
queue->array[i] = NULL;
return queue;
}
// Standard Queue Functions
int BinaryTreeDeque::isEmpty(struct Queue* queue)
{
return queue->front == -1;
}
int BinaryTreeDeque::isFull(struct Queue* queue)
{ return queue->rear == queue->size - 1; }
int BinaryTreeDeque::hasOnlyOneItem(struct Queue* queue)
{ return queue->front == queue->rear; }
void BinaryTreeDeque::Enqueue(struct node *root, s.
How do I fix it in LinkedList.javaLabProgram.javaLinkedList.jav.pdf
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.
package algs13;import stdlib.;import java.util.Iterator;im.docx
package algs13;
import stdlib.*;
import java.util.Iterator;
import java.util.NoSuchElementException;
/* ***********************************************************************
* Compilation: javac Queue.java
* Execution: java Queue < input.txt
* Data files: http://algs4.cs.princeton.edu/13stacks/tobe.txt
*
* A generic queue, implemented using a linked list.
*
* % java Queue < tobe.txt
* to be or not to be (2 left on queue)
*
*************************************************************************/
/**
* The <tt>Queue</tt> class represents a first-in-first-out (FIFO)
* queue of generic items.
* It supports the usual <em>enqueue</em> and <em>dequeue</em>
* operations, along with methods for peeking at the top item,
* testing if the queue is empty, and iterating through
* the items in FIFO order.
* <p>
* All queue operations except iteration are constant time.
* <p>
* For additional documentation, see <a href="http://algs4.cs.princeton.edu/13stacks">Section 1.3</a> of
* <i>Algorithms, 4th Edition</i> by Robert Sedgewick and Kevin Wayne.
*/
public class Queue<T> implements Iterable<T> {
private int N; // number of elements on queue
private Node<T> first; // beginning of queue
private Node<T> last; // end of queue
// helper linked list class
private static class Node<T> {
public Node() { }
public T item;
public Node<T> next;
}
/**
* Create an empty queue.
*/
public Queue() {
first = null;
last = null;
N = 0;
}
/**
* Is the queue empty?
*/
public boolean isEmpty() {
return first == null;
}
/**
* Return the number of items in the queue.
*/
public int size() {
return N;
}
/**
* Return the item least recently added to the queue.
* @throws java.util.NoSuchElementException if queue is empty.
*/
public T peek() {
if (isEmpty()) throw new NoSuchElementException("Queue underflow");
return first.item;
}
/**
* Add the item to the queue.
*/
public void enqueue(T item) {
Node<T> oldlast = last;
last = new Node<>();
last.item = item;
last.next = null;
if (isEmpty()) first = last;
else oldlast.next = last;
N++;
}
/**
* Remove and return the item on the queue least recently added.
* @throws java.util.NoSuchElementException if queue is empty.
*/
public T dequeue() {
if (isEmpty()) throw new NoSuchElementException("Queue underflow");
T item = first.item;
first = first.next;
N--;
if (isEmpty()) last = null;
return item;
}
/**
* Return string representation.
*/
public String toString() {
StringBuilder s = new StringBuilder();
for (T item : this)
s.append(item + " ");
return s.toString();
}
// check internal invariants
private static <T> boolean check(Queue<T> that) {
int N = that.N;
Queue.Node<T> first = that.first;
Queue.Node<T> last = that.last;
if (N == 0) {
if (first != null) return false;
if (last != null) return false;
}
else if (N == 1) {
if (f.
Given below is the completed implementation of MyLinkedList class. O.pdf
Given below is the completed implementation of MyLinkedList class. Other classes are not
modified and remain same as in question - MyList, MyAbstractList, TestMyLinkedList.
The output of TestMyLinkedList is shown below. Please don\'t forget to rate the answer if it
helped. Thank you very much.
Since the MyList is not completely pasted in the question ... giving the complete class file below
MyList.java
public interface MyList> extends java.lang.Iterable
{
// Add a new element at the end of this list
public void add (E e);
// Add a new element at specified index in this list
public void add (int index, E e);
// Return true if this list contains the element
public boolean contains (E e);
// Return the element at the specified index
public E get (int index);
// Return the index of the first matching element
// Return -1 if no match.
public int indexOf (E e);
// Return the index of the last matching element
// Return -1 if no match.
public int lastIndexOf (E e);
E remove(int index);
void clear();
E set(int index, E e);
}
MyLinkedList.java
public class MyLinkedList> extends MyAbstractList
implements Comparable>
{
private Node head, tail; // head and tail pointers
// Create a default list
public MyLinkedList()
{
}
public int size()
{
return size;
}
// Need this for implementing Comparable
public int compareTo (MyLinkedList e)
{
return(size() - e.size());
}
// Create a list from an array of objects
public MyLinkedList (E[] objects)
{
super(objects); // Passes the array up to abstract parent
}
// Return the head element in the list
public E getFirst()
{
if (size == 0)
{
return null;
}
else
{
return head.element;
}
}
// Return the last element in the list
public E getLast()
{
if (size == 0)
{
return null;
}
else
{
return tail.element;
}
}
// Add an element to the beginning of the list
public void addFirst (E e)
{
// Create a new node for element e
Node newNode = new Node(e);
newNode.next = head; // link the new node with the head
head = newNode; // head points to the new node
size++; // Increase list size
if (tail == null) // new node is only node
{
tail = head;
}
}
// Add an element to the end of the list
public void addLast (E e)
{
// Create a new node for element e
Node newNode = new Node(e);
if (tail == null)
{
head = tail = newNode; // new node is only node
}
else
{
tail.next = newNode; // Link the new with the last node
tail = tail.next; // tail now points to the last node
}
size++; // Increase size
}
// Remove the head node and
// return the object from the removed node
public E removeFirst()
{
if (size == 0)
{
return null;
}
else
{
Node temp = head;
head = head.next;
size--;
if (head == null)
{
tail = null;
}
return temp.element;
}
}
// Remove the last node and return the object from it
public E removeLast()
{
if (size == 0)
{
return null;
}
else if (size == 1)
{
Node temp = head;
head = tail = null;
size = 0;
return temp.element;
}
else
{
Node current = head;
for (int i = 0; i < size - 2; i++)
{
current = current.next;
}
Node temp = tail;
tai.
Add functions push(int n- Deque &dq) and pop(Deque &dq)- Functions pus.docx
Add functions push(int n, Deque &dq) and pop(Deque &dq).
Functions push(int n, Deque &dq) and pop(Deque &dq) should call functions of the Deque class to simulate a stack's push and pop functions.
The Deque class should not be touched . I will use the original unmodified Deque class when testing your code.
Demonstrate to convert a base 10 number to base 2. Ask the user to enter a base 10 number, output the equivalent base 2 number. The main() function would create a Deque object and pass it by reference when calling the new
push(int n, Deque &dq) and pop(Deque &dq) functions simulating stack operations.
keep it simple and to the instructions and code provided please! and thank you!
// C++ implementation of De-queue using circular
// array
#include<iostream>
using namespace std;
// Maximum size of array or Dequeue
#define MAX 100
// A structure to represent a Deque
class Deque
{
int arr[MAX];
int front;
int rear;
int size;
public :
Deque(int size)
{
front = -1;
rear = 0;
this->size = size;
}
// Operations on Deque:
void insertfront(int key);
void insertrear(int key);
void deletefront();
void deleterear();
bool isFull();
bool isEmpty();
int getFront();
int getRear();
};
// Checks whether Deque is full or not.
bool Deque::isFull()
{
return ((front == 0 && rear == size-1)||
front == rear+1);
}
// Checks whether Deque is empty or not.
bool Deque::isEmpty ()
{
return (front == -1);
}
// Inserts an element at front
void Deque::insertfront(int key)
{
// check whether Deque if full or not
if (isFull())
{
cout << "Overflow\n" << endl;
return;
}
// If queue is initially empty
if (front == -1)
{
front = 0;
rear = 0;
}
// front is at first position of queue
else if (front == 0)
front = size - 1 ;
else // decrement front end by '1'
front = front-1;
// insert current element into Deque
arr[front] = key ;
}
// function to inset element at rear end
// of Deque.
void Deque ::insertrear(int key)
{
if (isFull())
{
cout << " Overflow\n " << endl;
return;
}
// If queue is initially empty
if (front == -1)
{
front = 0;
rear = 0;
}
// rear is at last position of queue
else if (rear == size-1)
rear = 0;
// increment rear end by '1'
else
rear = rear+1;
// insert current element into Deque
arr[rear] = key ;
}
// Deletes element at front end of Deque
void Deque ::deletefront()
{
// check whether Deque is empty or not
if (isEmpty())
{
cout << "Queue Underflow\n" << endl;
return ;
}
// Deque has only one element
if (front == rear)
{
front = -1;
rear = -1;
}
else
// back to initial position
if (front == size -1)
front = 0;
else // increment front by '1' to remove current
// front value from Deque
front = front+1;
}
// Delete element at rear end of Deque
void Deque::deleterear()
{
if (isEmpty())
{
cout << " Underflow\n" << endl ;
return ;
}
// Deque has only one element
if (front == rear)
{
front = -1;
rear = -1;
}
else if (rear == 0)
rear = size-1;
else
rear = rear-1;
}
// Returns front element of Deque
int Deque::getFront()
{
// check whether Deque is empty or not
if (isEmp.
Given the following ADT definition of a stack to use stack .docx
Given the following ADT definition of a stack to use:
/** stack (base class)
* The basic definition of the Stack Abstract Data Type (ADT)
* and stack operations. All declared functions here are
* virtual, they must be implemented by concrete derived
* classes.
*/
template <class T>
class Stack
{
public:
/** clear
* Method to clear out or empty any items on stack,
* put stack back to empty state.
* Postcondition: Stack is empty.
*/
virtual void clear() = 0;
/** isEmpty
* Function to determine whether the stack is empty. Needed
* because it is undefined to pop from empty stack. This
* function will not change the state of the stack (const).
*
* @returns bool true if stack is empty, false otherwise.
*/
virtual bool isEmpty() const = 0;
/** push
* Add a new item onto top of stack.
*
* @param newItem The item of template type T to push on top of
* the current stack.
*/
virtual void push(const T& newItem) = 0;
/** top
* Return the top item from the stack. Note in this ADT, peeking
* at the top item does not remove the top item. Some ADT combine
* top() and pop() as one operation. It is undefined to try and
* peek at the top item of an empty stack. Derived classes should
* throw an exception if this is attempted.
*
* @returns T Returns the top item from stack.
*/
virtual T top() const = 0;
/** pop
* Remove the item from the top of the stack. It is undefined what
* it means to try and pop from an empty stack. Derived classes should
* throw an exception if pop() from empty is attempted.
*/
virtual void pop() = 0;
/** size
* Accessor method to provide the current size of the stack.
*
* @returns int The current size (number of items) on the stack.
*/
virtual int size() const = 0;
};
perform the following tasks by writing code that uses a stack to accomplish the task. You will
need to create a stack of the needed type, then use the methods of the stack abstraction (push,
top, pop, etc.) to solve the given task asked for.
Question 7 (5 points)
Given a stack of integers, calculate the sum of the integer values. Also, the stack should still be
unchanged after you have calculated the sum Hint: take the items off the stack to sum them up
and keep them on a second temporary stack so you can put them all back on after you have
calculated the sum.
ANSWER FOR NUMBER 7:
int sumStackOfIntegers(Stack<int> currentStack) {
Stack<int> tempStack;
int sum = 0;
while(!currentStack.isEmpty()) {
int temp = currentStack.top();
tempStack.push(temp);
currentStack.pop();
sum += temp;
}
while(!tempStack.isEmpty()) {
int temp = tempStack.top();
currentStack.push(temp);
tempStack.pop();
}
return sum;
}
Stack Implementation
Given the following linked list implementation of a Stack ADT (this is the same implementation
you used in Assignment 10), add the asked for additional member methods to the linked list stack
implementation.
/** Node
* A basic node contaning an item and a link to t ...
Hi, Please find my code.I have correted all of your classes.Plea.pdf
Hi, Please find my code.
I have correted all of your classes.
Please let me know in case if do not get concpt.
######## Node.java ###########
public class Node {
private E element;
private Node next;
public Node() {
this.element = null;
this.next = null;
}
public Node(E e) {
this.element = e;
this.next = null;
}
public E getElement() {
return this.element;
}
public void setElement(E element) {
this.element= element;
}
public Node getNext() {
return next;
}
public void setNext(Node next) {
this.next = next;
}
}
########## Stack.java #############
public class Stack {
private int N;
private Node top;
public Stack() {
N = 0;
this.top =null;
}
/*
* places element on the top of the stack
*/
public void push(E element){
Node temp = new Node(element);
temp.setNext(top);
top = temp;
N++;
}
/*
* remove the top node and return its contents
*/
public E pop(){
if(top == null)
return null;
E e = top.getElement();
top = top.getNext();
N--;
return e;
}
/*
* Look at the top element of the Stack and return it, without removing
*/
public E peek(){
if(top == null)
return null;
return top.getElement();
}
//returns the size of the stack
public int size(){
return N; //replace
}
public boolean isEmpty(){
return top==null;
}
}
############ Queue.java ############
public class Queue {
private Node front;
private Node back;
private int N;
public Queue() {
this.front = null;
this.back = null;
N = 0;
}
/*
* places element in the back of the Queue
*/
public void enqueue(E element){
Node temp = new Node(element);
if(front == null) {
front = temp;
back = temp;
}
else{
back.setNext(temp);
back = temp;
}
N++;
}
/*
* remove the front node of the queue and return it
*/
public E dequeue(){
if(front == null) {
return null;
}
E item = front.getElement();
front = front.getNext();
// if we had only one element
if(front == null){
back = null;
}
N--;
return item;
}
/*
* Look at the front of the queue and return it, without removing
*/
public E peek(){
if(back == null)
return null;
return back.getElement();
}
//returns the size of the queue
public int size(){
return N;
}
public boolean isEmpty(){
return front==null;
}
}
########### Palindrome.java ############
import java.util.Scanner;
public class Palindrome
{
public static void main(String[ ] args)
{
Scanner input = new Scanner(System.in);
String inputString;
System.out.print(\"Please enter your string: \");
inputString = input.next( );
if (isPalindrome( inputString )){
System.out.println(\"Yes it is a palindrome.\");
}
else{
System.out.println(\"No this is not a palindrome.\");
}
}
public static boolean isPalindrome(String input)
{
Queue q = new Queue ();
Stack s = new Stack ();
char letter;
int i;
for (i = 0; i < input.length( ); i++)
{
letter = input.charAt(i);
q.enqueue(letter);
s.push(letter);
}
while (!q.isEmpty( ))
{
if (q.dequeue() != s.pop( ))
return false;
}
return true;
}
}
/*
Sample Output:
Please enter your string: MadaM
Yes it is a palindrome.
*/
Solution
Hi, Please find my code.
I have correted all of your classes.
Pl.
EmptyCollectionException-java -- - Represents the situation in which.docx
EmptyCollectionException.java
/*
* Represents the situation in which a collection is empty.
*/
public class EmptyCollectionException extends RuntimeException
{
/* General class level objects */
/*
* Sets up this exception with an appropriate message.
* @param collection the name of the collection
*/
public EmptyCollectionException(String collection)
{
super("The " + collection + " is empty.");
}
}
PriorityNode.java
/*
* Represents a node in a linked list.
*/
public class PriorityNode<T>
{
/* General class level objects */
private PriorityNode<T> _next;
private T _element;
private int _priority;
private final int _MAX_PRIORITY = 100;
/*
* Creates an empty node with a given priority.
*/
public PriorityNode(T elem, int priority)
{
// TODO To be completed as a Programming Project
}
/*
* Creates a node storing the specified element with a default priority.
*
* @param elem element to be stored
*/
public PriorityNode(T elem)
{
// TODO To be completed as a Programming Project
}
/*
* Returns the node that follows this one.
*
* @return reference to next node
*/
public PriorityNode<T> getNext()
{
// TODO To be completed as a Programming Project
}
/*
* Sets the node that follows this one.
*
* @param node node to follow this one
*/
public void setNext(PriorityNode<T> node)
{
// TODO To be completed as a Programming Project
}
/*
* Returns the element stored in this node.
*
* @return element stored at the node
*/
public T getElement()
{
// TODO To be completed as a Programming Project
}
/*
* Returns the priority of this node.
*
* @return element priority the node
*/
public int getPriority()
{
// TODO To be completed as a Programming Project
}
/*
* Sets the element stored in this node.
*
* @param elem element to be stored at this node
*/
public void setElement(T elem)
{
// TODO To be completed as a Programming Project
}
/*
* optional toString() override.
*/
//public String toString()
//{
// // TODO To be completed as a Programming Project
//}
}
PriorityQueue.java
/*
* LinkedQueue represents a linked implementation of a queue.
*/
public class PriorityQueue<T> implements PriorityQueueADT<T>
{
/* General class level objects */
private int _count;
private PriorityNode<T> _head, _tail;
/*
* Constructor - Creates an empty queue.
*/
public PriorityQueue()
{
_count = 0;
_head = _tail = null;
}
/*
* Adds one element to the rear of this queue.
* Higher priorities are inserted closer to the front of the queue
* Items with the same priority are processed in normal queue order
*
* @param element the element to be added to the rear of the queue
* @param priority relative priority of the queue item
*/
public void enqueue(T element, int priority)
{
// TODO To be completed as a Programming Project
// add in-order insertion of the PriorityNode based on getPriority() value
// the higher the priority is the closer to head it gets
// equivalent priority is normal .
public class DoubleArraySeq implements Cloneable { Priva.pdf
public class DoubleArraySeq implements Cloneable
{
// Private Instance Variables
private double[] data;
private int manyItems;
private int currentIndex;
//Constructor Methods
/**
* Initialize an empty sequence with an initial capacity of 10.
**/
public DoubleArraySeq()
{
try{
//Set a default capacity for new DoubleArraySeq\'s.
int INITAL_CAPACITY = 10;
//Set each instance variable to its initial value.
data = new double[INITAL_CAPACITY];
manyItems = 0;
currentIndex = 0;
}//end try
catch (OutOfMemoryError e){
throw new OutOfMemoryError (\"There is not enough memory to create a new
sequence!\");
}//end catch
}//end DoubleArraySeq() method
/**
* Initialize an empty sequence with a specified initial capacity. Note that the addAfter and
addBefore methods work
* efficiently (without needing more memory) until this capacity is reached.
**/
public DoubleArraySeq(int initialCapacity)
{
try{
//Set each instance variable to its initial value.
data = new double[initialCapacity];
currentIndex = 0;
manyItems = 0;
}//end try
catch (OutOfMemoryError e){
throw new OutOfMemoryError (\"There is not enough memory to create a new sequence
of capacity \" + initialCapacity + \"!\");
}//end catch
}//end DoubleArraySeq(int initialCapacity) method
// Accessor Methods
/**
**/
public boolean isCurrent()
{
return (currentIndex < manyItems);
}//end isCurrent() method
/**
* Accessor method to get the current element of this sequence.
**/
public double getCurrent()
{
//Confirm that there is a current element first.
if (isCurrent())
return data[currentIndex];
else
throw new IllegalStateException(\"There is no current element! Please specify a current
element first.\");
}//end getCurrent() method
/**
* Accessor method to get the current capacity of this sequence.
**/
public int getCapacity()
{
//Returns the number of indexes in the array.
return data.length;
}//end getCapacity() method
/**
* Accessor method to get the available capacity (number of empty indexes) of this sequence.
* The available capacity (number of empty indexes) of this sequence.
**/
public int getAvailCapacity()
{
//Returns the number of empty indexes in the array.
return data.length - manyItems;
}//end getAvailCapacity() method
/**
**/
public int size()
{
//Returns the number of elements in the sequence.
return manyItems;
}//end size() method
// Setter Methods
/**
* A method to move forward, so the current element is now the next element in this sequence.
**/
public void advance()
{
if (isCurrent())
currentIndex++;
else
throw new IllegalStateException (\"There is no current element! Advance may not be
called.\");
}//end advance() method
/**
* A method to set the current element at the front of this sequence.
**/
public void start()
{
if (manyItems > 0)
currentIndex = 0;
else
throw new IllegalStateException(\"This sequence is empty!\");
}//end start() method
/**
* A method that makes the last element of the sequence the current element.
**/
public void setCurrentLast()
{
if (manyItems > 0)
currentIndex = ma.
Please review my code (java)Someone helped me with it but i cannot.pdf
Please make it to clear 12-95. The basketball passed through the hoop even though it barely
cleared the hands of the player B who attempted to block it. Neglecting the size of the ball,
determine the magnitude vn of its initial velocity and the height h of the ball when it passes over
player B 10 ft 5 ft Prob. 12-95
Solution
Consider the motion along horizontal direction
Vox = initial velocity in horizontal direction = Va Cos30
X = horizontal distance = 25 + 3 = 28 ft
t = time taken
t = X / Vox = 28/(Va Cos30) eq-1
consider the motion in vertical direction
Y = vertical displacement = 10 - 7 = 3 ft
a = acceleration = - 32.2
Voy = initial velocity = Va Sin30
t = time taken
using the equation
Y = Voy t + (0.5) a t2
3 = (Va Sin30) (28/(Va Cos30)) + (0.5) (- 32.2) (28/(Va Cos30))2
Va = 35.8 m/s
t\' = time taken to reach B = 25 / (Va Cos30) = 25 / (35.8 Cos30) = 0.81 sec
h = 7 + Voy t\' + (0.5) a t\'2
h = 7 + (35.8 Sin30) (0.81) + (0.5) (- 32.2) (0.81)2
h = 10.94 ft.
I have a stack in Java populated with integers. Im trying to compa.pdf
I have a stack in Java populated with integers. I\'m trying to compare the elements in the stack to
determine which is the largest. Basically, I enter the element at the top of the stack into e then
pop each element off the stack and check to see if it is greater than the value stored in e. How can
I check to see if the next element in the stack is greater than the element stored in e?
E e = stk1.peek();
while(!stk1.empty())
{
if(stk1.peek() > e)
{
e=stk1.peek();
}
Solution
Using recursive approach we can sort the stack and the top element of stack would be the largest
integer.
Algorithm:
Sorting stack elements:
Inserting elements in sorted order:
Illustration:
First pop all the elements from the stack and store poped element in variable \'temp\'. After
poping all the elements function\'s stack frame will look like:
Now stack is empty and \'insert_in_sorted_order()\' function is called and it inserts 30 (from
stack frame #5) at the bottom of the stack. Now stack looks like below:
Now next element i.e. -5 (from stack frame #4) is picked. Since -5 < 30, -5 is inserted at the
bottom of stack. Now stack becomes:
Next 18 (from stack frame #3) is picked. Since 18 < 30, 18 is inserted below 30. Now stack
becomes:
Next 14 (from stack frame #2) is picked. Since 14 < 30 and 14 < 18, it is inserted below 18. Now
stack becomes:
Now -3 (from stack frame #1) is picked, as -3 < 30 and -3 < 18 and -3 < 14, it is inserted below
14. Now stack becomes:
Implementation:
/**
* Stack is represented using linked list
*/
public class Stack extends NativeClass {
private final IntContainer data = new IntContainer(this, 1);
private final Container> next = new Container>(this, 1){};
public int getData() {
return data.get();
}
public int setData(int newData) {
return data.set(newData);
}
public Container getNext() {
return next.get();
}
public Container setNext(Container newNext) {
return next.set(newNext);
}
public static Container nnc(Container orig) {
return Container.nnc(new TypeInfo>(){}, orig);
}
/**
* Utility function to initialize stack
*/
public static void initStack(Container[] s) {
s[0] = null;
}
/**
* Utility function to chcek if stack is empty
*/
public static int isEmpty(Stack[] s) {
if(s == null) {
return 1;
}
return 0;
}
/**
* Utility function to push an item to stack
*/
public static void push(Container[] s, int x) {
Container p = new Container(true, 1){};
p.get().setData(x);
p.get().setNext(s[0]);
s[0] = p;
}
/**
* Utility function to remove an item from stack
*/
public static int pop(Container[] s) {
int x;
Container temp;
x = s[0].get().getData();
temp = s[0];
s[0] = s[0].get().getNext();
nnc(temp).setNativeControlled(false);
return x;
}
/**
* Function to find top item
*/
public static int top(Stack[] s) {
return s[0].getData();
}
}
// Recursive function to insert an item x in sorted way
public static void sortedInsert(Container> s, int x) {
// Base case: Either stack is empty or newly inserted
// item is greater than top (more than all existing)
if(is.
AnswerNote Driver class is not given to test the DoubleArraySeq..pdf
Answer:
Note: Driver class is not given to test the DoubleArraySeq.java
Modified Code:
public class DoubleArraySeq implements Cloneable
{
// Invariant of the DoubleArraySeq class:
// 1. The number of elements in the sequences is in the instance variable
// manyItems.
// 2. For an empty sequence (with no elements), we do not care what is
// stored in any of data; for a non-empty sequence, the elements of the
// sequence are stored in data[0] through data[manyItems-1], and we
// don care what in the rest of data.
// 3. If there is a current element, then it lies in data[currentIndex];
// if there is no current element, then currentIndex equals manyItems.
private double[ ] data;
private int manyItems;
private int currentIndex;
/**
* Initialize an empty sequence with an initial capacity of 10. Note that
* the addAfter and addBefore methods work
* efficiently (without needing more memory) until this capacity is reached.
* @param - none
* @postcondition
* This sequence is empty and has an initial capacity of 10.
* @exception OutOfMemoryError
* Indicates insufficient memory for:
* new double[10].
**/
public DoubleArraySeq( )
{
//Set manyItems to 0.
manyItems=0;
//Initialize data
data=new double[10];
}
/**
* Initialize an empty sequence with a specified initial capacity. Note that
* the addAfter and addBefore methods work
* efficiently (without needing more memory) until this capacity is reached.
* @param initialCapacity
* the initial capacity of this sequence
* @precondition
* initialCapacity is non-negative.
* @postcondition
* This sequence is empty and has the given initial capacity.
* @exception IllegalArgumentException
* Indicates that initialCapacity is negative.
* @exception OutOfMemoryError
* Indicates insufficient memory for:
* new double[initialCapacity].
**/
public DoubleArraySeq(int initialCapacity)
{
//Check initialCapacity. If it is <0, throw EXCEPTION
if(initialCapacity < 0)
//Throw EXCEPTION
throw new IllegalArgumentException (\"initialCapacity IS NEGATIVE:\");
//Set manyItems to 0.
manyItems = 0;
try
{
data = new double[initialCapacity];
}
catch(OutOfMemoryError ea)
{
throw new RuntimeException
(\"NOT ENOUGH MEMORY\");
}
}
/**
* Add a new element to this sequence, after the current element.
* If the new element would take this sequence beyond its current capacity,
* then the capacity is increased before adding the new element.
* @param element
* the new element that is being added
* @postcondition
* A new copy of the element has been added to this sequence. If there was
* a current element, then the new element is placed after the current
* element. If there was no current element, then the new element is placed
* at the end of the sequence. In all cases, the new element becomes the
* new current element of this sequence.
* @exception OutOfMemoryError
* Indicates insufficient memory for increasing the sequence\'s capacity.
* @note
* An attempt to increase the capacity beyond
* Integer.MAX_VALUE will cause the sequence to fail with an.
In java , I want you to implement a Data Structure known as a Doubly.pdf
In java , I want you to implement a Data Structure known as a Doubly-Ended-Queue. it is a
“fair” data structure in that it implements a FIFO (First In First Out ) behavior. As such, it is
often used to implement various wait lists in computer systems. For example, jobs waiting to use
the CPU, jobs waiting for a printer, jobs waiting to be placed into RAM for execution. In short,
whenever we want a fair strategy for waiting we use queues.
A DEQUE (Doubly-ended-queue) is a related data structure. Although similar to a Queue, it
differs in that it allows for insertions AND deletions from either end of the list (both the front
and the rear).
Your implementation MUST use a doubly-linked-list implementation. You may not use a static
array implementation.
Thus, a Deque is a List but it is one which only concerns itself with the first and last positions for
any insertion or deletion. The 6 operations supported are :
public void insertFront( int item ) - insert the given item (as a node) into the first position of the
Deque.
public void insertRear( int item ) - insert the given item (as a node) into the last position of the
Deque.
public int deleteFront( ) - delete and return the element stored in the first node of the Deque.
public int deletRear( ) – delete and return the element stored in the last node of the Deque.
public boolean isempty( ) - returns true if the Deque is currently empty or false if it is not.
public void printDeque( ) - print the integers from the list, one per line, from the first element
through to the last in order.
Classes
Your program must implement the following 3 classes. public class dequeDriver
This class will contain your program’s main method. It will need to declare a deque object and
process input as indicated below.
Your program should prompt the user for the path of an input file. It should open the file for
input and process it line by line. Each line of the input file will have one of the following forms.
PR
IF
IR
DF
DR
The meanings of each input is as follows:
PR - print the current contents of the deque from front to rear using the printDeque( ) method of
the deque object.
IF - insert the given int value into the front of the deque.
IR - insert the given int value into the rear of the deque.
DF - delete the front value from the deque.
DR – delete the rear element of the deque.
Below is an example input file that your program should be able to process.
PR
IF 4
IF 5
IF 6
IR 7
PR
DR
PR
DF
PR
The output for the input file shown above is :
EMPTY DEQUE
----- Front -----
6
5
4
7
----- Rear -----
----- Front -----
6
5
4
----- Rear -----
----- Front -----
5
4
----- Rear -----
public class dequeNode
This class will implement the linked nodes that will be used to implement the deque itself.
It should have the following protected data members.
protected dequeNode next; // next pointer to next node
protected dequeNode prev; // previous pointer to previous node
protected int val; // the integer value stored within the dequeNod.
import java-util-Iterator- import java-util-NoSuchElementException- im.pdf
import java.util.Iterator;
import java.util.NoSuchElementException;
import lab4.util.List;
public class SinglyLinkedList<E> implements List<E> {
@SuppressWarnings("hiding")
private class SinglyLinkedListIterator<E> implements Iterator<E>{
private Node<E> nextNode;
@SuppressWarnings("unchecked")
public SinglyLinkedListIterator() {
this.nextNode = (Node<E>) header.getNext();
}
@Override
public boolean hasNext() {
return nextNode != null;
}
@Override
public E next() {
if (this.hasNext()) {
E result = this.nextNode.getElement();
this.nextNode = this.nextNode.getNext();
return result;
}
else {
throw new NoSuchElementException();
}
}
}
private static class Node<E> {
private E element;
private Node<E> next;
public Node(E element, Node<E> next) {
super();
this.element = element;
this.next = next;
}
public Node() {
super();
}
public E getElement() {
return element;
}
public void setElement(E element) {
this.element = element;
}
public Node<E> getNext() {
return next;
}
public void setNext(Node<E> next) {
this.next = next;
}
}
private Node<E> header;
private int currentSize;
public SinglyLinkedList() {
this.header = new Node<>();
this.currentSize = 0;
}
@Override
public int size() {
return this.currentSize;
}
@Override
public boolean isEmpty() {
return this.size() == 0;
}
@Override
public boolean contains(E e) {
return this.firstIndexOf(e) >= 0;
}
@Override
public int firstIndexOf(E e) {
int i = 0;
for (Node<E> temp = this.header.getNext(); temp != null;
temp = temp.getNext(), ++i) {
if (temp.getElement().equals(e)) {
return i;
}
}
// not found
return -1;
}
@Override
public void add(E e) {
if (this.isEmpty()) {
this.header.setNext(new Node<E>(e, null));
this.currentSize++;
}
else {
Node<E>temp= this.header.getNext();
while (temp.getNext() != null) {
temp = temp.getNext();
}
Node<E> newNode = new Node<>(e, null);
temp.setNext(newNode);
this.currentSize++;
}
}
@Override
public void add(E e, int index) {
if ((index < 0) || (index > this.currentSize)) {
throw new IndexOutOfBoundsException();
}
if (index == this.currentSize) {
this.add(e);
}
else {
Node<E> temp = null;
if (index == 0) {
temp = this.header;
}
else {
temp = this.getPosition(index -1);
}
Node<E> newNode = new Node<>();
newNode.setElement(e);
newNode.setNext(temp.getNext());
temp.setNext(newNode);
this.currentSize++;
}
}
@Override
public E get(int position) {
if ((position < 0) || position >= this.currentSize) {
throw new IndexOutOfBoundsException();
}
Node<E> temp = this.getPosition(position);
return temp.getElement();
}
private Node<E> getPosition(int index){
int currentPosition=0;
Node<E> temp = this.header.getNext();
while(currentPosition != index) {
temp = temp.getNext();
currentPosition++;
}
return temp;
}
@Override
public boolean remove(int index) {
if ((index < 0) || (index >= this.currentSize)){
throw new IndexOutOfBoundsException();
}
else {
Node<E> temp = this.header;
int currentPosition =0;
Node<E> target = null;
while (currentPosition != index) {
temp = temp.getNext();
currentPosit.
Hi,I have added the methods and main class as per your requirement.pdf
Hi,
I have added the methods and main class as per your requirement. it is working fine now.
Highlighted the code changes.
MyLinkedListTest.java
public class MyLinkedListTest {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
MyLinkedList list = new MyLinkedList();
list.addFirst(\"AAAAA\");
list.add(\"1\");
list.add(\"2\");
list.add(\"3\");
list.addLast(\"ZZZZZ\");
System.out.println(\"Linked List Elements : \"+list.toString());
System.out.println(\"First element: \"+list.getFirst());
System.out.println(\"Second element: \"+list.getLast());
System.out.println(\"Removed First Element: \"+list.removeFirst());
System.out.println(\"Now Linked List Elements : \"+list.toString());
System.out.println(\"Removed Last Element: \"+list.removeLast());
System.out.println(\"Now Linked List Elements : \"+list.toString());
System.out.println(\"Removed all element: \");
list.removeAll();
System.out.println(\"Now Linked List Elements : \"+list.toString());
}
}
MyLinkedList.java
public class MyLinkedList extends MyAbstractList {
private Node head, tail;
/** Create a default list */
public MyLinkedList() {
}
/** Create a list from an array of objects */
public MyLinkedList(E[] objects) {
super(objects);
}
/** Return the head element in the list */
public E getFirst() {
if (size == 0) {
return null;
}
else {
return (E)head.element;
}
}
/** Return the last element in the list */
public E getLast() {
if (size == 0) {
return null;
}
else {
return (E)tail.element;
}
}
/** Add an element to the beginning of the list */
public void addFirst(E e) {
Node newNode = new Node(e); // Create a new node
newNode.next = head; // link the new node with the head
head = newNode; // head points to the new node
size++; // Increase list size
if (tail == null) // the new node is the only node in list
tail = head;
}
/** Add an element to the end of the list */
public void addLast(E e) {
Node newNode = new Node(e); // Create a new for element e
if (tail == null) {
head = tail = newNode; // The new node is the only node in list
}
else {
tail.next = newNode; // Link the new with the last node
tail = tail.next; // tail now points to the last node
}
size++; // Increase size
}
/** Add a new element at the specified index in this list
* The index of the head element is 0 */
public void add(int index, E e) {
if (index == 0) {
addFirst(e);
}
else if (index >= size) {
addLast(e);
}
else {
Node current = head;
for (int i = 1; i < index; i++) {
current = current.next;
}
Node temp = current.next;
current.next = new Node(e);
(current.next).next = temp;
size++;
}
}
/** Remove the head node and
* return the object that is contained in the removed node. */
public E removeFirst() {
if (size == 0) {
return null;
}
else {
Node temp = head;
head = head.next;
size--;
if (head == null) {
tail = null;
}
return (E)temp.element;
}
}
/** Remove all elements from list */
public void removeAll() {
while(true) {
if (size == 0) {
break;
}
else {
Node temp = head;
head =.
For the code below complete the preOrder() method so that it perform.pdf
For the code below complete the preOrder() method so that it performs a preOrder traversal of
the tree. For each node it traverses, it should call sb.append() to add a \"[\" the results of
traversing the subtree rooted at that node, and then a \"]\". You should add a space before the
results of the left and right child traversals, but only if the node exists.
code:
Solution
In preorder Nodes visited are in the order of
code:
package edu.buffalo.cse116;
import java.util.AbstractSet;
import java.util.Iterator;
public class BinarySearchTree> extends AbstractSet {
protected Entry root;
protected int size;
/**
* Initializes this BinarySearchTree object to be empty, to contain only
* elements of type E, to be ordered by the Comparable interface, and to
* contain no duplicate elements.
*/
public BinarySearchTree() {
root = null;
size = 0;
}
/**
* Initializes this BinarySearchTree object to contain a shallow copy of a
* specified BinarySearchTree object. The worstTime(n) is O(n), where n is the
* number of elements in the specified BinarySearchTree object.
*
* @param otherTree - the specified BinarySearchTree object that this
* BinarySearchTree object will be assigned a shallow copy of.
*/
public BinarySearchTree(BinarySearchTree otherTree) {
root = copy(otherTree.root, null);
size = otherTree.size;
}
/* Method to complete is here! */
public void preOrder(Entry ent, StringBuilder sb) {
preorder(root)
protected Entry copy(Entry p, Entry parent) {
if (p != null) {
Entry q = new Entry(p.element, parent);
q.left = copy(p.left, q);
q.right = copy(p.right, q);
return q;
}
return null;
} // method copy
@SuppressWarnings(\"unchecked\")
@Override
public boolean equals(Object obj) {
if (!(obj instanceof BinarySearchTree)) {
return false;
}
return equals(root, ((BinarySearchTree) obj).root);
}
public boolean equals(Entry p, Entry q) {
if ((p == null) || (q == null)) {
return p == q;
}
if (!p.element.equals(q.element)) {
return false;
}
if (equals(p.left, q.left) && equals(p.right, q.right)) {
return true;
}
return false;
}
/**
* Returns the size of this BinarySearchTree object.
*
* @return the size of this BinarySearchTree object.
*/
@Override
public int size() {
return size;
}
/**
* Iterator method will be implemented for a future
*
* @return an iterator positioned at the smallest element in this
* BinarySearchTree object.
*/
@Override
public Iterator iterator() {
throw new UnsupportedOperationException(\"Not implemented yet!\");
}
/**
* Determines if there is at least one element in this BinarySearchTree object
* that equals a specified element. The worstTime(n) is O(n) and
* averageTime(n) is O(log n).
*
* @param obj - the element sought in this BinarySearchTree object.
* @return true - if there is an element in this BinarySearchTree object that
* equals obj; otherwise, return false.
* @throws ClassCastException - if obj cannot be compared to the elements in
* this BinarySearchTree object.
* @throws NullPointerException - if obj is null.
*/
@Override
public .
How do I fix it in LinkedList.javathis is what i didLabProgra.pdf
How do I fix it in LinkedList.java?
this is what i did
LabProgram.java
LinkedList.java:
/**
* Defines a doubly-linked list class
* @author
* @author
*/
import java.util.NoSuchElementException;
public class LinkedList {
private class Node {
private T data;
private Node next;
private Node prev;
public Node(T data) {
this.data = data;
this.next = null;
this.prev = null;
}
}
private int length;
private Node first;
private Node last;
private Node iterator;
/**** CONSTRUCTORS ****/
/**
* Instantiates a new LinkedList with default values
* @postcondition
*/
public LinkedList() {
first = null;
last = null;
iterator = null;
length = 0;
}
/**
* Converts the given array into a LinkedList
* @param array the array of values to insert into this LinkedList
* @postcondition
*/
public LinkedList(T[] array) {
}
/**
* Instantiates a new LinkedList by copying another List
* @param original the LinkedList to copy
* @postcondition a new List object, which is an identical,
* but separate, copy of the LinkedList original
*/
public LinkedList(LinkedList original) {
}
/**** ACCESSORS ****/
public T getFirst() throws NoSuchElementException {
if (isEmpty()){
throw new NoSuchElementException("The list is empty");
}
return first.data;
}
public T getLast() throws NoSuchElementException {
if (isEmpty()){
throw new NoSuchElementException("The list is empty");
}
return last.data;
}
/**
* Returns the data stored in the iterator node
* @precondition
* @return the data stored in the iterator node
* @throw NullPointerException
*/
public T getIterator() throws NullPointerException {
if (iterator != null){
return iterator.data;
}else{
throw new NullPointerException("Iterator is off the end opf the list.");
}
}
/**
* Returns the current length of the LinkedList
* @return the length of the LinkedList from 0 to n
*/
public int getLength() {
return length;
}
/**
* Returns whether the LinkedList is currently empty
* @return whether the LinkedList is empty
*/
public boolean isEmpty() {
return length == 0;
}
/**
* Returns whether the iterator is offEnd, i.e. null
* @return whether the iterator is null
*/
public boolean offEnd() {
return iterator == null;
}
/**** MUTATORS ****/
public void addFirst(T data) {
Node newNode = new Node(data);
if(isEmpty()){
first = newNode;
last = newNode;
}
else{
newNode.next = first;
first.prev = newNode;
first = newNode;
}
length++;
}
public void addLast(T data) {
Node newNode = new Node(data);
if(isEmpty()){
first = newNode;
last = newNode;
}
else{
last.next = newNode;
newNode.prev = last;
last = newNode;
}
length++;
}
/**
* Inserts a new element after the iterator
* @param data the data to insert
* @precondition
* @throws NullPointerException
*/
public void addIterator(T data) throws NullPointerException{
if(iterator != null){
Node newNode = new Node(data);
newNode.next = iterator.next;
iterator.next = newNode;
if (iterator == first){
first = newNode;
}
}else{
throw new NullPointerException("Iterator is off the end opf the list.");
}
}
/
public void remov.
PROBLEM STATEMENTIn this assignment, you will complete DoubleEnde.pdf
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.
Here is the editable codeSolutionimport java.util.NoSuchEleme.pdf
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.
1 The goal is to implement DataStructuresArrayStack accor.pdf
(1) The goal is to implement DataStructures.ArrayStack according to the interface ADTs.StackADT
********************************************
package DataStructures;
import ADTs.StackADT;
import Exceptions.EmptyCollectionException;
import Exceptions.StackOverflowException;
public class ArrayStack<T> implements StackADT<T> {
/** The index of where the top of the stack is */
int top;
/** The array that holds the stack */
T[] buffer;
public ArrayStack() {
}
public ArrayStack(int initialCapacity) {
}
}
*******************************************************
package ADTs;
import Exceptions.EmptyCollectionException;
import Exceptions.StackOverflowException;
/**
* An interface for a Stack
* Specific stack implementations will implement this interface
* For use Data Structures & Algorithms
*
*
* author unknown
*/
public interface StackADT<T> extends CollectionADT<T> {
/**
* Adds the specified element to the top of the stack
*
* @param element element to be pushed onto the stack
*/
public void push(T element) throws StackOverflowException;
/**
* Removes and returns the element that is on top of the stack
*
* @return the element removed from the stack
* @throws EmptyCollectionException
*/
public T pop() throws EmptyCollectionException;
/**
* Returns (without removing) the element that is on top of the stack
*
* @return the element on top of the stack
* @throws EmptyCollectionException
*/
public T peek() throws EmptyCollectionException;
}
*****************************************
package ADTs;
import Exceptions.*;
/**
* An interface for an ordered (NOT SORTED) List
* Elements stay in the order they are put in to the list
* For use in Data Structures & Algorithms
*
*
* @author unknown
*/
public interface ListADT<T> extends CollectionADT<T> {
/**
* Adds the specified element to the list at the front
*
* @param element: the element to be added
*
*/
public void addFirst(T element);
/**
* Adds the specified element to the end of the list
*
* @param element: the element to be added
*/
public void addLast(T element);
/**
* Adds the specified element to the list after the existing element
*
* @param existing: the element that is in the list already
* @param element: the element to be added
* @throws ElementNotFoundException if existing isn't in the list
*/
public void addAfter(T existing, T element) throws ElementNotFoundException,
EmptyCollectionException;
/**
* Removes and returns the specified element
*
* @return the element specified
* @throws EmptyCollectionException
* @throws ElementNotFoundException
*/
public T remove(T element) throws EmptyCollectionException, ElementNotFoundException;
/**
* Removes and returns the first element
*
* @return the first element in the list
* @throws EmptyCollectionException
*/
public T removeFirst() throws EmptyCollectionException;
/**
* Removes and returns the last element
*
* @return the last element in the list
* @throws EmptyCollectionException
*/
public T removeLast() throws EmptyCollectionException;
/**
* Returns (wit.
Nancy acaba de vender algunas de sus acciones en Spotify Inc.pdf
Name at least a few trends that have business potential in your area. The trend can be regional,
national, or global. How did you go about identifying this trend? What makes you think there is a
potential business idea for your area based on this trend? What problem does it solve? Is this a
potential business idea you want to develop? If not, describe at least one potential business idea
that interests you and the problem it solves..
Name this accessory gland to the digestive systemName th.pdf
Nakatomi Lexus.Nakatomi Lexus buys its cars from Lexus Motors (U.S.), and sells them to U.S.
customers. One of its customers is EcoHire, a car rental firm that buys cars from Nakatomi Lexus
at a wholesale price. Final payment is due to Nakatomi Lexus in six months. EcoHire has bought
USD806 comma 000 worth of cars from Nakatomi, with a cash down payment of USD177 comma
320 and the balance due in six months without any interest charged as a sales incentive.
Nakatomi Lexus will have the EcoHire receivable accepted by Alliance Acceptance for a 1.7 %
fee, and then sell it at a 2.6 % per annum discount to Wells Fargo Bank. a. What is the annualized
percentage all-in cost to Nakatomi Lexus? b. What are Nakatomi's net cash proceeds, including
the cash down payment? (NOTE: Assume a 360-day year.)
a. What is the annualized percentage all-in cost to Nakatomi Lexus? b. What are Nakatomi's net
cash proceeds, including the cash down payment? (NOTE: Assume a 360-day year.) The amount
financed is $ (Round to the nearest cent.).
More Related Content
Similar to I need help in writing the test cases of the below methods i.pdf
How do I fix it in LinkedList.javaLabProgram.javaLinkedList.jav.pdf
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.
package algs13;import stdlib.;import java.util.Iterator;im.docx
package algs13;
import stdlib.*;
import java.util.Iterator;
import java.util.NoSuchElementException;
/* ***********************************************************************
* Compilation: javac Queue.java
* Execution: java Queue < input.txt
* Data files: http://algs4.cs.princeton.edu/13stacks/tobe.txt
*
* A generic queue, implemented using a linked list.
*
* % java Queue < tobe.txt
* to be or not to be (2 left on queue)
*
*************************************************************************/
/**
* The <tt>Queue</tt> class represents a first-in-first-out (FIFO)
* queue of generic items.
* It supports the usual <em>enqueue</em> and <em>dequeue</em>
* operations, along with methods for peeking at the top item,
* testing if the queue is empty, and iterating through
* the items in FIFO order.
* <p>
* All queue operations except iteration are constant time.
* <p>
* For additional documentation, see <a href="http://algs4.cs.princeton.edu/13stacks">Section 1.3</a> of
* <i>Algorithms, 4th Edition</i> by Robert Sedgewick and Kevin Wayne.
*/
public class Queue<T> implements Iterable<T> {
private int N; // number of elements on queue
private Node<T> first; // beginning of queue
private Node<T> last; // end of queue
// helper linked list class
private static class Node<T> {
public Node() { }
public T item;
public Node<T> next;
}
/**
* Create an empty queue.
*/
public Queue() {
first = null;
last = null;
N = 0;
}
/**
* Is the queue empty?
*/
public boolean isEmpty() {
return first == null;
}
/**
* Return the number of items in the queue.
*/
public int size() {
return N;
}
/**
* Return the item least recently added to the queue.
* @throws java.util.NoSuchElementException if queue is empty.
*/
public T peek() {
if (isEmpty()) throw new NoSuchElementException("Queue underflow");
return first.item;
}
/**
* Add the item to the queue.
*/
public void enqueue(T item) {
Node<T> oldlast = last;
last = new Node<>();
last.item = item;
last.next = null;
if (isEmpty()) first = last;
else oldlast.next = last;
N++;
}
/**
* Remove and return the item on the queue least recently added.
* @throws java.util.NoSuchElementException if queue is empty.
*/
public T dequeue() {
if (isEmpty()) throw new NoSuchElementException("Queue underflow");
T item = first.item;
first = first.next;
N--;
if (isEmpty()) last = null;
return item;
}
/**
* Return string representation.
*/
public String toString() {
StringBuilder s = new StringBuilder();
for (T item : this)
s.append(item + " ");
return s.toString();
}
// check internal invariants
private static <T> boolean check(Queue<T> that) {
int N = that.N;
Queue.Node<T> first = that.first;
Queue.Node<T> last = that.last;
if (N == 0) {
if (first != null) return false;
if (last != null) return false;
}
else if (N == 1) {
if (f.
Given below is the completed implementation of MyLinkedList class. O.pdf
Given below is the completed implementation of MyLinkedList class. Other classes are not
modified and remain same as in question - MyList, MyAbstractList, TestMyLinkedList.
The output of TestMyLinkedList is shown below. Please don\'t forget to rate the answer if it
helped. Thank you very much.
Since the MyList is not completely pasted in the question ... giving the complete class file below
MyList.java
public interface MyList> extends java.lang.Iterable
{
// Add a new element at the end of this list
public void add (E e);
// Add a new element at specified index in this list
public void add (int index, E e);
// Return true if this list contains the element
public boolean contains (E e);
// Return the element at the specified index
public E get (int index);
// Return the index of the first matching element
// Return -1 if no match.
public int indexOf (E e);
// Return the index of the last matching element
// Return -1 if no match.
public int lastIndexOf (E e);
E remove(int index);
void clear();
E set(int index, E e);
}
MyLinkedList.java
public class MyLinkedList> extends MyAbstractList
implements Comparable>
{
private Node head, tail; // head and tail pointers
// Create a default list
public MyLinkedList()
{
}
public int size()
{
return size;
}
// Need this for implementing Comparable
public int compareTo (MyLinkedList e)
{
return(size() - e.size());
}
// Create a list from an array of objects
public MyLinkedList (E[] objects)
{
super(objects); // Passes the array up to abstract parent
}
// Return the head element in the list
public E getFirst()
{
if (size == 0)
{
return null;
}
else
{
return head.element;
}
}
// Return the last element in the list
public E getLast()
{
if (size == 0)
{
return null;
}
else
{
return tail.element;
}
}
// Add an element to the beginning of the list
public void addFirst (E e)
{
// Create a new node for element e
Node newNode = new Node(e);
newNode.next = head; // link the new node with the head
head = newNode; // head points to the new node
size++; // Increase list size
if (tail == null) // new node is only node
{
tail = head;
}
}
// Add an element to the end of the list
public void addLast (E e)
{
// Create a new node for element e
Node newNode = new Node(e);
if (tail == null)
{
head = tail = newNode; // new node is only node
}
else
{
tail.next = newNode; // Link the new with the last node
tail = tail.next; // tail now points to the last node
}
size++; // Increase size
}
// Remove the head node and
// return the object from the removed node
public E removeFirst()
{
if (size == 0)
{
return null;
}
else
{
Node temp = head;
head = head.next;
size--;
if (head == null)
{
tail = null;
}
return temp.element;
}
}
// Remove the last node and return the object from it
public E removeLast()
{
if (size == 0)
{
return null;
}
else if (size == 1)
{
Node temp = head;
head = tail = null;
size = 0;
return temp.element;
}
else
{
Node current = head;
for (int i = 0; i < size - 2; i++)
{
current = current.next;
}
Node temp = tail;
tai.
Add functions push(int n- Deque &dq) and pop(Deque &dq)- Functions pus.docx
Add functions push(int n, Deque &dq) and pop(Deque &dq).
Functions push(int n, Deque &dq) and pop(Deque &dq) should call functions of the Deque class to simulate a stack's push and pop functions.
The Deque class should not be touched . I will use the original unmodified Deque class when testing your code.
Demonstrate to convert a base 10 number to base 2. Ask the user to enter a base 10 number, output the equivalent base 2 number. The main() function would create a Deque object and pass it by reference when calling the new
push(int n, Deque &dq) and pop(Deque &dq) functions simulating stack operations.
keep it simple and to the instructions and code provided please! and thank you!
// C++ implementation of De-queue using circular
// array
#include<iostream>
using namespace std;
// Maximum size of array or Dequeue
#define MAX 100
// A structure to represent a Deque
class Deque
{
int arr[MAX];
int front;
int rear;
int size;
public :
Deque(int size)
{
front = -1;
rear = 0;
this->size = size;
}
// Operations on Deque:
void insertfront(int key);
void insertrear(int key);
void deletefront();
void deleterear();
bool isFull();
bool isEmpty();
int getFront();
int getRear();
};
// Checks whether Deque is full or not.
bool Deque::isFull()
{
return ((front == 0 && rear == size-1)||
front == rear+1);
}
// Checks whether Deque is empty or not.
bool Deque::isEmpty ()
{
return (front == -1);
}
// Inserts an element at front
void Deque::insertfront(int key)
{
// check whether Deque if full or not
if (isFull())
{
cout << "Overflow\n" << endl;
return;
}
// If queue is initially empty
if (front == -1)
{
front = 0;
rear = 0;
}
// front is at first position of queue
else if (front == 0)
front = size - 1 ;
else // decrement front end by '1'
front = front-1;
// insert current element into Deque
arr[front] = key ;
}
// function to inset element at rear end
// of Deque.
void Deque ::insertrear(int key)
{
if (isFull())
{
cout << " Overflow\n " << endl;
return;
}
// If queue is initially empty
if (front == -1)
{
front = 0;
rear = 0;
}
// rear is at last position of queue
else if (rear == size-1)
rear = 0;
// increment rear end by '1'
else
rear = rear+1;
// insert current element into Deque
arr[rear] = key ;
}
// Deletes element at front end of Deque
void Deque ::deletefront()
{
// check whether Deque is empty or not
if (isEmpty())
{
cout << "Queue Underflow\n" << endl;
return ;
}
// Deque has only one element
if (front == rear)
{
front = -1;
rear = -1;
}
else
// back to initial position
if (front == size -1)
front = 0;
else // increment front by '1' to remove current
// front value from Deque
front = front+1;
}
// Delete element at rear end of Deque
void Deque::deleterear()
{
if (isEmpty())
{
cout << " Underflow\n" << endl ;
return ;
}
// Deque has only one element
if (front == rear)
{
front = -1;
rear = -1;
}
else if (rear == 0)
rear = size-1;
else
rear = rear-1;
}
// Returns front element of Deque
int Deque::getFront()
{
// check whether Deque is empty or not
if (isEmp.
Given the following ADT definition of a stack to use stack .docx
Given the following ADT definition of a stack to use:
/** stack (base class)
* The basic definition of the Stack Abstract Data Type (ADT)
* and stack operations. All declared functions here are
* virtual, they must be implemented by concrete derived
* classes.
*/
template <class T>
class Stack
{
public:
/** clear
* Method to clear out or empty any items on stack,
* put stack back to empty state.
* Postcondition: Stack is empty.
*/
virtual void clear() = 0;
/** isEmpty
* Function to determine whether the stack is empty. Needed
* because it is undefined to pop from empty stack. This
* function will not change the state of the stack (const).
*
* @returns bool true if stack is empty, false otherwise.
*/
virtual bool isEmpty() const = 0;
/** push
* Add a new item onto top of stack.
*
* @param newItem The item of template type T to push on top of
* the current stack.
*/
virtual void push(const T& newItem) = 0;
/** top
* Return the top item from the stack. Note in this ADT, peeking
* at the top item does not remove the top item. Some ADT combine
* top() and pop() as one operation. It is undefined to try and
* peek at the top item of an empty stack. Derived classes should
* throw an exception if this is attempted.
*
* @returns T Returns the top item from stack.
*/
virtual T top() const = 0;
/** pop
* Remove the item from the top of the stack. It is undefined what
* it means to try and pop from an empty stack. Derived classes should
* throw an exception if pop() from empty is attempted.
*/
virtual void pop() = 0;
/** size
* Accessor method to provide the current size of the stack.
*
* @returns int The current size (number of items) on the stack.
*/
virtual int size() const = 0;
};
perform the following tasks by writing code that uses a stack to accomplish the task. You will
need to create a stack of the needed type, then use the methods of the stack abstraction (push,
top, pop, etc.) to solve the given task asked for.
Question 7 (5 points)
Given a stack of integers, calculate the sum of the integer values. Also, the stack should still be
unchanged after you have calculated the sum Hint: take the items off the stack to sum them up
and keep them on a second temporary stack so you can put them all back on after you have
calculated the sum.
ANSWER FOR NUMBER 7:
int sumStackOfIntegers(Stack<int> currentStack) {
Stack<int> tempStack;
int sum = 0;
while(!currentStack.isEmpty()) {
int temp = currentStack.top();
tempStack.push(temp);
currentStack.pop();
sum += temp;
}
while(!tempStack.isEmpty()) {
int temp = tempStack.top();
currentStack.push(temp);
tempStack.pop();
}
return sum;
}
Stack Implementation
Given the following linked list implementation of a Stack ADT (this is the same implementation
you used in Assignment 10), add the asked for additional member methods to the linked list stack
implementation.
/** Node
* A basic node contaning an item and a link to t ...
Hi, Please find my code.I have correted all of your classes.Plea.pdf
Hi, Please find my code.
I have correted all of your classes.
Please let me know in case if do not get concpt.
######## Node.java ###########
public class Node {
private E element;
private Node next;
public Node() {
this.element = null;
this.next = null;
}
public Node(E e) {
this.element = e;
this.next = null;
}
public E getElement() {
return this.element;
}
public void setElement(E element) {
this.element= element;
}
public Node getNext() {
return next;
}
public void setNext(Node next) {
this.next = next;
}
}
########## Stack.java #############
public class Stack {
private int N;
private Node top;
public Stack() {
N = 0;
this.top =null;
}
/*
* places element on the top of the stack
*/
public void push(E element){
Node temp = new Node(element);
temp.setNext(top);
top = temp;
N++;
}
/*
* remove the top node and return its contents
*/
public E pop(){
if(top == null)
return null;
E e = top.getElement();
top = top.getNext();
N--;
return e;
}
/*
* Look at the top element of the Stack and return it, without removing
*/
public E peek(){
if(top == null)
return null;
return top.getElement();
}
//returns the size of the stack
public int size(){
return N; //replace
}
public boolean isEmpty(){
return top==null;
}
}
############ Queue.java ############
public class Queue {
private Node front;
private Node back;
private int N;
public Queue() {
this.front = null;
this.back = null;
N = 0;
}
/*
* places element in the back of the Queue
*/
public void enqueue(E element){
Node temp = new Node(element);
if(front == null) {
front = temp;
back = temp;
}
else{
back.setNext(temp);
back = temp;
}
N++;
}
/*
* remove the front node of the queue and return it
*/
public E dequeue(){
if(front == null) {
return null;
}
E item = front.getElement();
front = front.getNext();
// if we had only one element
if(front == null){
back = null;
}
N--;
return item;
}
/*
* Look at the front of the queue and return it, without removing
*/
public E peek(){
if(back == null)
return null;
return back.getElement();
}
//returns the size of the queue
public int size(){
return N;
}
public boolean isEmpty(){
return front==null;
}
}
########### Palindrome.java ############
import java.util.Scanner;
public class Palindrome
{
public static void main(String[ ] args)
{
Scanner input = new Scanner(System.in);
String inputString;
System.out.print(\"Please enter your string: \");
inputString = input.next( );
if (isPalindrome( inputString )){
System.out.println(\"Yes it is a palindrome.\");
}
else{
System.out.println(\"No this is not a palindrome.\");
}
}
public static boolean isPalindrome(String input)
{
Queue q = new Queue ();
Stack s = new Stack ();
char letter;
int i;
for (i = 0; i < input.length( ); i++)
{
letter = input.charAt(i);
q.enqueue(letter);
s.push(letter);
}
while (!q.isEmpty( ))
{
if (q.dequeue() != s.pop( ))
return false;
}
return true;
}
}
/*
Sample Output:
Please enter your string: MadaM
Yes it is a palindrome.
*/
Solution
Hi, Please find my code.
I have correted all of your classes.
Pl.
EmptyCollectionException-java -- - Represents the situation in which.docx
EmptyCollectionException.java
/*
* Represents the situation in which a collection is empty.
*/
public class EmptyCollectionException extends RuntimeException
{
/* General class level objects */
/*
* Sets up this exception with an appropriate message.
* @param collection the name of the collection
*/
public EmptyCollectionException(String collection)
{
super("The " + collection + " is empty.");
}
}
PriorityNode.java
/*
* Represents a node in a linked list.
*/
public class PriorityNode<T>
{
/* General class level objects */
private PriorityNode<T> _next;
private T _element;
private int _priority;
private final int _MAX_PRIORITY = 100;
/*
* Creates an empty node with a given priority.
*/
public PriorityNode(T elem, int priority)
{
// TODO To be completed as a Programming Project
}
/*
* Creates a node storing the specified element with a default priority.
*
* @param elem element to be stored
*/
public PriorityNode(T elem)
{
// TODO To be completed as a Programming Project
}
/*
* Returns the node that follows this one.
*
* @return reference to next node
*/
public PriorityNode<T> getNext()
{
// TODO To be completed as a Programming Project
}
/*
* Sets the node that follows this one.
*
* @param node node to follow this one
*/
public void setNext(PriorityNode<T> node)
{
// TODO To be completed as a Programming Project
}
/*
* Returns the element stored in this node.
*
* @return element stored at the node
*/
public T getElement()
{
// TODO To be completed as a Programming Project
}
/*
* Returns the priority of this node.
*
* @return element priority the node
*/
public int getPriority()
{
// TODO To be completed as a Programming Project
}
/*
* Sets the element stored in this node.
*
* @param elem element to be stored at this node
*/
public void setElement(T elem)
{
// TODO To be completed as a Programming Project
}
/*
* optional toString() override.
*/
//public String toString()
//{
// // TODO To be completed as a Programming Project
//}
}
PriorityQueue.java
/*
* LinkedQueue represents a linked implementation of a queue.
*/
public class PriorityQueue<T> implements PriorityQueueADT<T>
{
/* General class level objects */
private int _count;
private PriorityNode<T> _head, _tail;
/*
* Constructor - Creates an empty queue.
*/
public PriorityQueue()
{
_count = 0;
_head = _tail = null;
}
/*
* Adds one element to the rear of this queue.
* Higher priorities are inserted closer to the front of the queue
* Items with the same priority are processed in normal queue order
*
* @param element the element to be added to the rear of the queue
* @param priority relative priority of the queue item
*/
public void enqueue(T element, int priority)
{
// TODO To be completed as a Programming Project
// add in-order insertion of the PriorityNode based on getPriority() value
// the higher the priority is the closer to head it gets
// equivalent priority is normal .
public class DoubleArraySeq implements Cloneable { Priva.pdf
public class DoubleArraySeq implements Cloneable
{
// Private Instance Variables
private double[] data;
private int manyItems;
private int currentIndex;
//Constructor Methods
/**
* Initialize an empty sequence with an initial capacity of 10.
**/
public DoubleArraySeq()
{
try{
//Set a default capacity for new DoubleArraySeq\'s.
int INITAL_CAPACITY = 10;
//Set each instance variable to its initial value.
data = new double[INITAL_CAPACITY];
manyItems = 0;
currentIndex = 0;
}//end try
catch (OutOfMemoryError e){
throw new OutOfMemoryError (\"There is not enough memory to create a new
sequence!\");
}//end catch
}//end DoubleArraySeq() method
/**
* Initialize an empty sequence with a specified initial capacity. Note that the addAfter and
addBefore methods work
* efficiently (without needing more memory) until this capacity is reached.
**/
public DoubleArraySeq(int initialCapacity)
{
try{
//Set each instance variable to its initial value.
data = new double[initialCapacity];
currentIndex = 0;
manyItems = 0;
}//end try
catch (OutOfMemoryError e){
throw new OutOfMemoryError (\"There is not enough memory to create a new sequence
of capacity \" + initialCapacity + \"!\");
}//end catch
}//end DoubleArraySeq(int initialCapacity) method
// Accessor Methods
/**
**/
public boolean isCurrent()
{
return (currentIndex < manyItems);
}//end isCurrent() method
/**
* Accessor method to get the current element of this sequence.
**/
public double getCurrent()
{
//Confirm that there is a current element first.
if (isCurrent())
return data[currentIndex];
else
throw new IllegalStateException(\"There is no current element! Please specify a current
element first.\");
}//end getCurrent() method
/**
* Accessor method to get the current capacity of this sequence.
**/
public int getCapacity()
{
//Returns the number of indexes in the array.
return data.length;
}//end getCapacity() method
/**
* Accessor method to get the available capacity (number of empty indexes) of this sequence.
* The available capacity (number of empty indexes) of this sequence.
**/
public int getAvailCapacity()
{
//Returns the number of empty indexes in the array.
return data.length - manyItems;
}//end getAvailCapacity() method
/**
**/
public int size()
{
//Returns the number of elements in the sequence.
return manyItems;
}//end size() method
// Setter Methods
/**
* A method to move forward, so the current element is now the next element in this sequence.
**/
public void advance()
{
if (isCurrent())
currentIndex++;
else
throw new IllegalStateException (\"There is no current element! Advance may not be
called.\");
}//end advance() method
/**
* A method to set the current element at the front of this sequence.
**/
public void start()
{
if (manyItems > 0)
currentIndex = 0;
else
throw new IllegalStateException(\"This sequence is empty!\");
}//end start() method
/**
* A method that makes the last element of the sequence the current element.
**/
public void setCurrentLast()
{
if (manyItems > 0)
currentIndex = ma.
Please review my code (java)Someone helped me with it but i cannot.pdf
Please make it to clear 12-95. The basketball passed through the hoop even though it barely
cleared the hands of the player B who attempted to block it. Neglecting the size of the ball,
determine the magnitude vn of its initial velocity and the height h of the ball when it passes over
player B 10 ft 5 ft Prob. 12-95
Solution
Consider the motion along horizontal direction
Vox = initial velocity in horizontal direction = Va Cos30
X = horizontal distance = 25 + 3 = 28 ft
t = time taken
t = X / Vox = 28/(Va Cos30) eq-1
consider the motion in vertical direction
Y = vertical displacement = 10 - 7 = 3 ft
a = acceleration = - 32.2
Voy = initial velocity = Va Sin30
t = time taken
using the equation
Y = Voy t + (0.5) a t2
3 = (Va Sin30) (28/(Va Cos30)) + (0.5) (- 32.2) (28/(Va Cos30))2
Va = 35.8 m/s
t\' = time taken to reach B = 25 / (Va Cos30) = 25 / (35.8 Cos30) = 0.81 sec
h = 7 + Voy t\' + (0.5) a t\'2
h = 7 + (35.8 Sin30) (0.81) + (0.5) (- 32.2) (0.81)2
h = 10.94 ft.
I have a stack in Java populated with integers. Im trying to compa.pdf
I have a stack in Java populated with integers. I\'m trying to compare the elements in the stack to
determine which is the largest. Basically, I enter the element at the top of the stack into e then
pop each element off the stack and check to see if it is greater than the value stored in e. How can
I check to see if the next element in the stack is greater than the element stored in e?
E e = stk1.peek();
while(!stk1.empty())
{
if(stk1.peek() > e)
{
e=stk1.peek();
}
Solution
Using recursive approach we can sort the stack and the top element of stack would be the largest
integer.
Algorithm:
Sorting stack elements:
Inserting elements in sorted order:
Illustration:
First pop all the elements from the stack and store poped element in variable \'temp\'. After
poping all the elements function\'s stack frame will look like:
Now stack is empty and \'insert_in_sorted_order()\' function is called and it inserts 30 (from
stack frame #5) at the bottom of the stack. Now stack looks like below:
Now next element i.e. -5 (from stack frame #4) is picked. Since -5 < 30, -5 is inserted at the
bottom of stack. Now stack becomes:
Next 18 (from stack frame #3) is picked. Since 18 < 30, 18 is inserted below 30. Now stack
becomes:
Next 14 (from stack frame #2) is picked. Since 14 < 30 and 14 < 18, it is inserted below 18. Now
stack becomes:
Now -3 (from stack frame #1) is picked, as -3 < 30 and -3 < 18 and -3 < 14, it is inserted below
14. Now stack becomes:
Implementation:
/**
* Stack is represented using linked list
*/
public class Stack extends NativeClass {
private final IntContainer data = new IntContainer(this, 1);
private final Container> next = new Container>(this, 1){};
public int getData() {
return data.get();
}
public int setData(int newData) {
return data.set(newData);
}
public Container getNext() {
return next.get();
}
public Container setNext(Container newNext) {
return next.set(newNext);
}
public static Container nnc(Container orig) {
return Container.nnc(new TypeInfo>(){}, orig);
}
/**
* Utility function to initialize stack
*/
public static void initStack(Container[] s) {
s[0] = null;
}
/**
* Utility function to chcek if stack is empty
*/
public static int isEmpty(Stack[] s) {
if(s == null) {
return 1;
}
return 0;
}
/**
* Utility function to push an item to stack
*/
public static void push(Container[] s, int x) {
Container p = new Container(true, 1){};
p.get().setData(x);
p.get().setNext(s[0]);
s[0] = p;
}
/**
* Utility function to remove an item from stack
*/
public static int pop(Container[] s) {
int x;
Container temp;
x = s[0].get().getData();
temp = s[0];
s[0] = s[0].get().getNext();
nnc(temp).setNativeControlled(false);
return x;
}
/**
* Function to find top item
*/
public static int top(Stack[] s) {
return s[0].getData();
}
}
// Recursive function to insert an item x in sorted way
public static void sortedInsert(Container> s, int x) {
// Base case: Either stack is empty or newly inserted
// item is greater than top (more than all existing)
if(is.
AnswerNote Driver class is not given to test the DoubleArraySeq..pdf
Answer:
Note: Driver class is not given to test the DoubleArraySeq.java
Modified Code:
public class DoubleArraySeq implements Cloneable
{
// Invariant of the DoubleArraySeq class:
// 1. The number of elements in the sequences is in the instance variable
// manyItems.
// 2. For an empty sequence (with no elements), we do not care what is
// stored in any of data; for a non-empty sequence, the elements of the
// sequence are stored in data[0] through data[manyItems-1], and we
// don care what in the rest of data.
// 3. If there is a current element, then it lies in data[currentIndex];
// if there is no current element, then currentIndex equals manyItems.
private double[ ] data;
private int manyItems;
private int currentIndex;
/**
* Initialize an empty sequence with an initial capacity of 10. Note that
* the addAfter and addBefore methods work
* efficiently (without needing more memory) until this capacity is reached.
* @param - none
* @postcondition
* This sequence is empty and has an initial capacity of 10.
* @exception OutOfMemoryError
* Indicates insufficient memory for:
* new double[10].
**/
public DoubleArraySeq( )
{
//Set manyItems to 0.
manyItems=0;
//Initialize data
data=new double[10];
}
/**
* Initialize an empty sequence with a specified initial capacity. Note that
* the addAfter and addBefore methods work
* efficiently (without needing more memory) until this capacity is reached.
* @param initialCapacity
* the initial capacity of this sequence
* @precondition
* initialCapacity is non-negative.
* @postcondition
* This sequence is empty and has the given initial capacity.
* @exception IllegalArgumentException
* Indicates that initialCapacity is negative.
* @exception OutOfMemoryError
* Indicates insufficient memory for:
* new double[initialCapacity].
**/
public DoubleArraySeq(int initialCapacity)
{
//Check initialCapacity. If it is <0, throw EXCEPTION
if(initialCapacity < 0)
//Throw EXCEPTION
throw new IllegalArgumentException (\"initialCapacity IS NEGATIVE:\");
//Set manyItems to 0.
manyItems = 0;
try
{
data = new double[initialCapacity];
}
catch(OutOfMemoryError ea)
{
throw new RuntimeException
(\"NOT ENOUGH MEMORY\");
}
}
/**
* Add a new element to this sequence, after the current element.
* If the new element would take this sequence beyond its current capacity,
* then the capacity is increased before adding the new element.
* @param element
* the new element that is being added
* @postcondition
* A new copy of the element has been added to this sequence. If there was
* a current element, then the new element is placed after the current
* element. If there was no current element, then the new element is placed
* at the end of the sequence. In all cases, the new element becomes the
* new current element of this sequence.
* @exception OutOfMemoryError
* Indicates insufficient memory for increasing the sequence\'s capacity.
* @note
* An attempt to increase the capacity beyond
* Integer.MAX_VALUE will cause the sequence to fail with an.
In java , I want you to implement a Data Structure known as a Doubly.pdf
In java , I want you to implement a Data Structure known as a Doubly-Ended-Queue. it is a
“fair” data structure in that it implements a FIFO (First In First Out ) behavior. As such, it is
often used to implement various wait lists in computer systems. For example, jobs waiting to use
the CPU, jobs waiting for a printer, jobs waiting to be placed into RAM for execution. In short,
whenever we want a fair strategy for waiting we use queues.
A DEQUE (Doubly-ended-queue) is a related data structure. Although similar to a Queue, it
differs in that it allows for insertions AND deletions from either end of the list (both the front
and the rear).
Your implementation MUST use a doubly-linked-list implementation. You may not use a static
array implementation.
Thus, a Deque is a List but it is one which only concerns itself with the first and last positions for
any insertion or deletion. The 6 operations supported are :
public void insertFront( int item ) - insert the given item (as a node) into the first position of the
Deque.
public void insertRear( int item ) - insert the given item (as a node) into the last position of the
Deque.
public int deleteFront( ) - delete and return the element stored in the first node of the Deque.
public int deletRear( ) – delete and return the element stored in the last node of the Deque.
public boolean isempty( ) - returns true if the Deque is currently empty or false if it is not.
public void printDeque( ) - print the integers from the list, one per line, from the first element
through to the last in order.
Classes
Your program must implement the following 3 classes. public class dequeDriver
This class will contain your program’s main method. It will need to declare a deque object and
process input as indicated below.
Your program should prompt the user for the path of an input file. It should open the file for
input and process it line by line. Each line of the input file will have one of the following forms.
PR
IF
IR
DF
DR
The meanings of each input is as follows:
PR - print the current contents of the deque from front to rear using the printDeque( ) method of
the deque object.
IF - insert the given int value into the front of the deque.
IR - insert the given int value into the rear of the deque.
DF - delete the front value from the deque.
DR – delete the rear element of the deque.
Below is an example input file that your program should be able to process.
PR
IF 4
IF 5
IF 6
IR 7
PR
DR
PR
DF
PR
The output for the input file shown above is :
EMPTY DEQUE
----- Front -----
6
5
4
7
----- Rear -----
----- Front -----
6
5
4
----- Rear -----
----- Front -----
5
4
----- Rear -----
public class dequeNode
This class will implement the linked nodes that will be used to implement the deque itself.
It should have the following protected data members.
protected dequeNode next; // next pointer to next node
protected dequeNode prev; // previous pointer to previous node
protected int val; // the integer value stored within the dequeNod.
import java-util-Iterator- import java-util-NoSuchElementException- im.pdf
import java.util.Iterator;
import java.util.NoSuchElementException;
import lab4.util.List;
public class SinglyLinkedList<E> implements List<E> {
@SuppressWarnings("hiding")
private class SinglyLinkedListIterator<E> implements Iterator<E>{
private Node<E> nextNode;
@SuppressWarnings("unchecked")
public SinglyLinkedListIterator() {
this.nextNode = (Node<E>) header.getNext();
}
@Override
public boolean hasNext() {
return nextNode != null;
}
@Override
public E next() {
if (this.hasNext()) {
E result = this.nextNode.getElement();
this.nextNode = this.nextNode.getNext();
return result;
}
else {
throw new NoSuchElementException();
}
}
}
private static class Node<E> {
private E element;
private Node<E> next;
public Node(E element, Node<E> next) {
super();
this.element = element;
this.next = next;
}
public Node() {
super();
}
public E getElement() {
return element;
}
public void setElement(E element) {
this.element = element;
}
public Node<E> getNext() {
return next;
}
public void setNext(Node<E> next) {
this.next = next;
}
}
private Node<E> header;
private int currentSize;
public SinglyLinkedList() {
this.header = new Node<>();
this.currentSize = 0;
}
@Override
public int size() {
return this.currentSize;
}
@Override
public boolean isEmpty() {
return this.size() == 0;
}
@Override
public boolean contains(E e) {
return this.firstIndexOf(e) >= 0;
}
@Override
public int firstIndexOf(E e) {
int i = 0;
for (Node<E> temp = this.header.getNext(); temp != null;
temp = temp.getNext(), ++i) {
if (temp.getElement().equals(e)) {
return i;
}
}
// not found
return -1;
}
@Override
public void add(E e) {
if (this.isEmpty()) {
this.header.setNext(new Node<E>(e, null));
this.currentSize++;
}
else {
Node<E>temp= this.header.getNext();
while (temp.getNext() != null) {
temp = temp.getNext();
}
Node<E> newNode = new Node<>(e, null);
temp.setNext(newNode);
this.currentSize++;
}
}
@Override
public void add(E e, int index) {
if ((index < 0) || (index > this.currentSize)) {
throw new IndexOutOfBoundsException();
}
if (index == this.currentSize) {
this.add(e);
}
else {
Node<E> temp = null;
if (index == 0) {
temp = this.header;
}
else {
temp = this.getPosition(index -1);
}
Node<E> newNode = new Node<>();
newNode.setElement(e);
newNode.setNext(temp.getNext());
temp.setNext(newNode);
this.currentSize++;
}
}
@Override
public E get(int position) {
if ((position < 0) || position >= this.currentSize) {
throw new IndexOutOfBoundsException();
}
Node<E> temp = this.getPosition(position);
return temp.getElement();
}
private Node<E> getPosition(int index){
int currentPosition=0;
Node<E> temp = this.header.getNext();
while(currentPosition != index) {
temp = temp.getNext();
currentPosition++;
}
return temp;
}
@Override
public boolean remove(int index) {
if ((index < 0) || (index >= this.currentSize)){
throw new IndexOutOfBoundsException();
}
else {
Node<E> temp = this.header;
int currentPosition =0;
Node<E> target = null;
while (currentPosition != index) {
temp = temp.getNext();
currentPosit.
Hi,I have added the methods and main class as per your requirement.pdf
Hi,
I have added the methods and main class as per your requirement. it is working fine now.
Highlighted the code changes.
MyLinkedListTest.java
public class MyLinkedListTest {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
MyLinkedList list = new MyLinkedList();
list.addFirst(\"AAAAA\");
list.add(\"1\");
list.add(\"2\");
list.add(\"3\");
list.addLast(\"ZZZZZ\");
System.out.println(\"Linked List Elements : \"+list.toString());
System.out.println(\"First element: \"+list.getFirst());
System.out.println(\"Second element: \"+list.getLast());
System.out.println(\"Removed First Element: \"+list.removeFirst());
System.out.println(\"Now Linked List Elements : \"+list.toString());
System.out.println(\"Removed Last Element: \"+list.removeLast());
System.out.println(\"Now Linked List Elements : \"+list.toString());
System.out.println(\"Removed all element: \");
list.removeAll();
System.out.println(\"Now Linked List Elements : \"+list.toString());
}
}
MyLinkedList.java
public class MyLinkedList extends MyAbstractList {
private Node head, tail;
/** Create a default list */
public MyLinkedList() {
}
/** Create a list from an array of objects */
public MyLinkedList(E[] objects) {
super(objects);
}
/** Return the head element in the list */
public E getFirst() {
if (size == 0) {
return null;
}
else {
return (E)head.element;
}
}
/** Return the last element in the list */
public E getLast() {
if (size == 0) {
return null;
}
else {
return (E)tail.element;
}
}
/** Add an element to the beginning of the list */
public void addFirst(E e) {
Node newNode = new Node(e); // Create a new node
newNode.next = head; // link the new node with the head
head = newNode; // head points to the new node
size++; // Increase list size
if (tail == null) // the new node is the only node in list
tail = head;
}
/** Add an element to the end of the list */
public void addLast(E e) {
Node newNode = new Node(e); // Create a new for element e
if (tail == null) {
head = tail = newNode; // The new node is the only node in list
}
else {
tail.next = newNode; // Link the new with the last node
tail = tail.next; // tail now points to the last node
}
size++; // Increase size
}
/** Add a new element at the specified index in this list
* The index of the head element is 0 */
public void add(int index, E e) {
if (index == 0) {
addFirst(e);
}
else if (index >= size) {
addLast(e);
}
else {
Node current = head;
for (int i = 1; i < index; i++) {
current = current.next;
}
Node temp = current.next;
current.next = new Node(e);
(current.next).next = temp;
size++;
}
}
/** Remove the head node and
* return the object that is contained in the removed node. */
public E removeFirst() {
if (size == 0) {
return null;
}
else {
Node temp = head;
head = head.next;
size--;
if (head == null) {
tail = null;
}
return (E)temp.element;
}
}
/** Remove all elements from list */
public void removeAll() {
while(true) {
if (size == 0) {
break;
}
else {
Node temp = head;
head =.
For the code below complete the preOrder() method so that it perform.pdf
For the code below complete the preOrder() method so that it performs a preOrder traversal of
the tree. For each node it traverses, it should call sb.append() to add a \"[\" the results of
traversing the subtree rooted at that node, and then a \"]\". You should add a space before the
results of the left and right child traversals, but only if the node exists.
code:
Solution
In preorder Nodes visited are in the order of
code:
package edu.buffalo.cse116;
import java.util.AbstractSet;
import java.util.Iterator;
public class BinarySearchTree> extends AbstractSet {
protected Entry root;
protected int size;
/**
* Initializes this BinarySearchTree object to be empty, to contain only
* elements of type E, to be ordered by the Comparable interface, and to
* contain no duplicate elements.
*/
public BinarySearchTree() {
root = null;
size = 0;
}
/**
* Initializes this BinarySearchTree object to contain a shallow copy of a
* specified BinarySearchTree object. The worstTime(n) is O(n), where n is the
* number of elements in the specified BinarySearchTree object.
*
* @param otherTree - the specified BinarySearchTree object that this
* BinarySearchTree object will be assigned a shallow copy of.
*/
public BinarySearchTree(BinarySearchTree otherTree) {
root = copy(otherTree.root, null);
size = otherTree.size;
}
/* Method to complete is here! */
public void preOrder(Entry ent, StringBuilder sb) {
preorder(root)
protected Entry copy(Entry p, Entry parent) {
if (p != null) {
Entry q = new Entry(p.element, parent);
q.left = copy(p.left, q);
q.right = copy(p.right, q);
return q;
}
return null;
} // method copy
@SuppressWarnings(\"unchecked\")
@Override
public boolean equals(Object obj) {
if (!(obj instanceof BinarySearchTree)) {
return false;
}
return equals(root, ((BinarySearchTree) obj).root);
}
public boolean equals(Entry p, Entry q) {
if ((p == null) || (q == null)) {
return p == q;
}
if (!p.element.equals(q.element)) {
return false;
}
if (equals(p.left, q.left) && equals(p.right, q.right)) {
return true;
}
return false;
}
/**
* Returns the size of this BinarySearchTree object.
*
* @return the size of this BinarySearchTree object.
*/
@Override
public int size() {
return size;
}
/**
* Iterator method will be implemented for a future
*
* @return an iterator positioned at the smallest element in this
* BinarySearchTree object.
*/
@Override
public Iterator iterator() {
throw new UnsupportedOperationException(\"Not implemented yet!\");
}
/**
* Determines if there is at least one element in this BinarySearchTree object
* that equals a specified element. The worstTime(n) is O(n) and
* averageTime(n) is O(log n).
*
* @param obj - the element sought in this BinarySearchTree object.
* @return true - if there is an element in this BinarySearchTree object that
* equals obj; otherwise, return false.
* @throws ClassCastException - if obj cannot be compared to the elements in
* this BinarySearchTree object.
* @throws NullPointerException - if obj is null.
*/
@Override
public .
How do I fix it in LinkedList.javathis is what i didLabProgra.pdf
How do I fix it in LinkedList.java?
this is what i did
LabProgram.java
LinkedList.java:
/**
* Defines a doubly-linked list class
* @author
* @author
*/
import java.util.NoSuchElementException;
public class LinkedList {
private class Node {
private T data;
private Node next;
private Node prev;
public Node(T data) {
this.data = data;
this.next = null;
this.prev = null;
}
}
private int length;
private Node first;
private Node last;
private Node iterator;
/**** CONSTRUCTORS ****/
/**
* Instantiates a new LinkedList with default values
* @postcondition
*/
public LinkedList() {
first = null;
last = null;
iterator = null;
length = 0;
}
/**
* Converts the given array into a LinkedList
* @param array the array of values to insert into this LinkedList
* @postcondition
*/
public LinkedList(T[] array) {
}
/**
* Instantiates a new LinkedList by copying another List
* @param original the LinkedList to copy
* @postcondition a new List object, which is an identical,
* but separate, copy of the LinkedList original
*/
public LinkedList(LinkedList original) {
}
/**** ACCESSORS ****/
public T getFirst() throws NoSuchElementException {
if (isEmpty()){
throw new NoSuchElementException("The list is empty");
}
return first.data;
}
public T getLast() throws NoSuchElementException {
if (isEmpty()){
throw new NoSuchElementException("The list is empty");
}
return last.data;
}
/**
* Returns the data stored in the iterator node
* @precondition
* @return the data stored in the iterator node
* @throw NullPointerException
*/
public T getIterator() throws NullPointerException {
if (iterator != null){
return iterator.data;
}else{
throw new NullPointerException("Iterator is off the end opf the list.");
}
}
/**
* Returns the current length of the LinkedList
* @return the length of the LinkedList from 0 to n
*/
public int getLength() {
return length;
}
/**
* Returns whether the LinkedList is currently empty
* @return whether the LinkedList is empty
*/
public boolean isEmpty() {
return length == 0;
}
/**
* Returns whether the iterator is offEnd, i.e. null
* @return whether the iterator is null
*/
public boolean offEnd() {
return iterator == null;
}
/**** MUTATORS ****/
public void addFirst(T data) {
Node newNode = new Node(data);
if(isEmpty()){
first = newNode;
last = newNode;
}
else{
newNode.next = first;
first.prev = newNode;
first = newNode;
}
length++;
}
public void addLast(T data) {
Node newNode = new Node(data);
if(isEmpty()){
first = newNode;
last = newNode;
}
else{
last.next = newNode;
newNode.prev = last;
last = newNode;
}
length++;
}
/**
* Inserts a new element after the iterator
* @param data the data to insert
* @precondition
* @throws NullPointerException
*/
public void addIterator(T data) throws NullPointerException{
if(iterator != null){
Node newNode = new Node(data);
newNode.next = iterator.next;
iterator.next = newNode;
if (iterator == first){
first = newNode;
}
}else{
throw new NullPointerException("Iterator is off the end opf the list.");
}
}
/
public void remov.
PROBLEM STATEMENTIn this assignment, you will complete DoubleEnde.pdf
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.
Here is the editable codeSolutionimport java.util.NoSuchEleme.pdf
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.
1 The goal is to implement DataStructuresArrayStack accor.pdf
(1) The goal is to implement DataStructures.ArrayStack according to the interface ADTs.StackADT
********************************************
package DataStructures;
import ADTs.StackADT;
import Exceptions.EmptyCollectionException;
import Exceptions.StackOverflowException;
public class ArrayStack<T> implements StackADT<T> {
/** The index of where the top of the stack is */
int top;
/** The array that holds the stack */
T[] buffer;
public ArrayStack() {
}
public ArrayStack(int initialCapacity) {
}
}
*******************************************************
package ADTs;
import Exceptions.EmptyCollectionException;
import Exceptions.StackOverflowException;
/**
* An interface for a Stack
* Specific stack implementations will implement this interface
* For use Data Structures & Algorithms
*
*
* author unknown
*/
public interface StackADT<T> extends CollectionADT<T> {
/**
* Adds the specified element to the top of the stack
*
* @param element element to be pushed onto the stack
*/
public void push(T element) throws StackOverflowException;
/**
* Removes and returns the element that is on top of the stack
*
* @return the element removed from the stack
* @throws EmptyCollectionException
*/
public T pop() throws EmptyCollectionException;
/**
* Returns (without removing) the element that is on top of the stack
*
* @return the element on top of the stack
* @throws EmptyCollectionException
*/
public T peek() throws EmptyCollectionException;
}
*****************************************
package ADTs;
import Exceptions.*;
/**
* An interface for an ordered (NOT SORTED) List
* Elements stay in the order they are put in to the list
* For use in Data Structures & Algorithms
*
*
* @author unknown
*/
public interface ListADT<T> extends CollectionADT<T> {
/**
* Adds the specified element to the list at the front
*
* @param element: the element to be added
*
*/
public void addFirst(T element);
/**
* Adds the specified element to the end of the list
*
* @param element: the element to be added
*/
public void addLast(T element);
/**
* Adds the specified element to the list after the existing element
*
* @param existing: the element that is in the list already
* @param element: the element to be added
* @throws ElementNotFoundException if existing isn't in the list
*/
public void addAfter(T existing, T element) throws ElementNotFoundException,
EmptyCollectionException;
/**
* Removes and returns the specified element
*
* @return the element specified
* @throws EmptyCollectionException
* @throws ElementNotFoundException
*/
public T remove(T element) throws EmptyCollectionException, ElementNotFoundException;
/**
* Removes and returns the first element
*
* @return the first element in the list
* @throws EmptyCollectionException
*/
public T removeFirst() throws EmptyCollectionException;
/**
* Removes and returns the last element
*
* @return the last element in the list
* @throws EmptyCollectionException
*/
public T removeLast() throws EmptyCollectionException;
/**
* Returns (wit.
Similar to I need help in writing the test cases of the below methods i.pdf (20)
How do I fix it in LinkedList.javaLabProgram.javaLinkedList.jav.pdf
How do I fix it in LinkedList.javaLabProgram.javaLinkedList.jav.pdf
package algs13;import stdlib.;import java.util.Iterator;im.docx
package algs13;import stdlib.;import java.util.Iterator;im.docx
Given below is the completed implementation of MyLinkedList class. O.pdf
Given below is the completed implementation of MyLinkedList class. O.pdf
Add functions push(int n- Deque &dq) and pop(Deque &dq)- Functions pus.docx
Add functions push(int n- Deque &dq) and pop(Deque &dq)- Functions pus.docx
Given the following ADT definition of a stack to use stack .docx
Given the following ADT definition of a stack to use stack .docx
Hi, Please find my code.I have correted all of your classes.Plea.pdf
Hi, Please find my code.I have correted all of your classes.Plea.pdf
EmptyCollectionException-java -- - Represents the situation in which.docx
EmptyCollectionException-java -- - Represents the situation in which.docx
public class DoubleArraySeq implements Cloneable { Priva.pdf
public class DoubleArraySeq implements Cloneable { Priva.pdf
Please review my code (java)Someone helped me with it but i cannot.pdf
Please review my code (java)Someone helped me with it but i cannot.pdf
I have a stack in Java populated with integers. Im trying to compa.pdf
I have a stack in Java populated with integers. Im trying to compa.pdf
AnswerNote Driver class is not given to test the DoubleArraySeq..pdf
AnswerNote Driver class is not given to test the DoubleArraySeq..pdf
In java , I want you to implement a Data Structure known as a Doubly.pdf
In java , I want you to implement a Data Structure known as a Doubly.pdf
import java-util-Iterator- import java-util-NoSuchElementException- im.pdf
import java-util-Iterator- import java-util-NoSuchElementException- im.pdf
Hi,I have added the methods and main class as per your requirement.pdf
Hi,I have added the methods and main class as per your requirement.pdf
For the code below complete the preOrder() method so that it perform.pdf
For the code below complete the preOrder() method so that it perform.pdf
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.pdf
PROBLEM STATEMENTIn this assignment, you will complete DoubleEnde.pdf
PROBLEM STATEMENTIn this assignment, you will complete DoubleEnde.pdf
Here is the editable codeSolutionimport java.util.NoSuchEleme.pdf
Here is the editable codeSolutionimport java.util.NoSuchEleme.pdf
1 The goal is to implement DataStructuresArrayStack accor.pdf
1 The goal is to implement DataStructuresArrayStack accor.pdf
More from adianantsolutions
Nancy acaba de vender algunas de sus acciones en Spotify Inc.pdf
Name at least a few trends that have business potential in your area. The trend can be regional,
national, or global. How did you go about identifying this trend? What makes you think there is a
potential business idea for your area based on this trend? What problem does it solve? Is this a
potential business idea you want to develop? If not, describe at least one potential business idea
that interests you and the problem it solves..
Name this accessory gland to the digestive systemName th.pdf
Nakatomi Lexus.Nakatomi Lexus buys its cars from Lexus Motors (U.S.), and sells them to U.S.
customers. One of its customers is EcoHire, a car rental firm that buys cars from Nakatomi Lexus
at a wholesale price. Final payment is due to Nakatomi Lexus in six months. EcoHire has bought
USD806 comma 000 worth of cars from Nakatomi, with a cash down payment of USD177 comma
320 and the balance due in six months without any interest charged as a sales incentive.
Nakatomi Lexus will have the EcoHire receivable accepted by Alliance Acceptance for a 1.7 %
fee, and then sell it at a 2.6 % per annum discount to Wells Fargo Bank. a. What is the annualized
percentage all-in cost to Nakatomi Lexus? b. What are Nakatomi's net cash proceeds, including
the cash down payment? (NOTE: Assume a 360-day year.)
a. What is the annualized percentage all-in cost to Nakatomi Lexus? b. What are Nakatomi's net
cash proceeds, including the cash down payment? (NOTE: Assume a 360-day year.) The amount
financed is $ (Round to the nearest cent.).
Name of Bacteria Observation Results E coli Yellow s.pdf
Nabais Corporation uses the weighted-average method in its process costing system. Operating
data for the Lubricating Department for the month of October appear below: What were the
equivalent units for conversion costs in the Lubricating Department for October? Multiple Choice
31,780 29,200 32,200 33,280The Richmond Corporation uses the weighted-average method in its
process costing system. The company has only a single processing department. The company's
ending work in process inventory on August 31 consisted of 18,000 units. The units in the ending
work in process inventory were 100% complete with respect to materials and 60% complete with
respect to labor and overhead. If the cost per equivalent unit for August was $2.75 for materials
and $4.25 for labor and overhead, the total cost assigned to the ending work in process inventory
was: Multiple Choice $95,400 $80,100 $126,000 $75,600Molzahn Corporation is a manufacturer
that uses job-order costing. The company closes out any overapplied or underapplied overhead to
Cost of Goods Sold at the end of the year. The company has supplied the following data for the
just completed year: Estimated total manufacturing overhead at the beginning of the year
Estimated direct labor-hours at the beginning of the year F Manufacturing overhead is overapplied
or underapplied by: (Do not round your intermediate calculations.) Multiple Choice $165,000
Overapplied $94,000 Underapplied $94,000 Overapplied $165,000 Underapplied.
Nasopharyngeal aspirates samples are used to investigate the.pdf
Nancy Cardoza invested $4,850 in ExxonMobil stock because her research indicated the stock
should earn an average return of 7 percent for the investors over the next six years. If ExxonMobil
investors do earn 7 percent each year, what will her $4,850 investment be worth at the end of six
years? Use Exhibit 1-A, Exhibit 1-B, Exhibit 1-C, Exhibit 1-D. Note: Use appropriate factor(s) from
the tables provided. Round time value factor to 3 decimal places and final answer.
Mutating His E7 the distal His in myoglobin to a Gly would.pdf
Mutating His E7 (the distal His) in myoglobin to a Gly would most likely: result in a protein with
increased affinity for oxygen. result in a protein with a dangerous increase in its affinity for CO.
result in a protein with decreased affinity for CO. not affect myoglobin's affinity for either diatomic
molecule..
Muthata1Calleingove LatinatLahr Nereant 1 17ar.pdf
Muthata:1.Calleingove LatinatLahr Nereant? 1. 17ar pese 3. Mevulis * Weat is the average Vou int
min and ral.1. Wia for ast danden." Presed dath in intuts in rarh theove dutb is a lakic ar erim 4.
WiwusienMaresibermells tharpit Mriaset.
Nadine LeMieux has just inherited 8000 She wants to use t.pdf
n this mentor-focised video check-in, you will review the Project Guidelines and Rubak document
in preparation tor the project that is doe in Prompt Module Nine and have an asynchronous
discussion with your instructor regarding any initial concerns about the same. You are higtly
encouraged to continue reaching out to your instructor so any concems and questions are
addiressed before the course project is de. Docus your progress and these concerns with vear
instructor through this video submission. Pecord a thort video in the Bongo Q&A tool, sharing your
expectations and understanding of the scenario and corresponding requirements: Addres the
followies criteria: 1. Stare vour thoughts and questions about the coure project, including any
questions or concems you have resarting: - Acquivition rationale - Dusiness envitoniment -.
Erecutive suinmary (parposeidetwes) 2. Share what you learned from completing the MScstone
Two assignent and any feediackyoureceived from the initructor including any quostions ven moy
have about the ame to make your hrui recammenations in the peopect sabemision. It yagi tuve
any additional questons or requare additional wppors trom your initructof let your im truct tor know
Guidelines for Submission vong fiongo mecond a video thas s 3-5 minutio lone..
NAD Participa en la hidrlisis de la sacarosa a glucosa e.pdf
n this informational memo you will discuss, with outside literature support for each section, the
following EHR components found in the textbook: a. Administrative Processes b. Communication
and Connectivity c. Decision Support d. Dentistry/Optometry e. Health Information and Data f.
Order Entry Management g. Patient Support, Results Management h. Population Health
Management..
Multi choice Which sequence represents the correct sequence .pdf
Multi choice
Which sequence represents the correct sequence for endosteal implant placement from start to
finish?
a. The titanium implant is surgically embedded into the bone.
b. The titanium abutment screw is screwed into the implant after osseointegration of the implant
and during stage II surgery.
c. The abutment post or cylinder attaches to the artificial tooth..
n2 1 let xPn Show that yv2x0X22n 2 Let x1x2.pdf
n September 17, 2011, protesters occupied Zuccotti Park in
the financial district of New York as part of a movement that became
known as Occupy Wall Street (OWS). Many of the protesters had been
inspired by the popular uprisings that had occurred in Egypt and Tunisia
in early 2011. The OWS protesters were opposed to what they perceived
to be the undue influence of banks and multinational corporations on the
political system. They believed that the wealthiest 1 percent of society
had a disproportionate share of capital and political influence, and they
used the slogan We are the 99% to highlight the problem of social and
economic inequality. The OWS led to the creation of the international
Occupy Movement, which has organized protests in dozens of countries
around the world. The occupation of Zuccotti Park ended on November
15, 2011, when the protesters were forcibly removed by the police. Imagine
that you are discussing issues of inequality and the power of the financial
sector with some of the Occupy Wall Street protesters in the fall of 2011.
How would you explain the implications of the structural dependence of
the state on capital to someone who doesn't understand why left-wing
parties do not always expropriate the rich when they come to power?.
n Faturalama Belgesi ilevini kullanmak iin n koullar nele.pdf
n a test of the effectiveness of garlic for lowering cholesterol, 48 subjects were treated with garlic
in a processed tablet form. Cholesterol levels were measured before and after the treatment. The
changes (beforeafter) in their levels of LDL cholesterol (in mg/dL) have a mean of 3.2 and a
standard deviation of 17.8. Construct a 95% confidence interval estimate of the mean net change
in LDL cholesterol after the garlic treatment. What does the confidence interval suggest about the
effectiveness.
Myra had high scores as cooperative team player evenkeele.pdf
myDict={1:2,3:4,5:6,7:8} What are the keys of the dictionary? 2,4,6,81,2,3,41,3,5,75,6,7,80,1,2,3
Question 2 1 pts myDict ={1:2,3:4,5:6,7:8} What are the values of the dictionary? 1,2,3,45,6,7,81,3
,5,70,1,2,32,4,6,8 Question 3 4 pts Match the syntax to the appropriate data type. List [ Choose ] "
" () Dictionary.
Mycobacterium tuberculosis infecta a casi 13 de la poblaci.pdf
My Topbar and Sidebar keeps appearing below my LandingPage and Login page, I have tried
separating into multiple functions and exporting, I have tried re-arranging the switch but nothing
works. Please help!!
Below are two methods I've tried, the 1st code doesn't work and so the Topbar and Sidebar still
shows
Here's the 1st code:
<code>
function App() {
return (
<Router>
<Switch>
<Route exact path="/">
<Landingpage />
</Route>
<Route path="/login">
<Login />
</Route>
<Route path="/">
<Appp />
</Route>
</Switch>
</Router>
);
}
function Appp() {
return (
<Router>
<div>
<Topbar />
<div className="container">
<Sidebar />
<Switch>
<Route path="/userProfile">
<UserProfile />
</Route>
<Route path="/project">
<Project />
</Route>
<Route path="/editProject">
<EditProject />
</Route>
<Route path="/testProject">
<TestProject />
</Route>
<Route path="/program">
<Program />
</Route>
<Route path="/users">
<UserList />
</Route>
<Route path="/user/:userId">
<User />
</Route>
<Route path="/newUser">
<NewUser />
</Route>
<Route path="/products">
<ProductList />
</Route>
<Route path="/product/:productId">
<Product />
</Route>
<Route path="/newproduct">
<NewProduct />
</Route>
<Route path="/curiMaps">
<CuriMaps />
</Route>
<Route path="/newMap">
<NewMap />
</Route>
<Route path="/home">
<Home />
</Route>
<Route path="/board">
<Board />
</Route>
</Switch>
</div>
</div>
</Router>
);
}
</code>
and the second code gives this error:
<code>
function App() {
return (
<Router>
<Switch>
<Route exact path="/">
<Landingpage />
</Route>
<Route path="/login">
<Login />
</Route>
<Route path="/">
<Appp />
</Route>
</Switch>
</Router>
);
}
function Appp() {
return (
<div>
<Topbar />
<div className="container">
<Sidebar />
<Switch>
<Route path="/userProfile">
<UserProfile />
</Route>
<Route path="/project">
<Project />
</Route>
<Route path="/editProject">
<EditProject />
</Route>
<Route path="/testProject">
<TestProject />
</Route>
<Route path="/program">
<Program />
</Route>
<Route path="/users">
<UserList />
</Route>
<Route path="/user/:userId">
<User />
</Route>
<Route path="/newUser">
<NewUser />
</Route>
<Route path="/products">
<ProductList />
</Route>
<Route path="/product/:productId">
<Product />
</Route>
<Route path="/newproduct">
<NewProduct />
</Route>
<Route path="/curiMaps">
<CuriMaps />
</Route>
<Route path="/newMap">
<NewMap />
</Route>
<Route path="/home">
<Home />
</Route>
<Route path="/board">
<Board />
</Route>
</Switch>
</div>
</div>
);
}
</code>
1 of 10 errars on the page Error: Invariant failed: You should not use outside a invariant
node_nodutes/tiny-inuariant/dist/tiny-imvariant.esn. js:10 (anonymous function) /Usc
ra/edwin1/Desktop/naduLes/Link. js:89 View conpiled - 20 stack franes were collapsed. This
screen is visithle only in devilgpenent. In will not appear if the app crasies in production. Open
your trawser's developer ecrisale to further inspect this errar. Clies the ' or hit ESC to dismiss this
message..
My library gt IT 145 Intro to Software Development home .pdf
My instructor wants us to use the d flip flop circuits.
Digital clock/ second unit: Design up counters to count 0 to 59 . Stack two up counters, the first
counter is module 10 (count from 0-9) and the second module 6 is Module 6 (count from 0-5). The
output of decoding 10 in the first counter is used to reset itself and start the second counter. Use a
logic simulator to verify your work.
My code is below How do I write this code without usin.pdf
My code is below...... How do I write this code without using arrays? I also need to write it without
using the while (true) or using a break statement. I need to use a prime read and a sentinel value
to control the repetition.
import java.text.DecimalFormat;
import java.util.Scanner;
public class AuthorPay2 {
public static void main(String[] args) {
//Declaring variables
double largestAmount = 0.0, avgAmt = 0.0, totAmount = 0.0;
int totNoOfPayments = 0;
//Creating an integer array
int[] countPayLevels = new int[3];
//DecimalFormat class is used to format the output
DecimalFormat df = new DecimalFormat(".00");
/*
*Creating an Scanner class object which is used to get the inputs
*entered by the user
*/
Scanner sc = new Scanner(System.in);
while (true) {
//Getting the input entered by the user
System.out.print("Enter the length of the story: ");
int length = sc.nextInt();
if (length != -1) {
System.out.print("Enter the level of the author: ");
char level = sc.next().charAt(0);
double amount = calculateAmount(length, level);
if (largestAmount < amount) {
largestAmount = amount;
}
totAmount += amount;
totNoOfPayments++;
if (level == 'A' || length == 'a') {
countPayLevels[0]++;
} else if (level == 'B' || length == 'b') {
countPayLevels[1]++;
} else if (level == 'C' || length == 'c') {
countPayLevels[2]++;
}
System.out.println("Length of the story: " + length + " Amount to be paid; $" + df.format(amount));
} else {
avgAmt = totAmount / totNoOfPayments;
System.out.println("nTotal no of payments: " + totNoOfPayments);
System.out.println("No of Payments made at level 'A': " + countPayLevels[0]);
System.out.println("No of Payments made at level 'B': " + countPayLevels[1]);
System.out.println("No of Payments made at level 'C': " + countPayLevels[2]);
System.out.printf("The average amount paid for a story: %.2fn", avgAmt);
System.out.printf("The largest amount paid for a story: %.2fn", largestAmount);
break;
}
}
}
private static double calculateAmount(int length, char level) {
double amount = 0.0;
if (length < 7500) {
amount = 0.08 * length;
} else if (length >= 7500 && length < 8000) {
amount = 600;
} else if (length >= 8000 && length < 17500) {
amount = 0.075 * length;
} else if (length >= 17500 && length <= 190000) {
amount = 1313;
} else if (length > 19000) {
amount = 0.07 * length;
}
if (level == 'A' || length == 'a') {
amount = 1.75 * amount;
} else if (level == 'B' || length == 'b') {
amount = 1.25 * amount;
}
return amount;
}
}.
My essay topic is Water Pollution in black Mississippi Jacks.pdf
My Code:
while True:
print(value1, end = '')
if value1 % 2 == 0:
print(format('*', '>6s'), end = '')
if value1 % 2 != 0:
print(format('*', '>2s'), end = '')
if integer_functions.is_prime(value1) == True:
print(format('*', '>2s'), end = '')
if integer_functions.is_perfect(value1) == True:
print(format('*', '>2s'), end = '')
if integer_functions.is_abundant(value1) == True:
print(format('*', '>2s'), end = '')
if integer_functions.are_first_and_last_digits_the_same(value1) == True:
print(format('*', '>2s'), end = '')
print(integer_functions.get_greatest_divisor(value1))
value1 += 1
if value1 > value2:
break.
Msrda renkli bir aleuron tohumun bir ksm bir maddenin var.pdf
Msrda, renkli bir aleuron (tohumun bir ksm) bir maddenin varlndan kaynaklanr.
R
alel;
r/r
renksizdir. Bitkinin rengini baka bir gen kontrol eder.
yi oyun
yap
sar ve
G_
yeil olmak. Genotipi bilinmeyen bir bitki apraz test edilir ve
aadaki nesil bitkiler elde edilmitir.
yeil renkli
89
sar renkli
13
renksiz yeil
9
renksiz sar
92
A.
apraz test iin kullanlan bitkinin fenotipi ve genotipi neydi?
B. Bitkiyi retmek iin kullanlan bitkilerin fenotipleri neydi?
bilinmeyen genotip? (Ebeveynlerin homozigot olduunu varsayalm.)
C. R yeri ile G yeri arasndaki yaklak harita mesafesi nedir?.
MRPnin baarl bir ekilde uygulanmas ve iletilmesi iin aadak.pdf
MRP'nin baarl bir ekilde uygulanmas ve iletilmesi iin aadakilerden hangisi kesinlikle gereklidir?
(I) doru envanter kaytlar
(II) ana programlar
(III) doru elde tutma ve n sipari maliyetleri
(IV) doru malzeme listeleri
Sadece I ve II
Yalnzca I, II ve III
Yalnzca I, II ve IV
I, II, III ve IV
Yalnzca I, III ve IV
Sadece I ve II
Yalnzca I, II ve III
Yalnzca I, II ve IV
I, II, III ve IV
Yalnzca I, III ve IV.
Mr senabe is a senior teacher in a secondary school he has.pdf
Mr senabe, is a senior teacher in a secondary school. he has received P15 000 as the best
teacher of the year. in addition, senabe was afforded a holiday in maun valued at P5000.during his
stay at a maun hotel, he played casino and won P500.yiu are required to discuss with reasons,
which amounts must be included in Mr senabe's Gross income ( 6 marks).
Multiple Choice that those genes are not useful in interpret.pdf
Multiple Choice that those genes are not useful in interpreting phylogeny. that Darwin was
incorrect in his idea about descent with modification. that Porifera are not animals, but rather the
most complex non-animal taxa. that those genes probably are related to the embryonic layers of
cells that will form tissues. that those genes probably are related to cell wall formation..
More from adianantsolutions (20)
Nancy acaba de vender algunas de sus acciones en Spotify Inc.pdf
Nancy acaba de vender algunas de sus acciones en Spotify Inc.pdf
Name this accessory gland to the digestive systemName th.pdf
Name this accessory gland to the digestive systemName th.pdf
Name of Bacteria Observation Results E coli Yellow s.pdf
Name of Bacteria Observation Results E coli Yellow s.pdf
Nasopharyngeal aspirates samples are used to investigate the.pdf
Nasopharyngeal aspirates samples are used to investigate the.pdf
Mutating His E7 the distal His in myoglobin to a Gly would.pdf
Mutating His E7 the distal His in myoglobin to a Gly would.pdf
Muthata1Calleingove LatinatLahr Nereant 1 17ar.pdf
Muthata1Calleingove LatinatLahr Nereant 1 17ar.pdf
Nadine LeMieux has just inherited 8000 She wants to use t.pdf
Nadine LeMieux has just inherited 8000 She wants to use t.pdf
NAD Participa en la hidrlisis de la sacarosa a glucosa e.pdf
NAD Participa en la hidrlisis de la sacarosa a glucosa e.pdf
Multi choice Which sequence represents the correct sequence .pdf
Multi choice Which sequence represents the correct sequence .pdf
n Faturalama Belgesi ilevini kullanmak iin n koullar nele.pdf
n Faturalama Belgesi ilevini kullanmak iin n koullar nele.pdf
Myra had high scores as cooperative team player evenkeele.pdf
Myra had high scores as cooperative team player evenkeele.pdf
Mycobacterium tuberculosis infecta a casi 13 de la poblaci.pdf
Mycobacterium tuberculosis infecta a casi 13 de la poblaci.pdf
My library gt IT 145 Intro to Software Development home .pdf
My library gt IT 145 Intro to Software Development home .pdf
My code is below How do I write this code without usin.pdf
My code is below How do I write this code without usin.pdf
My essay topic is Water Pollution in black Mississippi Jacks.pdf
My essay topic is Water Pollution in black Mississippi Jacks.pdf
Msrda renkli bir aleuron tohumun bir ksm bir maddenin var.pdf
Msrda renkli bir aleuron tohumun bir ksm bir maddenin var.pdf
MRPnin baarl bir ekilde uygulanmas ve iletilmesi iin aadak.pdf
MRPnin baarl bir ekilde uygulanmas ve iletilmesi iin aadak.pdf
Mr senabe is a senior teacher in a secondary school he has.pdf
Mr senabe is a senior teacher in a secondary school he has.pdf
Multiple Choice that those genes are not useful in interpret.pdf
Multiple Choice that those genes are not useful in interpret.pdf
Recently uploaded
Synthetic Fiber Construction in lab .pptx
Synthetic fiber production is a fascinating and complex field that blends chemistry, engineering, and environmental science. By understanding these aspects, students can gain a comprehensive view of synthetic fiber production, its impact on society and the environment, and the potential for future innovations. Synthetic fibers play a crucial role in modern society, impacting various aspects of daily life, industry, and the environment. ynthetic fibers are integral to modern life, offering a range of benefits from cost-effectiveness and versatility to innovative applications and performance characteristics. While they pose environmental challenges, ongoing research and development aim to create more sustainable and eco-friendly alternatives. Understanding the importance of synthetic fibers helps in appreciating their role in the economy, industry, and daily life, while also emphasizing the need for sustainable practices and innovation.
Introduction to AI for Nonprofits with Tapp Network
Dive into the world of AI! Experts Jon Hill and Tareq Monaur will guide you through AI's role in enhancing nonprofit websites and basic marketing strategies, making it easy to understand and apply.
CACJapan - GROUP Presentation 1- Wk 4.pdf
Macroeconomics- Movie Location
This will be used as part of your Personal Professional Portfolio once graded.
Objective:
Prepare a presentation or a paper using research, basic comparative analysis, data organization and application of economic information. You will make an informed assessment of an economic climate outside of the United States to accomplish an entertainment industry objective.
Unit 8 - Information and Communication Technology (Paper I).pdf
This slides describes the basic concepts of ICT, basics of Email, Emerging Technology and Digital Initiatives in Education. This presentations aligns with the UGC Paper I syllabus.
The Roman Empire A Historical Colossus.pdf
The Roman Empire, a vast and enduring power, stands as one of history's most remarkable civilizations, leaving an indelible imprint on the world. It emerged from the Roman Republic, transitioning into an imperial powerhouse under the leadership of Augustus Caesar in 27 BCE. This transformation marked the beginning of an era defined by unprecedented territorial expansion, architectural marvels, and profound cultural influence.
The empire's roots lie in the city of Rome, founded, according to legend, by Romulus in 753 BCE. Over centuries, Rome evolved from a small settlement to a formidable republic, characterized by a complex political system with elected officials and checks on power. However, internal strife, class conflicts, and military ambitions paved the way for the end of the Republic. Julius Caesar’s dictatorship and subsequent assassination in 44 BCE created a power vacuum, leading to a civil war. Octavian, later Augustus, emerged victorious, heralding the Roman Empire’s birth.
Under Augustus, the empire experienced the Pax Romana, a 200-year period of relative peace and stability. Augustus reformed the military, established efficient administrative systems, and initiated grand construction projects. The empire's borders expanded, encompassing territories from Britain to Egypt and from Spain to the Euphrates. Roman legions, renowned for their discipline and engineering prowess, secured and maintained these vast territories, building roads, fortifications, and cities that facilitated control and integration.
The Roman Empire’s society was hierarchical, with a rigid class system. At the top were the patricians, wealthy elites who held significant political power. Below them were the plebeians, free citizens with limited political influence, and the vast numbers of slaves who formed the backbone of the economy. The family unit was central, governed by the paterfamilias, the male head who held absolute authority.
Culturally, the Romans were eclectic, absorbing and adapting elements from the civilizations they encountered, particularly the Greeks. Roman art, literature, and philosophy reflected this synthesis, creating a rich cultural tapestry. Latin, the Roman language, became the lingua franca of the Western world, influencing numerous modern languages.
Roman architecture and engineering achievements were monumental. They perfected the arch, vault, and dome, constructing enduring structures like the Colosseum, Pantheon, and aqueducts. These engineering marvels not only showcased Roman ingenuity but also served practical purposes, from public entertainment to water supply.
Palestine last event orientationfvgnh .pptx
An EFL lesson about the current events in Palestine. It is intended to be for intermediate students who wish to increase their listening skills through a short lesson in power point.
Unit 2- Research Aptitude (UGC NET Paper I).pdf
This slide describes the research aptitude of unit 2 in the UGC NET paper I.
Model Attribute Check Company Auto Property
In Odoo, the multi-company feature allows you to manage multiple companies within a single Odoo database instance. Each company can have its own configurations while still sharing common resources such as products, customers, and suppliers.
TESDA TM1 REVIEWER FOR NATIONAL ASSESSMENT WRITTEN AND ORAL QUESTIONS WITH A...
TESDA TM1 REVIEWER FOR NATIONAL ASSESSMENT WRITTEN AND ORAL QUESTIONS WITH ANSWERS.
2024.06.01 Introducing a competency framework for languag learning materials ...
http://sandymillin.wordpress.com/iateflwebinar2024
Published classroom materials form the basis of syllabuses, drive teacher professional development, and have a potentially huge influence on learners, teachers and education systems. All teachers also create their own materials, whether a few sentences on a blackboard, a highly-structured fully-realised online course, or anything in between. Despite this, the knowledge and skills needed to create effective language learning materials are rarely part of teacher training, and are mostly learnt by trial and error.
Knowledge and skills frameworks, generally called competency frameworks, for ELT teachers, trainers and managers have existed for a few years now. However, until I created one for my MA dissertation, there wasn’t one drawing together what we need to know and do to be able to effectively produce language learning materials.
This webinar will introduce you to my framework, highlighting the key competencies I identified from my research. It will also show how anybody involved in language teaching (any language, not just English!), teacher training, managing schools or developing language learning materials can benefit from using the framework.
1.4 modern child centered education - mahatma gandhi-2.pptx
Child centred education is an educational approach that priorities the interest, needs and abilities of the child in the learning process.
"Protectable subject matters, Protection in biotechnology, Protection of othe...
Protectable subject matters, Protection in biotechnology, Protection of other biological materials, Ownership and period of protection
Biological Screening of Herbal Drugs in detailed.
Biological screening of herbal drugs: Introduction and Need for
Phyto-Pharmacological Screening, New Strategies for evaluating
Natural Products, In vitro evaluation techniques for Antioxidants, Antimicrobial and Anticancer drugs. In vivo evaluation techniques
for Anti-inflammatory, Antiulcer, Anticancer, Wound healing, Antidiabetic, Hepatoprotective, Cardio protective, Diuretics and
Antifertility, Toxicity studies as per OECD guidelines
Digital Tools and AI for Teaching Learning and Research
This Presentation in details discusses on Digital Tools and AI for Teaching Learning and Research
CLASS 11 CBSE B.St Project AIDS TO TRADE - INSURANCE
Class 11 CBSE Business Studies Project ( AIDS TO TRADE - INSURANCE)
How libraries can support authors with open access requirements for UKRI fund...
How libraries can support authors with open access requirements for UKRI funded books
Wednesday 22 May 2024, 14:00-15:00.
Acetabularia Information For Class 9 .docx
Acetabularia acetabulum is a single-celled green alga that in its vegetative state is morphologically differentiated into a basal rhizoid and an axially elongated stalk, which bears whorls of branching hairs. The single diploid nucleus resides in the rhizoid.
Recently uploaded (20)
Introduction to AI for Nonprofits with Tapp Network
Introduction to AI for Nonprofits with Tapp Network
Unit 8 - Information and Communication Technology (Paper I).pdf
Unit 8 - Information and Communication Technology (Paper I).pdf
TESDA TM1 REVIEWER FOR NATIONAL ASSESSMENT WRITTEN AND ORAL QUESTIONS WITH A...
TESDA TM1 REVIEWER FOR NATIONAL ASSESSMENT WRITTEN AND ORAL QUESTIONS WITH A...
2024.06.01 Introducing a competency framework for languag learning materials ...
2024.06.01 Introducing a competency framework for languag learning materials ...
1.4 modern child centered education - mahatma gandhi-2.pptx
1.4 modern child centered education - mahatma gandhi-2.pptx
"Protectable subject matters, Protection in biotechnology, Protection of othe...
"Protectable subject matters, Protection in biotechnology, Protection of othe...
Digital Tools and AI for Teaching Learning and Research
Digital Tools and AI for Teaching Learning and Research
CLASS 11 CBSE B.St Project AIDS TO TRADE - INSURANCE
CLASS 11 CBSE B.St Project AIDS TO TRADE - INSURANCE
How libraries can support authors with open access requirements for UKRI fund...
How libraries can support authors with open access requirements for UKRI fund...
I need help in writing the test cases of the below methods i.pdf
- 1. I need help in writing the test cases of the below methods in java. The test cases must test both empty and non empty deque.PLS HELP ME WITH WRITING THE TEST CASES IN JAVA.ITS URGENT. package deque; /** * A deque implemented using a doubly-linked chain. * * @param <T> * The type of elements contained in the deque. */ public class Lab08Deque<T> extends DLinkedDeque<T> { /** * Inserts a new item at the front of the deque. * * @param newEntry * the item to insert. */ public void addToFront(T newEntry) { DLNode<T> newNode = new DLNode<T>(newEntry); if (isEmpty()) { lastNode = newNode; } else { firstNode.setPreviousNode(newNode); } newNode.setNextNode(firstNode); firstNode = newNode; size++; throw new UnsupportedOperationException( "You have not implemented addToFront() yet"); } /** * Insert a new item at the rear of the deque. * * @param newEntry * the item to insert. */ public void addToBack(T newEntry) { DLNode<T> newNode = new DLNode<T>(newEntry); if (isEmpty()) { firstNode = newNode; }
- 2. else { lastNode.setPreviousNode(newNode); newNode.setPreviousNode(lastNode); } lastNode = newNode; size++; throw new UnsupportedOperationException( "You have not implemented addToBack() yet"); } /** * Remove the item at the front of the deque. * * @return The item that was removed * @throws EmptyQueueException * if there is not an element at the front */ public T removeFront() { if (isEmpty()) { throw new EmptyQueueException(); } T front = firstNode.getData(); firstNode = firstNode.getNextNode(); if (firstNode == null) { lastNode = null; } else { firstNode.setPreviousNode(null); } throw new UnsupportedOperationException( "You have not implemented removeFront() yet"); } /** * Remove the item at the rear of the deque. * * @return The item that was removed * @throws EmptyQueueException * if there is no element at the front */ public T removeBack() { if (isEmpty()) { throw new EmptyQueueException(); }
- 3. T data = lastNode.getData(); lastNode = lastNode.getPreviousNode(); if (lastNode == null) { firstNode = null; } else { lastNode.setPreviousNode(null); } throw new UnsupportedOperationException( "You have not implemented removeBack() yet"); } /** * Get the item at the front (the head) of the deque. Does not alter the * deque. * * @return the item at the front of the deque. * @throws EmptyQueueException * if no element at the front */ public T getFront() { if (isEmpty()) { throw new EmptyQueueException(); } return firstNode.getData(); } /** * Get the item at the rear (the tail) of the deque. Does not alter the * deque. * * @return the item at the rear of the deque. * @throws EmptyQueueException * if no element at rear * */ public T getBack() { if (isEmpty()) { throw new EmptyQueueException(); } return lastNode.getData(); } /** * Check if the deque is empty
- 4. * * @return true if the deque has no items */ public boolean isEmpty() { return size() == 0; } /** * Empty the deque. */ public void clear() { while (!isEmpty()) { removeFront(); } } // ---------------------------------------------------------- /** * Returns a string representation of this deque. A deque's string * representation is written as a comma-separated list of its contents (in * front-to-rear order) surrounded by square brackets, like this: * * [52, 14, 12, 119, 73, 80, 35] * * An empty deque is simply []. * * @return a string representation of the deque */ @Override public String toString() { StringBuilder s = new StringBuilder(); s.append("["); DLNode<T> p = firstNode; while (p != null) { if (s.length() > 1) { s.append(", "); } s.append(p.getData()); p = p.getNextNode(); } s.append("]"); return s.toString(); } }