Please find my implementationpublic KeyedItem remove() { DO.pdf
•
0 likes•2 views
Please find my implementation: public KeyedItem remove() { //DO THIS //remove the smallest item // since Linked List is in sorted order, so head is the samllest element if(head == null) return null; // return head element and move head one step forward KeyedItem item = head.getItem(); head = head.getNext(); return item; } private Node locateNodeAdd(KeyedItem item) { //DO THIS //find the insertion location (remember FIFO for duplicates) Node curr = head; Node prev = null; while(curr != null){ if((current.getItem().getKey()).compareTo(item.getKey) >= 0){ return prev; } prev = curr; curr = curr.getNext(); } return prev; } Solution Please find my implementation: public KeyedItem remove() { //DO THIS //remove the smallest item // since Linked List is in sorted order, so head is the samllest element if(head == null) return null; // return head element and move head one step forward KeyedItem item = head.getItem(); head = head.getNext(); return item; } private Node locateNodeAdd(KeyedItem item) { //DO THIS //find the insertion location (remember FIFO for duplicates) Node curr = head; Node prev = null; while(curr != null){ if((current.getItem().getKey()).compareTo(item.getKey) >= 0){ return prev; } prev = curr; curr = curr.getNext(); } return prev; }.
Report
Share
Report
Share
Download to read offline
Recommended
This is problem is same problem which i submitted on 22017, I just.pdf
There is a host of sociological and cultural research that paints a robust picture of the effects of
globalization on culture. This Application focuses on the flows of culture between Western and
developing nations. As a practitioner in this global environment, you should be familiar with
these culture effects. Use newspapers, magazines, and the Internet to research cultural changes in
both Western and developing countries due to globalization. Then perform the following tasks:
Outline the cultural aspects of globalization. Take an anthropological, rather than a business,
perspective. Explain how you think understanding culture helps in doing business in today\'s
global economy. Cite resources to justify your response.
Solution
Information technology has penetrated almost every aspect of our lives, “shrinking” our world
into a global village.
Economies and cultures have come closer. People are now aware of the cultures, traditions,
lifestyle, living conditions
prevailing in almost every corner of the world. Interestingly, this is going beyond awareness and
into a state of
integration that is a result of cross-pollinated views, ideologies, products and services.
This evolution is termed as “globalization.”
Culture has many definitions. My own definition is that culture is our collective experience as a
society,
and its impact on our reaction and decision-making relative to every-day facts and
circumstances.
Why is cross-cultural competence critical to your professional future and the viability of your
company?
It’s omnipresent in every business interaction and strategic decision.It is not feasible to be an
expert on
all the world’s cultures. It is possible, however, to incorporate a cross-cultural framework that
improves
cross-cultural understanding and interactions.
Multinational firms whose operations are borderless have to consider the cultural variability of
different regions
of the world and develop cultural understanding. Major cultural constraints encountered by
businesses include local
attitudes, taste preferences, language, religion, management style, gender discrimination, skills,
personalities,
education, etc. To be successful, they need to mold their business actions in accordance with the
local cultural models,
they need to establish a global mindset.
Let’s consider an example of the food giant, McDonald’s. The company enjoys a global
presence; operating in more than
100 countries serving 70 million people every day. Their headquarters and senior management
are U.S.-based but they
entrust their local operations to local managers of the countries they operate in. Operations in
more than 50 percent of
their outlets are franchised. Furthermore, their menus are customized according to cultural
habits and local taste
preferences in every country. It is without a doubt that global thinking and cultural
understanding are both powerful
business tools which allow multinational firms to dominate the local markets and establish a
global pres.
import java.util.Iterator; import java.util.NoSuchElementException; .pdf
import java.util.Iterator; import java.util.NoSuchElementException; /** * An implementation
of MyList with a linked list (a longer exercise would be to * implement the List interface as is
done in the class java.util.LinkedList: * the source of the LinkedList class is available from Sun.
Check it out). */ public class MyLinkedList implements MyList { // A private class to
represent a Node in the linked list private class Node { public E item;
public Node next; // a convenient constructor public Node(E o) {
this.item = o; this.next = null; } } // The start of the linked
list private Node head; // The last Node in the linked list private Node tail;
// Number of elements in the list private int size; /** * Creates an empty list (this
constructor is not necessary) */ public MyLinkedList() { } /** *
Returns the number of elements in this list. */ public int size() { return size;
} /** * Returns true if this list contains no elements. */ public boolean
isEmpty() { return size == 0; } /** * Appends the specified element to
the end of this list */ public boolean add(E o) { Node n = new Node(o);
// If this is the first element in the list if (head == null) { head = n;
} else { // If the list is not empty, use tail tail.next = n;
} // update tail tail = n; // update size size++;
return true; } /** * Empties this List */ public void clear() {
// update head, tail and size head = tail = null; size = 0; } /**
* Returns the element at the specified position in this list. */ public E get(int index) {
if (index < 0 || index >= size) { throw new
IndexOutOfBoundsException(\"index = \" + index); } // Find it
Node n = head; for (int i = 0; i < index; i++) { n = n.next; }
return n.item; } /** * Returns the index of the specified element (-1 if
there is no match) */ public int indexOf(Object o) { // If o is null
int index = 0; Node p = head; if (o == null) // look for a null element in the
list { while (p != null) { if (p.item == null) {
return index; } index++;
p = p.next; } } else // o is an object (use equals) {
while (p != null) { if (o.equals(p.item)) { return
index; } index++; p = p.next;
} } // if we get here, o is not in the list return -1; }
/** * Returns true if this list contains the specified element. */ public boolean
contains(Object o) { // easy with indexOf return indexOf(o) != -1; }
/** * Removes the element in the List at position index */ public boolean
remove(int index) { if (index < 0 || index >= size) { throw new
IndexOutOfBoundsException(\"index = \" + index); } // Find the
corresponding node Node prev = null, p = head; for (int i = 0; i < index; i++)
{ prev = p; p = p.next; } // Remove it
// Special case for the first node if (p == head) { head = head.next;
} else { prev.next = p.next; } // If the last node has been
removed, update tail if (p == tail) { tail = prev; } //
update size size--; return true; } /** * Removes the element
in the List at position index */ public boolean remove(Object o) { // easy
with indexOf and remove int index = i.
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.
In the class LinkedBinarySearchTree implement only the following metho.pdf
In the class LinkedBinarySearchTree implement only the following methods:
removeMax
findMin
findMax
import java.util.NoSuchElementException;
public class LinkedBinarySearchTree<E extends Comparable<E>>
extends LinkedBinaryTree<E>
implements BinarySearchTree<E> {
/**
* Creates an empty binary search tree.
*/
public LinkedBinarySearchTree() {
super();
}
/**
* Creates a binary search with the specified element as its root.
*
* @param element the element that will be the root of the new binary
* search tree
*/
public LinkedBinarySearchTree(E element) {
super(element);
}
@Override
public void add(E element) {
if (isEmpty()) { // Add as root of new tree
root = new LinkedBinaryTreeNode(element);
modCount += 1;
} else if (element.compareTo(root.element) < 0) { // Add to left subtree
if (root.left == null) {
root.left = new LinkedBinaryTreeNode(element);
} else {
add(element, root.left);
}
modCount += 1;
} else if (0 < element.compareTo(root.element)){ // Add to right subtree
if (root.right == null) {
root.right = new LinkedBinaryTreeNode(element);
} else {
add(element, root.right);
}
modCount += 1;
} else { // Element found in tree. Do not add to tree.
}
}
private void add(E element, LinkedBinaryTreeNode node) {
if (element.compareTo(node.element) < 0) { // Add to left subtree
if (node.left == null) {
node.left = new LinkedBinaryTreeNode(element);
} else {
add(element, node.left);
}
} else if (0 < element.compareTo(node.element)) { // Add to right subtree
if (node.right == null) {
node.right = new LinkedBinaryTreeNode(element);
} else {
add(element, node.right);
}
} else { // Element found in tree. Do not add to tree.
}
}
@Override
public E remove(E targetElement) {
if (isEmpty()) {
throw new NoSuchElementException("LinkedBinarySearchTree");
}
E result = null;
LinkedBinaryTreeNode parent = null;
if (targetElement.equals(root.element)) { // Target element found
result = root.element;
LinkedBinaryTreeNode temp = replacement(root);
if (temp == null) {
root = null;
} else {
root.element = temp.element;
root.right = temp.right;
root.left = temp.left;
}
modCount -= 1;
} else { // Target element not found
parent = root;
if (targetElement.compareTo(root.element) < 0) {
result = removeElement(targetElement, root.left, parent);
} else {
result = removeElement(targetElement, root.right, parent);
}
}
return result;
}
private E removeElement(E targetElement,
LinkedBinaryTreeNode node, LinkedBinaryTreeNode parent) {
if (node == null) {
throw new NoSuchElementException("LinkedBinarySearchTree");
}
E result = null;
if (targetElement.equals(node.element)) { // Target element found.
result = node.element;
LinkedBinaryTreeNode temp = replacement(node);
if (parent.right == node) {
parent.right = temp;
} else {
parent.left = temp;
}
modCount -= 1;
} else { // Target element not found
parent = node;
if (targetElement.compareTo(node.element) < 0) { // Look in left subtree
result = removeElement(targetElement, node.left, parent);
} else { // Look in right subtree
result = r.
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 .
#ifndef LINKED_LIST_ #define LINKED_LIST_ templateclass It.pdf
#ifndef LINKED_LIST_
#define LINKED_LIST_
template
class LinkedList {
private:
std::shared_ptr> headPtr; // Pointer to first node in the chain;
// (contains the first entry in the list)
int itemCount; // Current count of list items
std::shared_ptr> getNodeAt(int position) const;
public:
LinkedList();
LinkedList(const LinkedList& aList);
virtual ~LinkedList();
bool isEmpty() const;
int getLength() const;
bool insert(int newPosition, const ItemType& newEntry);
bool remove(int position);
void clear();
/** throw PrecondViolatedExcept if position < 1 or
position > getLength(). */
ItemType getEntry(int position) const throw(PrecondViolatedExcept);
/** throw PrecondViolatedExcept if position < 1 or
position > getLength(). */
void replace(int position, const ItemType& newEntry)
throw(PrecondViolatedExcept);
// Operator Overloading
void operator = (const LinkedList& arg);
friend std::ostream& operator << (std::ostream& os, const LinkedList& arg)
{
os << \"There are \" << arg.getLength() << \" values in the list:\" << std::endl;
for (int i{ 1 }; i <= arg.getLength(); i++) {
os << arg.getEntry(i) << std::endl;
}
os << std::endl << std::endl << std::endl << std::endl;
return os;
}
};
// Returns a pointer to the Node at the given position.
template
std::shared_ptr> LinkedList::getNodeAt (int position) const {
std::shared_ptr> currPtr{ headPtr };
for (int i{ 1 }; i < position; i++)
currPtr = currPtr->getNext();
return currPtr;
}
// Default constructor.
template
LinkedList::LinkedList() {
headPtr = nullptr;
itemCount = 0;
}
// Copy constructor.
template
LinkedList::LinkedList(const LinkedList& aList) {
itemCount = aList.getLength();
auto currPtr{ aList.headPtr };
auto newNodePtr{ headPtr = std::make_shared>(currPtr->getItem()) };
auto prevNodePtr{ newNodePtr };
currPtr = currPtr->getNext();
for (int i{ 2 }; i <= itemCount; i++) {
newNodePtr = std::make_shared>(currPtr->getItem());
prevNodePtr->setNext(newNodePtr);
prevNodePtr = newNodePtr;
currPtr = currPtr->getNext();
}
}
// Destructor.
template
LinkedList::~LinkedList() {
headPtr = nullptr;
itemCount = 0;
}
// Accessor/Info Functions.
template
bool LinkedList::isEmpty() const {
return (itemCount > 0)?0:1;
}
template
int LinkedList::getLength() const {
return itemCount;
}
// Places a Node at a given position (element at the same position is now pos+1).
template
bool LinkedList::insert(const int newPosition,
const ItemType& newEntry)
{
bool ableToInsert{ (newPosition >= 1) &&
(newPosition <= itemCount + 1) };
if (ableToInsert)
{
// Create a new node containing the new entry
auto newNodePtr{ std::make_shared>(newEntry) };
// Attach new node to chain
if (newPosition == 1)
{
// Insert new node at beginning of chain
newNodePtr->setNext(headPtr);
headPtr = newNodePtr;
}
else
{
// Find node that will be before new node
auto prevPtr{ getNodeAt(newPosition - 1) };
// Insert new node after node to which prevPtr points
newNodePtr->setNext(prevPtr->getNext());
prevPtr->setNext(newNodePtr);
} // end if
itemCount++; // .
In the class we extensively discussed a generic singly linked list i.pdf
In the class we extensively discussed a generic singly linked list implemented as a node class.
Implement a generic node class called DoublyNode in which each node contains an element of
type E and each node is linked not only forward to the next element in the list but also backward
to the previous element in the list. Your implementation should adapt and implement all the
methods of generic Node including the following methods:
Constructor for DoublyNode
addNodeAfter, removeNodeAfter
getData, setData
getForeLink, setForeLink
getBackLink, setBackLink
listCopy
listCopyWithTail
listLength
listPart
listPosition
listSearch
Solution
import java.util.ListIterator;
import java.util.NoSuchElementException;
import java.util.Random;
public class DoublyNode {
private Node head;
private Node tail;
private int size;
public DoublyNode() {
size = 0;
}
private class Node {
E element;
Node getForeNode;
Node getBackNode;
public Node(E element, Node next, Node prev) {
this.element = element;
this.getForeNode = next;
this.getBackNode = prev;
}
}
public int listLength() { return size; }
public boolean isEmpty() { return size == 0; }
public void addFirst(E element) {
Node tmp = new Node(element, head, null);
if(head != null ) {head.getBackNode = tmp;}
head = tmp;
if(tail == null) { tail = tmp;}
size++;
System.out.println(\"adding: \"+element);
}
public void addNodeAfter(E element) {
Node tmp = new Node(element, null, tail);
if(tail != null) {tail.getForeNode = tmp;}
tail = tmp;
if(head == null) { head = tmp;}
size++;
System.out.println(\"adding: \"+element);
}
public void addNodeAfterSpecifiedNode(E element, E tobeAddedAfter) {
Node prevTobeAddedAfter = listSearch(element);
Node afterNode = prevTobeAddedAfter.getForeNode;
Node tmpNode = new Node(element,prevTobeAddedAfter,afterNode);
tmpNode = prevTobeAddedAfter.getForeNode;
afterNode = tmpNode.getForeNode;
}
public void listCopy(){
System.out.println(\"iterating forward..\");
Node tmp = head;
while(tmp != null){
System.out.println(tmp.element);
tmp = tmp.getForeNode;
}
}
public Node listSearch(E item){
System.out.println(\"Searching Item \"+item);
Node tmp = head;
while(tmp != null){
System.out.println(tmp.element);
if(tmp.element == item) {
System.out.println(\"Item found \"+item);
return tmp;
}
tmp = tmp.getForeNode;
}
return null;
}
public void iterateBackward(){
System.out.println(\"iterating backword..\");
Node tmp = tail;
while(tmp != null){
System.out.println(tmp.element);
tmp = tmp.getBackNode;
}
}
public E removeFirst() {
if (size == 0) throw new NoSuchElementException();
Node tmp = head;
head = head.getForeNode;
head.getBackNode = null;
size--;
System.out.println(\"deleted: \"+tmp.element);
return tmp.element;
}
public E removeNodeAfter() {
if (size == 0) throw new NoSuchElementException();
Node tmp = tail;
tail = tail.getBackNode;
tail.getForeNode = null;
size--;
System.out.println(\"deleted: \"+tmp.element);
return tmp.element;
}
}.
Adding elements public void add(String element) { For fi.pdf
// Adding elements
public void add(String element) {
// For first element Head is null. So, create a new node and mark it as head.
// and increase numElements
if(head == null){
head = new StringNode(element, null);
numElements++;
} else {
// if not, find its place first.
// then create a node and mark position link to new node
// mark new node as link to positional node
StringNode node = head;
while(node.getLink() != null){
if(node.getData().compareTo(element) < 0){
break;
}
}
StringNode newNode = new StringNode(element, null);
newNode.setLink(node.getLink());
node.setLink(newNode);
numElements++;
}
}
// Removing elements
public boolean remove(String target)
{
StringNode targetNode = head;
boolean found = false;
while (targetNode!= null && !found)
{
if(targetNode.getData().equalsIgnoreCase(target))
found = true;
else
targetNode = targetNode.getLink();
}
if(found)
{
// copy the head to targetNode
// and then advance head to the next node.
targetNode.setData(targetNode.getLink().getData());
targetNode.setLink(targetNode.getLink());
numElements --;
}
return found;
}
Solution
// Adding elements
public void add(String element) {
// For first element Head is null. So, create a new node and mark it as head.
// and increase numElements
if(head == null){
head = new StringNode(element, null);
numElements++;
} else {
// if not, find its place first.
// then create a node and mark position link to new node
// mark new node as link to positional node
StringNode node = head;
while(node.getLink() != null){
if(node.getData().compareTo(element) < 0){
break;
}
}
StringNode newNode = new StringNode(element, null);
newNode.setLink(node.getLink());
node.setLink(newNode);
numElements++;
}
}
// Removing elements
public boolean remove(String target)
{
StringNode targetNode = head;
boolean found = false;
while (targetNode!= null && !found)
{
if(targetNode.getData().equalsIgnoreCase(target))
found = true;
else
targetNode = targetNode.getLink();
}
if(found)
{
// copy the head to targetNode
// and then advance head to the next node.
targetNode.setData(targetNode.getLink().getData());
targetNode.setLink(targetNode.getLink());
numElements --;
}
return found;
}.
Recommended
This is problem is same problem which i submitted on 22017, I just.pdf
There is a host of sociological and cultural research that paints a robust picture of the effects of
globalization on culture. This Application focuses on the flows of culture between Western and
developing nations. As a practitioner in this global environment, you should be familiar with
these culture effects. Use newspapers, magazines, and the Internet to research cultural changes in
both Western and developing countries due to globalization. Then perform the following tasks:
Outline the cultural aspects of globalization. Take an anthropological, rather than a business,
perspective. Explain how you think understanding culture helps in doing business in today\'s
global economy. Cite resources to justify your response.
Solution
Information technology has penetrated almost every aspect of our lives, “shrinking” our world
into a global village.
Economies and cultures have come closer. People are now aware of the cultures, traditions,
lifestyle, living conditions
prevailing in almost every corner of the world. Interestingly, this is going beyond awareness and
into a state of
integration that is a result of cross-pollinated views, ideologies, products and services.
This evolution is termed as “globalization.”
Culture has many definitions. My own definition is that culture is our collective experience as a
society,
and its impact on our reaction and decision-making relative to every-day facts and
circumstances.
Why is cross-cultural competence critical to your professional future and the viability of your
company?
It’s omnipresent in every business interaction and strategic decision.It is not feasible to be an
expert on
all the world’s cultures. It is possible, however, to incorporate a cross-cultural framework that
improves
cross-cultural understanding and interactions.
Multinational firms whose operations are borderless have to consider the cultural variability of
different regions
of the world and develop cultural understanding. Major cultural constraints encountered by
businesses include local
attitudes, taste preferences, language, religion, management style, gender discrimination, skills,
personalities,
education, etc. To be successful, they need to mold their business actions in accordance with the
local cultural models,
they need to establish a global mindset.
Let’s consider an example of the food giant, McDonald’s. The company enjoys a global
presence; operating in more than
100 countries serving 70 million people every day. Their headquarters and senior management
are U.S.-based but they
entrust their local operations to local managers of the countries they operate in. Operations in
more than 50 percent of
their outlets are franchised. Furthermore, their menus are customized according to cultural
habits and local taste
preferences in every country. It is without a doubt that global thinking and cultural
understanding are both powerful
business tools which allow multinational firms to dominate the local markets and establish a
global pres.
import java.util.Iterator; import java.util.NoSuchElementException; .pdf
import java.util.Iterator; import java.util.NoSuchElementException; /** * An implementation
of MyList with a linked list (a longer exercise would be to * implement the List interface as is
done in the class java.util.LinkedList: * the source of the LinkedList class is available from Sun.
Check it out). */ public class MyLinkedList implements MyList { // A private class to
represent a Node in the linked list private class Node { public E item;
public Node next; // a convenient constructor public Node(E o) {
this.item = o; this.next = null; } } // The start of the linked
list private Node head; // The last Node in the linked list private Node tail;
// Number of elements in the list private int size; /** * Creates an empty list (this
constructor is not necessary) */ public MyLinkedList() { } /** *
Returns the number of elements in this list. */ public int size() { return size;
} /** * Returns true if this list contains no elements. */ public boolean
isEmpty() { return size == 0; } /** * Appends the specified element to
the end of this list */ public boolean add(E o) { Node n = new Node(o);
// If this is the first element in the list if (head == null) { head = n;
} else { // If the list is not empty, use tail tail.next = n;
} // update tail tail = n; // update size size++;
return true; } /** * Empties this List */ public void clear() {
// update head, tail and size head = tail = null; size = 0; } /**
* Returns the element at the specified position in this list. */ public E get(int index) {
if (index < 0 || index >= size) { throw new
IndexOutOfBoundsException(\"index = \" + index); } // Find it
Node n = head; for (int i = 0; i < index; i++) { n = n.next; }
return n.item; } /** * Returns the index of the specified element (-1 if
there is no match) */ public int indexOf(Object o) { // If o is null
int index = 0; Node p = head; if (o == null) // look for a null element in the
list { while (p != null) { if (p.item == null) {
return index; } index++;
p = p.next; } } else // o is an object (use equals) {
while (p != null) { if (o.equals(p.item)) { return
index; } index++; p = p.next;
} } // if we get here, o is not in the list return -1; }
/** * Returns true if this list contains the specified element. */ public boolean
contains(Object o) { // easy with indexOf return indexOf(o) != -1; }
/** * Removes the element in the List at position index */ public boolean
remove(int index) { if (index < 0 || index >= size) { throw new
IndexOutOfBoundsException(\"index = \" + index); } // Find the
corresponding node Node prev = null, p = head; for (int i = 0; i < index; i++)
{ prev = p; p = p.next; } // Remove it
// Special case for the first node if (p == head) { head = head.next;
} else { prev.next = p.next; } // If the last node has been
removed, update tail if (p == tail) { tail = prev; } //
update size size--; return true; } /** * Removes the element
in the List at position index */ public boolean remove(Object o) { // easy
with indexOf and remove int index = i.
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.
In the class LinkedBinarySearchTree implement only the following metho.pdf
In the class LinkedBinarySearchTree implement only the following methods:
removeMax
findMin
findMax
import java.util.NoSuchElementException;
public class LinkedBinarySearchTree<E extends Comparable<E>>
extends LinkedBinaryTree<E>
implements BinarySearchTree<E> {
/**
* Creates an empty binary search tree.
*/
public LinkedBinarySearchTree() {
super();
}
/**
* Creates a binary search with the specified element as its root.
*
* @param element the element that will be the root of the new binary
* search tree
*/
public LinkedBinarySearchTree(E element) {
super(element);
}
@Override
public void add(E element) {
if (isEmpty()) { // Add as root of new tree
root = new LinkedBinaryTreeNode(element);
modCount += 1;
} else if (element.compareTo(root.element) < 0) { // Add to left subtree
if (root.left == null) {
root.left = new LinkedBinaryTreeNode(element);
} else {
add(element, root.left);
}
modCount += 1;
} else if (0 < element.compareTo(root.element)){ // Add to right subtree
if (root.right == null) {
root.right = new LinkedBinaryTreeNode(element);
} else {
add(element, root.right);
}
modCount += 1;
} else { // Element found in tree. Do not add to tree.
}
}
private void add(E element, LinkedBinaryTreeNode node) {
if (element.compareTo(node.element) < 0) { // Add to left subtree
if (node.left == null) {
node.left = new LinkedBinaryTreeNode(element);
} else {
add(element, node.left);
}
} else if (0 < element.compareTo(node.element)) { // Add to right subtree
if (node.right == null) {
node.right = new LinkedBinaryTreeNode(element);
} else {
add(element, node.right);
}
} else { // Element found in tree. Do not add to tree.
}
}
@Override
public E remove(E targetElement) {
if (isEmpty()) {
throw new NoSuchElementException("LinkedBinarySearchTree");
}
E result = null;
LinkedBinaryTreeNode parent = null;
if (targetElement.equals(root.element)) { // Target element found
result = root.element;
LinkedBinaryTreeNode temp = replacement(root);
if (temp == null) {
root = null;
} else {
root.element = temp.element;
root.right = temp.right;
root.left = temp.left;
}
modCount -= 1;
} else { // Target element not found
parent = root;
if (targetElement.compareTo(root.element) < 0) {
result = removeElement(targetElement, root.left, parent);
} else {
result = removeElement(targetElement, root.right, parent);
}
}
return result;
}
private E removeElement(E targetElement,
LinkedBinaryTreeNode node, LinkedBinaryTreeNode parent) {
if (node == null) {
throw new NoSuchElementException("LinkedBinarySearchTree");
}
E result = null;
if (targetElement.equals(node.element)) { // Target element found.
result = node.element;
LinkedBinaryTreeNode temp = replacement(node);
if (parent.right == node) {
parent.right = temp;
} else {
parent.left = temp;
}
modCount -= 1;
} else { // Target element not found
parent = node;
if (targetElement.compareTo(node.element) < 0) { // Look in left subtree
result = removeElement(targetElement, node.left, parent);
} else { // Look in right subtree
result = r.
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 .
#ifndef LINKED_LIST_ #define LINKED_LIST_ templateclass It.pdf
#ifndef LINKED_LIST_
#define LINKED_LIST_
template
class LinkedList {
private:
std::shared_ptr> headPtr; // Pointer to first node in the chain;
// (contains the first entry in the list)
int itemCount; // Current count of list items
std::shared_ptr> getNodeAt(int position) const;
public:
LinkedList();
LinkedList(const LinkedList& aList);
virtual ~LinkedList();
bool isEmpty() const;
int getLength() const;
bool insert(int newPosition, const ItemType& newEntry);
bool remove(int position);
void clear();
/** throw PrecondViolatedExcept if position < 1 or
position > getLength(). */
ItemType getEntry(int position) const throw(PrecondViolatedExcept);
/** throw PrecondViolatedExcept if position < 1 or
position > getLength(). */
void replace(int position, const ItemType& newEntry)
throw(PrecondViolatedExcept);
// Operator Overloading
void operator = (const LinkedList& arg);
friend std::ostream& operator << (std::ostream& os, const LinkedList& arg)
{
os << \"There are \" << arg.getLength() << \" values in the list:\" << std::endl;
for (int i{ 1 }; i <= arg.getLength(); i++) {
os << arg.getEntry(i) << std::endl;
}
os << std::endl << std::endl << std::endl << std::endl;
return os;
}
};
// Returns a pointer to the Node at the given position.
template
std::shared_ptr> LinkedList::getNodeAt (int position) const {
std::shared_ptr> currPtr{ headPtr };
for (int i{ 1 }; i < position; i++)
currPtr = currPtr->getNext();
return currPtr;
}
// Default constructor.
template
LinkedList::LinkedList() {
headPtr = nullptr;
itemCount = 0;
}
// Copy constructor.
template
LinkedList::LinkedList(const LinkedList& aList) {
itemCount = aList.getLength();
auto currPtr{ aList.headPtr };
auto newNodePtr{ headPtr = std::make_shared>(currPtr->getItem()) };
auto prevNodePtr{ newNodePtr };
currPtr = currPtr->getNext();
for (int i{ 2 }; i <= itemCount; i++) {
newNodePtr = std::make_shared>(currPtr->getItem());
prevNodePtr->setNext(newNodePtr);
prevNodePtr = newNodePtr;
currPtr = currPtr->getNext();
}
}
// Destructor.
template
LinkedList::~LinkedList() {
headPtr = nullptr;
itemCount = 0;
}
// Accessor/Info Functions.
template
bool LinkedList::isEmpty() const {
return (itemCount > 0)?0:1;
}
template
int LinkedList::getLength() const {
return itemCount;
}
// Places a Node at a given position (element at the same position is now pos+1).
template
bool LinkedList::insert(const int newPosition,
const ItemType& newEntry)
{
bool ableToInsert{ (newPosition >= 1) &&
(newPosition <= itemCount + 1) };
if (ableToInsert)
{
// Create a new node containing the new entry
auto newNodePtr{ std::make_shared>(newEntry) };
// Attach new node to chain
if (newPosition == 1)
{
// Insert new node at beginning of chain
newNodePtr->setNext(headPtr);
headPtr = newNodePtr;
}
else
{
// Find node that will be before new node
auto prevPtr{ getNodeAt(newPosition - 1) };
// Insert new node after node to which prevPtr points
newNodePtr->setNext(prevPtr->getNext());
prevPtr->setNext(newNodePtr);
} // end if
itemCount++; // .
In the class we extensively discussed a generic singly linked list i.pdf
In the class we extensively discussed a generic singly linked list implemented as a node class.
Implement a generic node class called DoublyNode in which each node contains an element of
type E and each node is linked not only forward to the next element in the list but also backward
to the previous element in the list. Your implementation should adapt and implement all the
methods of generic Node including the following methods:
Constructor for DoublyNode
addNodeAfter, removeNodeAfter
getData, setData
getForeLink, setForeLink
getBackLink, setBackLink
listCopy
listCopyWithTail
listLength
listPart
listPosition
listSearch
Solution
import java.util.ListIterator;
import java.util.NoSuchElementException;
import java.util.Random;
public class DoublyNode {
private Node head;
private Node tail;
private int size;
public DoublyNode() {
size = 0;
}
private class Node {
E element;
Node getForeNode;
Node getBackNode;
public Node(E element, Node next, Node prev) {
this.element = element;
this.getForeNode = next;
this.getBackNode = prev;
}
}
public int listLength() { return size; }
public boolean isEmpty() { return size == 0; }
public void addFirst(E element) {
Node tmp = new Node(element, head, null);
if(head != null ) {head.getBackNode = tmp;}
head = tmp;
if(tail == null) { tail = tmp;}
size++;
System.out.println(\"adding: \"+element);
}
public void addNodeAfter(E element) {
Node tmp = new Node(element, null, tail);
if(tail != null) {tail.getForeNode = tmp;}
tail = tmp;
if(head == null) { head = tmp;}
size++;
System.out.println(\"adding: \"+element);
}
public void addNodeAfterSpecifiedNode(E element, E tobeAddedAfter) {
Node prevTobeAddedAfter = listSearch(element);
Node afterNode = prevTobeAddedAfter.getForeNode;
Node tmpNode = new Node(element,prevTobeAddedAfter,afterNode);
tmpNode = prevTobeAddedAfter.getForeNode;
afterNode = tmpNode.getForeNode;
}
public void listCopy(){
System.out.println(\"iterating forward..\");
Node tmp = head;
while(tmp != null){
System.out.println(tmp.element);
tmp = tmp.getForeNode;
}
}
public Node listSearch(E item){
System.out.println(\"Searching Item \"+item);
Node tmp = head;
while(tmp != null){
System.out.println(tmp.element);
if(tmp.element == item) {
System.out.println(\"Item found \"+item);
return tmp;
}
tmp = tmp.getForeNode;
}
return null;
}
public void iterateBackward(){
System.out.println(\"iterating backword..\");
Node tmp = tail;
while(tmp != null){
System.out.println(tmp.element);
tmp = tmp.getBackNode;
}
}
public E removeFirst() {
if (size == 0) throw new NoSuchElementException();
Node tmp = head;
head = head.getForeNode;
head.getBackNode = null;
size--;
System.out.println(\"deleted: \"+tmp.element);
return tmp.element;
}
public E removeNodeAfter() {
if (size == 0) throw new NoSuchElementException();
Node tmp = tail;
tail = tail.getBackNode;
tail.getForeNode = null;
size--;
System.out.println(\"deleted: \"+tmp.element);
return tmp.element;
}
}.
Adding elements public void add(String element) { For fi.pdf
// Adding elements
public void add(String element) {
// For first element Head is null. So, create a new node and mark it as head.
// and increase numElements
if(head == null){
head = new StringNode(element, null);
numElements++;
} else {
// if not, find its place first.
// then create a node and mark position link to new node
// mark new node as link to positional node
StringNode node = head;
while(node.getLink() != null){
if(node.getData().compareTo(element) < 0){
break;
}
}
StringNode newNode = new StringNode(element, null);
newNode.setLink(node.getLink());
node.setLink(newNode);
numElements++;
}
}
// Removing elements
public boolean remove(String target)
{
StringNode targetNode = head;
boolean found = false;
while (targetNode!= null && !found)
{
if(targetNode.getData().equalsIgnoreCase(target))
found = true;
else
targetNode = targetNode.getLink();
}
if(found)
{
// copy the head to targetNode
// and then advance head to the next node.
targetNode.setData(targetNode.getLink().getData());
targetNode.setLink(targetNode.getLink());
numElements --;
}
return found;
}
Solution
// Adding elements
public void add(String element) {
// For first element Head is null. So, create a new node and mark it as head.
// and increase numElements
if(head == null){
head = new StringNode(element, null);
numElements++;
} else {
// if not, find its place first.
// then create a node and mark position link to new node
// mark new node as link to positional node
StringNode node = head;
while(node.getLink() != null){
if(node.getData().compareTo(element) < 0){
break;
}
}
StringNode newNode = new StringNode(element, null);
newNode.setLink(node.getLink());
node.setLink(newNode);
numElements++;
}
}
// Removing elements
public boolean remove(String target)
{
StringNode targetNode = head;
boolean found = false;
while (targetNode!= null && !found)
{
if(targetNode.getData().equalsIgnoreCase(target))
found = true;
else
targetNode = targetNode.getLink();
}
if(found)
{
// copy the head to targetNode
// and then advance head to the next node.
targetNode.setData(targetNode.getLink().getData());
targetNode.setLink(targetNode.getLink());
numElements --;
}
return found;
}.
The LinkedList1 class implements a Linked list. class.pdf
/**
The LinkedList1 class implements a Linked list.
*/
class LinkedList1
{
/**
The Node class stores a list element
and a reference to the next node.
*/
private class Node
{
String value;
Node next;
/**
Constructor.
@param val The element to store in the node.
@param n The reference to the successor node.
*/
Node(String val, Node n)
{
value = val;
next = n;
}
/**
Constructor.
@param val The element to store in the node.
*/
Node(String val)
{
// Call the other (sister) constructor.
this(val, null);
}
}
private Node first; // list head
private Node last; // last element in list
/**
Constructor.
*/
public LinkedList1()
{
first = null;
last = null;
}
/**
The isEmpty method checks to see
if the list is empty.
@return true if list is empty,
false otherwise.
*/
public boolean isEmpty()
{
return first == null;
}
/**
The size method returns the length of the list.
@return The number of elements in the list.
*/
public int size()
{
int count = 0;
Node p = first;
while (p != null)
{
// There is an element at p
count ++;
p = p.next;
}
return count;
}
/**
The add method adds an element to
the end of the list.
@param e The value to add to the
end of the list.
*/
public void add(String e)
{
if (isEmpty())
{
first = new Node(e);
last = first;
}
else
{
// Add to end of existing list
last.next = new Node(e);
last = last.next;
}
}
/**
The add method adds an element at a position.
@param e The element to add to the list.
@param index The position at which to add
the element.
@exception IndexOutOfBoundsException When
index is out of bounds.
*/
public void add(int index, String e)
{
if (index < 0 || index > size())
{
String message = String.valueOf(index);
throw new IndexOutOfBoundsException(message);
}
// Index is at least 0
if (index == 0)
{
// New element goes at beginning
first = new Node(e, first);
if (last == null)
last = first;
return;
}
// Set a reference pred to point to the node that
// will be the predecessor of the new node
Node pred = first;
for (int k = 1; k <= index - 1; k++)
{
pred = pred.next;
}
// Splice in a node containing the new element
pred.next = new Node(e, pred.next);
// Is there a new last element ?
if (pred.next.next == null)
last = pred.next;
}
/**
The toString method computes the string
representation of the list.
@return The string form of the list.
*/
public String toString()
{
StringBuilder strBuilder = new StringBuilder();
// Use p to walk down the linked list
Node p = first;
while (p != null)
{
strBuilder.append(p.value + \"\ \");
p = p.next;
}
return strBuilder.toString();
}
/**
The remove method removes the element at an index.
@param index The index of the element to remove.
@return The element removed.
@exception IndexOutOfBoundsException When index is
out of bounds.
*/
public String remove(int index)
{
if (index < 0 || index >= size())
{
String message = String.valueOf(index);
throw new IndexOutOfBoundsException(message);
}
String element; // The element to return
if (index == 0)
{
// Removal of first item in the list
element.
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.
Program to insert in a sorted list #includestdio.h#include.pdf
* Program to insert in a sorted list */
#include
#include
/* Link list node */
struct node
{
int data;
struct node* next;
};
/* function to insert a new_node in a list. Note that this
function expects a pointer to head_ref as this can modify the
head of the input linked list (similar to push())*/
void sortedInsert(struct node** head_ref, struct node* new_node)
{
struct node* current;
/* Special case for the head end */
if (*head_ref == NULL || (*head_ref)->data >= new_node->data)
{
new_node->next = *head_ref;
*head_ref = new_node;
}
else
{
/* Locate the node before the point of insertion */
current = *head_ref;
while (current->next!=NULL &&
current->next->data < new_node->data)
{
current = current->next;
}
new_node->next = current->next;
current->next = new_node;
}
}
/* BELOW FUNCTIONS ARE JUST UTILITY TO TEST sortedInsert */
/* A utility function to create a new node */
struct node *newNode(int new_data)
{
/* allocate node */
struct node* new_node =
(struct node*) malloc(sizeof(struct node));
/* put in the data */
new_node->data = new_data;
new_node->next = NULL;
return new_node;
}
/* Function to print linked list */
void printList(struct node *head)
{
struct node *temp = head;
while(temp != NULL)
{
printf(\"%d \", temp->data);
temp = temp->next;
}
}
/* Drier program to test count function*/
int main()
{
/* Start with the empty list */
struct node* head = NULL;
struct node *new_node = newNode(5);
sortedInsert(&head, new_node);
new_node = newNode(10);
sortedInsert(&head, new_node);
new_node = newNode(7);
sortedInsert(&head, new_node);
new_node = newNode(3);
sortedInsert(&head, new_node);
new_node = newNode(1);
sortedInsert(&head, new_node);
new_node = newNode(9);
sortedInsert(&head, new_node);
printf(\"\ Created Linked List\ \");
printList(head);
return 0;
}
public class Listnode {
//*** fields ***
private Object data;
private Listnode next;
//*** methods ***
// 2 constructors
public Listnode(Object d) {
this(d, null);
}
public Listnode(Object d, Listnode n) {
data = d;
next = n;
}
// access to fields
public Object getData() {
return data;
}
public Listnode getNext() {
return next;
}
// modify fields
public void setData(Object ob) {
data = ob;
}
public void setNext(Listnode n) {
next = n;
}
}
Thsi below program print out all the varibles in SLL
#include
#include
#include
/* Link list node */
struct node
{
int data;
struct node* next;
};
/* Given a reference (pointer to pointer) to the head
of a list and an int, push a new node on the front
of the list. */
void push(struct node** head_ref, int new_data)
{
/* allocate node */
struct node* new_node =
(struct node*) malloc(sizeof(struct node));
/* put in the data */
new_node->data = new_data;
/* link the old list off the new node */
new_node->next = (*head_ref);
/* move the head to point to the new node */
(*head_ref) = new_node;
}
/* Takes head pointer of the linked list and index
as arguments and return data at index*/
int GetNth(struct node* head, int index)
{
struct node* current = head;
int .
5. Design and implement a method contains 2 for BinarySearchTree, fu.pdf
5. Design and implement a method contains 2 for BinarySearchTree, functionall equivalent to
the contains method, that does not use recursion.
show the driver code and do this in java
this is the binarysearchtree
import java.util.*; // Iterator, Comparator
public class BinarySearchTree implements BSTInterface
{
protected BSTNode root; // reference to the root of this BST
protected Comparator comp; // used for all comparisons
protected boolean found; // used by remove
public BinarySearchTree()
// Precondition: T implements Comparable
// Creates an empty BST object - uses the natural order of elements.
{
root = null;
comp = new Comparator()
{
public int compare(T element1, T element2)
{
return ((Comparable)element1).compareTo(element2);
}
};
}
public BinarySearchTree(Comparator comp)
// Creates an empty BST object - uses Comparator comp for order
// of elements.
{
root = null;
this.comp = comp;
}
public boolean isFull()
// Returns false; this link-based BST is never full.
{
return false;
}
public boolean isEmpty()
// Returns true if this BST is empty; otherwise, returns false.
{
return (root == null);
}
public T min()
// If this BST is empty, returns null;
// otherwise returns the smallest element of the tree.
{
if (isEmpty())
return null;
else
{
BSTNode node = root;
while (node.getLeft() != null)
node = node.getLeft();
return node.getInfo();
}
}
public T max()
// If this BST is empty, returns null;
// otherwise returns the largest element of the tree.
{
if (isEmpty())
return null;
else
{
BSTNode node = root;
while (node.getRight() != null)
node = node.getRight();
return node.getInfo();
}
}
private int recSize(BSTNode node)
// Returns the number of elements in subtree rooted at node.
{
if (node == null)
return 0;
else
return 1 + recSize(node.getLeft()) + recSize(node.getRight());
}
public int size()
// Returns the number of elements in this BST.
{
return recSize(root);
}
public int size2()
// Returns the number of elements in this BST.
{
int count = 0;
if (root != null)
{
LinkedStack> nodeStack = new LinkedStack>();
BSTNode currNode;
nodeStack.push(root);
while (!nodeStack.isEmpty())
{
currNode = nodeStack.top();
nodeStack.pop();
count++;
if (currNode.getLeft() != null)
nodeStack.push(currNode.getLeft());
if (currNode.getRight() != null)
nodeStack.push(currNode.getRight());
}
}
return count;
}
private boolean recContains(T target, BSTNode node)
// Returns true if the subtree rooted at node contains info i such that
// comp.compare(target, i) == 0; otherwise, returns false.
{
if (node == null)
return false; // target is not found
else if (comp.compare(target, node.getInfo()) < 0)
return recContains(target, node.getLeft()); // Search left subtree
else if (comp.compare(target, node.getInfo()) > 0)
return recContains(target, node.getRight()); // Search right subtree
else
return true; // target is found
}
public boolean contains (T target)
// Returns true if this BST contains a node with info i such that
// comp.compare(target, i) == 0; otherwise, re.
Implement the additional 5 methods as indicated in the LinkedList fi.pdf
Implement a minimum spanning tree using Boruvka\'s algorithm.
Implement a minimum spanning tree using Boruvka\'s algorithm.
Solution
The psuedo code is as follows:
1 Graph input = /* read input */;
2 UnionFind uf (input.getNodes ());
3 Workset ws = input.getNodes();
4 foreach (Node n : ws) {
5 Edge e = minWeight (input.getOutEdges (n));
6 Node rep1 = uf.find (e.src);
7 Node rep2 = uf.find (e.dst);
8 if (rep1 != rep2) {
9 e.markInMST();
10 Node rep = uf.union (rep1, rep2);
11 ws.add (rep)
12 }
13 }.
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) Create a function called reverselist that will take a simple list.pdf
1) Create a function called reverselist that will take a simple list as a parameter and return the
reversed list. (We aren’t using the word reverse, since it is also the name of a built-in function.)
2) Create a function called deleteall that will take an item and a list as parameters, and return the
list with that item removed.
Solution
Hi, Please find my function.
Please let me know in case of any issue.
Let assume structure of node is:
/* Link list node */
struct node
{
int data;
struct node* next;
};
a)
/* Function to reverse the linked list */
struct node* reverse(struct node* head)
{
struct node* prev = NULL;
struct node* current = head;
struct node* next;
while (current != NULL)
{
next = current->next;
current->next = prev;
prev = current;
current = next;
}
return prev;
}
b)
struct node* deleteNode(struct node *head, int item)
{
if(head == NULL)
return NULL;
// When node to be deleted is head node
if(head->data == item)
{
return head->next;
}
// When not first node, follow the normal deletion process
// find the previous node
struct node *prev = head;
while(prev->next != NULL && prev->item != item)
prev = prev->next;
// Check if node really exists in Linked List
if(prev->next == NULL)
{
printf(\"\ Given node is not present in Linked List\");
}else{
// Remove node from Linked List
prev->next = prev->next->next;
}
return head;
}.
Write the Java source code necessary to build a solution for the pro.pdf
Write the Java source code necessary to build a solution for the problem below:
Create a MyLinkedList class. Create methods in the class to add an item to the head, tail, or
middle of a linked list; remove an item from the head, tail, or middle of a linked list; check the
size of the list; and search for an element in the list.
Create a test class to use the newly created MyLinkedList class. Add the following names in to
the list: James, John, Michael, Peter, Allison, Daniel, George, Simon, Jason, and Mark. Your
program should allow the user to enter a name from the console, and then search to see if the
name exists in the list.
Solution
Hi, Please find my implementation.
Please let me know in case of any issue.
public class MyLinkedList {
static class Node{
String data;
Node next;
Node(String d){
data = d;
next =null;
}
}
private Node head;
public MyLinkedList() {
head = null;
}
public void append(String data){
if(head == null)
head = new Node(data);
else{
Node temp = head;
while(temp.next != null)
temp = temp.next;
temp.next = new Node(data);
}
}
public void addFront(String data){
Node newNode = new Node(data);
newNode.next = head;
head = newNode;
}
public void removeFromLast(){
if(head == null || head.next == null)
head = null;
else{
Node temp = head;
while(temp.next.next != null)
temp = temp.next;
temp.next = null; // removing last element
}
}
public void removeFirst(){
if(head == null)
return;
else
head = head.next;
}
public boolean search(String data){
Node temp = head;
while(temp != null){
if(temp.data.equals(data))
return true;
temp = temp.next;
}
return false;
}
public void addAtMiddle(String data){
Node slow = head;
Node fast = head;
Node prev = null;
Node newNode = new Node(data);
if(head == null || head.next == null){
newNode.next = head;
head = newNode;
return;
}
while(fast != null && fast.next != null){
fast = fast.next.next;
prev = slow;
slow = slow.next;
}
if(prev != null)
prev.next =newNode;
newNode.next = slow;
}
public void removeAtMiddle(){
Node slow = head;
Node fast = head;
Node prev = null;
if(head == null || head.next == null){
head = null;
return;
}
while(fast != null && fast.next != null){
fast = fast.next.next;
prev = slow;
slow = slow.next;
}
prev.next = slow.next;
}
public void display(){
Node temp = head;
while(temp != null){
System.out.print(temp.data+\" \");
temp =temp.next;
}
System.out.println();
}
}
public class MyLinkedListTest {
public static void main(String[] args) {
MyLinkedList list = new MyLinkedList();
list.addAtMiddle(\"James\");
list.display();
list.addAtMiddle(\"John\");
list.display();
list.addAtMiddle(\"Michael\");
list.display();
list.addAtMiddle(\"Peter\");
list.display();
list.addAtMiddle(\"Allison\");
list.display();
list.addFront(\"Daniel\");
list.display();
list.append(\"George\");
list.display();
list.addFront(\"Simon\");
list.display();
list.append(\"Jason\");
list.display();
list.addAtMiddle(\"Mark\");
list.display();
list.removeAtMiddle();
list.display();
list.removeFirst();
list.displ.
implement the ListLinked ADT (the declaration is given in ListLinked.pdf
implement the ListLinked ADT (the declaration is given in ListLinked.h)(60 points)
- implement the following operations:
- constructor, assignment operator, destructor
- insert, remove, replace, clear
- isFull, isEmpty
- gotoBeginning, gotoEnd, gotoNext, gotoPrior, getCursor
implement the function moveToBeginning() that removes the data item marked by the cursor and
reinserts it at the beginning of the list
- implement the function insertBefore(..) that will insert the new data item before the cursor or if
the list is empty as the first element of the list
#include \"ListLinked.h\"
// ListNode member functions
template
List::ListNode::ListNode(const DataType& nodeData, ListNode* nextPtr)
{
this->dataItem = nodeData;
this->next = nextPtr;
}
// List member functions
template
List::List(int ignored = 0)
{
}
template
List::List(const List& other)
{
}
template
List& List::operator=(const List& other)
{
}
template
List::~List()
{
}
template
void List::insert(const DataType& newDataItem) throw (logic_error)
{
}
template
void List::remove() throw (logic_error)
{
}
template
void List::replace(const DataType& newDataItem) throw (logic_error)
{
}
template
void List::clear()
{
}
template
bool List::isEmpty() const
{
return false;
}
template
bool List::isFull() const
{
return false;
}
template
void List::gotoBeginning() throw (logic_error)
{
}
template
void List::gotoEnd() throw (logic_error)
{
}
template
bool List::gotoNext() throw (logic_error)
{
return false;
}
template
bool List::gotoPrior() throw (logic_error)
{
return false;
}
template
DataType List::getCursor() const throw (logic_error)
{
DataType t;
return t;
}
template
void List::moveToBeginning () throw (logic_error)
{
}
template
void List::insertBefore(const DataType& newDataItem) throw (logic_error)
{
}
#include \"show5.cpp\"
Solution
#include
#include
#include
using namespace std;
struct Node
{
int data;
Node *next;
};
Node *tail=NULL;
Node* Insert_atHead(Node *head, int data)
{
Node *temp=new Node;
temp->data=data;
temp->next=head;
head=temp;
return head;
}
Node* Insert_atTail(Node *head, int data)
{
Node *tail=head;
if(tail==NULL)
{
Node *temp = new Node;
temp->data=data;
temp->next=NULL;
head=temp;
return head;
}
while(tail!= NULL)
{
if(tail->next==NULL)
{
Node *temp=new Node;
temp->data=data;
temp->next=NULL;
tail->next=temp;
return tail;
}
else
{
tail=tail->next;
}
}
}
Node *Insert_atPosition(Node *head, int data, int position)
{
int i=0;
int j=position-1;
if(position==0)
{
Node *temp = new Node;
temp->data=data;
temp->next=head;
head=temp;
return head;
}
else
{
Node *temp=head;
while(inext;
i++;
}
Node *temp1 = new Node;
temp1->data=data;
temp1->next=temp->next;
temp->next=temp1;
return head;
}
return head;
}
Node* Delete(Node *head, int position)
{
Node *temp=head;
int i=1;
int j=position;
if(j==0)
{
head=head->next;
return head;
}
Node *temp1 = new Node;
while(j>0)
{
temp1=temp;
temp=temp->next;
j--;
}
temp1->next=temp->next;
delete temp;
return head;
}
int GetNode(Node *head,int posi.
Assignment 9 (Parent reference for BST) Redefine TreeNode by adding .pdf
Assignment 9 (Parent reference for BST) Redefine TreeNode by adding a reference to a node’s
parent, as shown below:
BST.TreeNode
#element
#left : TreeNode
#right: TreeNode
#parent: TreeNode
Implement the insert and delete methods in BST class to update the parent for each node in the
tree.
Add the following new method in BST:
/** Return the node for the specific element.
* Return null if the element is not in the tree. */
private TreeNode getNode(E element)
/** Returns true if the node for the element is a lead */
private boolean isLeaf(E element)
/** Returns the path of the element from the specific element to the root in an array list */
public ArrayList getPath(E e)
Write a test program that prompts the user to enter 10 integers, adds them to the tree, deletes the
first integer from the tree, and displays the paths for all leaf nodes.
Sample run
Enter 10 integers :
45 54 67 56 50 45 23 59 23 67
[50, 54, 23]
[59, 56, 67, 54, 23]
Solution
import java.util.NoSuchElementException; public class TreeSet> implements Set {
private TreeNode root; private int size; // Constructs an empty set. public
TreeSet() { root = null; size = 0; } // Adds the given value to this
set, if it was not already in the set. // If the element is already a member of this set, adding it
again has no effect. public void add(E value) { root = add(root, value); }
// private recursive helper for add // uses the \"x = change(x)\" pattern: // pass in
current state of root // return out desired new state of root private TreeNode
add(TreeNode node, E value) { if (node == null) { node = new
TreeNode(value); // reached dead end; put new node here size++; }
else if (value.compareTo(node.data) > 0) { node.right = add(node.right, value);
} else if (value.compareTo(node.data) < 0) { node.left = add(node.left,
value); } // else a duplicate; do nothing return node; } // Returns
true if this set contains the given element value. public boolean contains(E value) {
return contains(root, value); } // private recursive helper for contains private
boolean contains(TreeNode node, E value) { if (node == null) { return
false; } else if (value.compareTo(node.data) > 0) { return
contains(node.right, value); } else if (value.compareTo(node.data) < 0) {
return contains(node.left, value); } else { // value.equals(root.data);
found it! return true; } } // Returns the minimum value in this
set. // Throws a NoSuchElementException if this set is empty. public E getMin() {
if (root == null) { throw new NoSuchElementException(\"empty tree\");
} return getMin(root); } // private recursive helper for getMin
private E getMin(TreeNode node) { if (node.left == null) { return
node.data; } else { return getMin(node.left); } }
// Returns true if this set does not contain any elements. public boolean isEmpty() {
return size == 0; } // Prints all elements of this tree in a left-to-right order (in-order)
traversal. public void print() { print(root); } // private recursive helper
for print private void print(TreeNode .
How to do the main method for this programBinaryNode.javapublic.pdf
How to do the main method for this program?
BinaryNode.java
public class BinaryNode
implements Parent{
/** The item associated with this node. */
private E item;
/** The node at the root of the left subtree. */
private BinaryNode left;
/** The node at the root of the right subtree. */
private BinaryNode right;
/** Put item in a leaf node. */
public BinaryNode(E item) {
this.item = item;
// left and right are set to null by default
}
/** no-argument constructor sets everything to null */
public BinaryNode() {
item = null;
left = null;
right = null;
}
/** Put item in a node with the specified subtrees. */
public BinaryNode(E item, BinaryNode left,
BinaryNode right) {
this.item = item;
this.left = left;
this.right = right;
}
/** Put item in a node with the specified subtrees. */
public BinaryNode getChild(int direction) {
if (direction < 0) {
return left;
} else {
return right;
}
}
/** Return the item associated with this node. */
public E getItem() {
return item;
}
/** Return the root of the left subtree. */
public BinaryNode getLeft() {
return left;
}
/** Return the root of the right subtree. */
public BinaryNode getRight() {
return right;
}
/** Return true if this is a leaf. */
public boolean isLeaf() {
return (left == null) && (right == null);
}
/** Replace the item associated with this node. */
public void setItem(E item) {
this.item = item;
}
/** Replace the left subtree with the one rooted at left. */
public void setLeft(BinaryNode left) {
this.left = left;
}
/** Replace the right subtree with the one rooted at right. */
public void setRight(BinaryNode right) {
this.right = right;
}
public void setChild(int direction, BinaryNode child) {
if (direction < 0) {
left = child;
} else {
right = child;
}
}
/**
* Return the String representation of the tree rooted at this node
* traversed preorder.
**/
public String toStringPreorder() {
String result = \"\";
result += item;
if (left != null) {
result += left.toStringPreorder();
}
if (right != null) {
result += right.toStringPreorder();
}
return result;
}
/** Return a String representation of the tree rooted at this node
* traversed inorder.
**/
public String toStringInOrder() {
String result = \"\";
if (left != null) {
result += left.toStringInOrder();
}
result += item;
if (right != null) {
result += right.toStringInOrder();
}
return result;
}
/** Return a String representation of the tree rooted at this node,
* traversed postorder.
**/
public String toStringPostorder() {
String result = \"\";
if (left != null) {
result += left.toStringPostorder();
}
if (right != null) {
result += right.toStringPostorder();
}
result += item;
return result;
}
/**
* Return a String representation of the tree rooted at this node,
* traversed level order.
**/
public String toStringLevelOrder() {
String result = \"\";
Queue> q = new ArrayQueue>();
q.add (this);
while (!(q.isEmpty())) {
BinaryNode node = q.remove ();
result += node.item;
if (node.left != null) {
q.add(node.left);
}
if (node.right != null) {
q.add(node..
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.
Design, implement, test(In Java ) a doubly linked list ADT, using DL.pdf
Design, implement, test(In Java ) a doubly linked list ADT, using DLLNode objects as the
nodes. In addition to our standard list operations, your class should provide for backward
iteration through the list. To support this operation, it should export a resetBack method and get a
getPrevious method.To facilitate this, you may want to include an instance variable last that
always references the last element on the list.
DLLNODE.java
public class DLLNode extends LLNode
{
private DLLNode back;
public DLLNode(T info)
{
super(info);
back = null;
}
public void setBack(DLLNode back)
// Sets back link of this DLLNode.
{
this.back = back;
}
public DLLNode getBack()
// Returns back link of this DLLNode.
{
return back;
}
}
LLNODE.java
public class LLNode
{
private LLNode link;
private T info;
public LLNode(T info)
{
this.info = info;
link = null;
}
public void setInfo(T info)
// Sets info of this LLNode.
{
this.info = info;
}
public T getInfo()
// Returns info of this LLONode.
{
return info;
}
public void setLink(LLNode link)
// Sets link of this LLNode.
{
this.link = link;
}
public LLNode getLink()
// Returns link of this LLNode.
{
return link;
}
}
This list can be an unsorted list. My professor suggested to reference off the RefUnsortedList
ADT and modifying it to be a doubly linked list.you need to create resetBack and getPrevious
methods which means you will need another variable to keep track of where you are in the
backward iteration. It is not correct to use currentPos to keep track of the backward iteration, so
make another variable (reference) for this, maybe call it currentBackPos.
RefUnsortedList.java
public class RefUnsortedList implements ListInterface
{
protected int numElements; // number of elements in this list
protected LLNode currentPos; // current position for iteration
// set by find method
protected boolean found; // true if element found, else false
protected LLNode location; // node containing element, if found
protected LLNode previous; // node preceeding location
protected LLNode list; // first node on the list
public RefUnsortedList()
{
numElements = 0;
list = null;
currentPos = null;
}
public void add(T element)
// Adds element to this list.
{
LLNode newNode = new LLNode(element);
newNode.setLink(list);
list = newNode;
numElements++;
}
protected void find(T target)
// Searches list for an occurence of an element e such that
// e.equals(target). If successful, sets instance variables
// found to true, location to node containing e, and previous
// to the node that links to location. If not successful, sets
// found to false.
{
location = list;
found = false;
while (location != null)
{
if (location.getInfo().equals(target)) // if they match
{
found = true;
return;
}
else
{
previous = location;
location = location.getLink();
}
}
}
public int size()
// Returns the number of elements on this list.
{
return numElements;
}
public boolean contains (T element)
// Returns true if this list contains an element e such that
// e.equals(el.
Implement the following specification of UnsortedType using circular.pdf
Implement the following specification of UnsortedType using circular linked list as the
implementation structure.
*** I have seen this question answered here before but it is not a good answer. Can someone
please give me a original answer.***
// Deliverables:
// - A listing of the specification and implementation files for UnsortedType
// - A listing of the driver program for your test plan
// - A listing of the test plan as input to the driver.
// - A listing of the output from the driver.
template
struct NodeType;
/* Assumption: ItemType is a type for which the operators
\"<\" and \"==\" are defined-either an appropriate built-in type or a
class that overloads these operators. */
template
class UnsortedType
{
public:
// Class constructor, destructor, and copy constructor
UnsortedType();
~UnsortedType();
UnsortedType(const UnsortedType&);
void operator=(UnsortedType);
bool IsFull() const;
// Determines whether list is full.
//Post: Function value = (list is full)
int GetLength() const;
// Determines the number of elements in list.
// Post: Function value = number of elements in list.
void RetrieveItem(ItemType& item, bool& found);
// Retrieves list element whose key matches item\'s key
// (if present).
// Pre: Key member of item is initialized.
// Post: If there is an element someItem whose key matches
// item\'s key, then found = true and item is a copy of
// someItem; otherwise found = false and item is unchanged.
// List is unchanged.
void InsertItem(ItemType item);
// Adds item to list.
// Pre: List is not full.
// Item is not in list.
// Post: item is in list.
void DeleteItem(ItemType item);
// Deletes the element whose key matches item\'s key
// Pre: Key member of item is initialized.
// One and only one element in list has a key matching
// item\'s key.
// Post: No element in list has a key matching item\'s key.
void ResetList();
// Initializes current position for an iteration through the list.
// Post: Current position is prior to list.
void GetNextItem(ItemType&);
// Gets the next element in list.
// Pre: Current position is defined.
// Element at current position is not last in list.
// Post: Current position is updated to next position.
// item is a copy of element at current position.
private:
NodeType* listData;
int length;
NodeType* currentPos;
};
Solution
#include
#include
/* structure for a node */
struct node
{
int data;
struct node *next;
};
/* function to insert a new_node in a list in sorted way.
Note that this function expects a pointer to head node
as this can modify the head of the input linked list */
void sortedInsert(struct node** head_ref, struct node* new_node)
{
struct node* current = *head_ref;
// Case 1 of the above algo
if (current == NULL)
{
new_node->next = new_node;
*head_ref = new_node;
}
// Case 2 of the above algo
else if (current->data >= new_node->data)
{
/* If value is smaller than head\'s value then
we need to change next of last node */
while(current->next != *head_ref)
current = current->next;
cur.
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.
1)(JAVA) Extend the Binary Search Tree ADT to include a public metho.pdf
1)(JAVA) Extend the Binary Search Tree ADT to include a public method leafCount that returns
the number of leaf nodes in the tree.
Thank You in Advanced.
Below, I also have attached the BinarySearchTree and the Interface File.
BinarySearchTree:
//----------------------------------------------------------------------------
// BinarySearchTree.java by Dale/Joyce/Weems Chapter 8
//
// Defines all constructs for a reference-based BST
//----------------------------------------------------------------------------
package ch08.trees;
import ch05.queues.*;
import ch03.stacks.*;
import support.BSTNode;
public class BinarySearchTree>
implements BSTInterface
{
protected BSTNode root; // reference to the root of this BST
boolean found; // used by remove
// for traversals
protected LinkedUnbndQueue inOrderQueue; // queue of info
protected LinkedUnbndQueue preOrderQueue; // queue of info
protected LinkedUnbndQueue postOrderQueue; // queue of info
public BinarySearchTree()
// Creates an empty BST object.
{
root = null;
}
public boolean isEmpty()
// Returns true if this BST is empty; otherwise, returns false.
{
return (root == null);
}
private int recSize(BSTNode tree)
// Returns the number of elements in tree.
{
if (tree == null)
return 0;
else
return recSize(tree.getLeft()) + recSize(tree.getRight()) + 1;
}
public int size()
// Returns the number of elements in this BST.
{
return recSize(root);
}
public int size2()
// Returns the number of elements in this BST.
{
int count = 0;
if (root != null)
{
LinkedStack> hold = new LinkedStack>();
BSTNode currNode;
hold.push(root);
while (!hold.isEmpty())
{
currNode = hold.top();
hold.pop();
count++;
if (currNode.getLeft() != null)
hold.push(currNode.getLeft());
if (currNode.getRight() != null)
hold.push(currNode.getRight());
}
}
return count;
}
private boolean recContains(T element, BSTNode tree)
// Returns true if tree contains an element e such that
// e.compareTo(element) == 0; otherwise, returns false.
{
if (tree == null)
return false; // element is not found
else if (element.compareTo(tree.getInfo()) < 0)
return recContains(element, tree.getLeft()); // Search left subtree
else if (element.compareTo(tree.getInfo()) > 0)
return recContains(element, tree.getRight()); // Search right subtree
else
return true; // element is found
}
public boolean contains (T element)
// Returns true if this BST contains an element e such that
// e.compareTo(element) == 0; otherwise, returns false.
{
return recContains(element, root);
}
private T recGet(T element, BSTNode tree)
// Returns an element e from tree such that e.compareTo(element) == 0;
// if no such element exists, returns null.
{
if (tree == null)
return null; // element is not found
else if (element.compareTo(tree.getInfo()) < 0)
return recGet(element, tree.getLeft()); // get from left subtree
else
if (element.compareTo(tree.getInfo()) > 0)
return recGet(element, tree.getRight()); // get from right subtree
else
return tree.getInfo(); // element is found
}
public T get(T.
Javascript tid-bits
An introductory presentation I'm doing at my workplace for other developers. This is geared toward programmers that are very new to javascript and covers some basics, but focuses on Functions, Objects and prototypal inheritance ideas.
10. The push button is pushed to the second stop when we pipette out.pdf
10. The push button is pushed to the second stop when we pipette out or transfer the sample, and
to completely void the sample without leaving any sample in the pipette tips
11. The button is to be released after it is withdrawn from the solution/liquid. If it is released
prior to withdrawal, the solution reenters the pipette tip.
12. If the push button is pressed to the second stop and is released even before the pipette tip is
withdrawn from the solution, the solution enters the pipette.
13. When concentrations or dilutions of the sample that are to be transferred changes, when
different solutions or chemicals are transferred, when containment is required, tips need to be
changed with each transfer.
14. The fragments obtained will have blunt ends if the restriction enzyme cuts at the center. Yes.
They are still useful because linkers or adapters can be attached to the blunt end to make them
useful. Moreover, new restriction sites can be created by attaching linkers or adapters.
15. Yes it can be done. The restriction enzyme creates the same overhanging ends since it
recognizes the same restriction site in both the DNA. Therefore, the two different DNA can
basepair at the sticky ends.
Solution
10. The push button is pushed to the second stop when we pipette out or transfer the sample, and
to completely void the sample without leaving any sample in the pipette tips
11. The button is to be released after it is withdrawn from the solution/liquid. If it is released
prior to withdrawal, the solution reenters the pipette tip.
12. If the push button is pressed to the second stop and is released even before the pipette tip is
withdrawn from the solution, the solution enters the pipette.
13. When concentrations or dilutions of the sample that are to be transferred changes, when
different solutions or chemicals are transferred, when containment is required, tips need to be
changed with each transfer.
14. The fragments obtained will have blunt ends if the restriction enzyme cuts at the center. Yes.
They are still useful because linkers or adapters can be attached to the blunt end to make them
useful. Moreover, new restriction sites can be created by attaching linkers or adapters.
15. Yes it can be done. The restriction enzyme creates the same overhanging ends since it
recognizes the same restriction site in both the DNA. Therefore, the two different DNA can
basepair at the sticky ends..
1. Working capital is the capital that a company uses for its day to.pdf
1. Working capital is the capital that a company uses for its day to day operations. Working
capital is computed using the formula: Working capital = current assets – current liabilities.
2. Determinants of working capital requirements are – nature of business, seasonality of
operations, production policy, market conditions and conditions of supply. A service company
will have a lower working capital requirement than a manufacturing company. Firms with
seasonality in operations will have higher fluctuations with regards to their working capital
requirements. Market conditions in the form of degree of competition will affect working capital
requirements. Higher competitive pressure will increase working capital requirements.
3. Three major decisions that managers have to take while performing the finance function are:
(i) Investment decision – Managers have to select those assets that the business will invest in. It
is also known as capital budgeting decisions.
(ii) Financing decision – These decisions pertain to determining how the total funds that are
required for the business will be obtained – will it be through debt or equity or a mix of debt or
equity.
(iii) Dividend decision – This pertains to determining what quantum of earnings should be
distributed to shareholders as dividends and what quantum should be retained for meeting future
growth requirements of the company.
4. Financial management involves planning, directing, monitoring and controlling the monetary
resources of a company in such a manner that the goals and objectives of the company are
achieved in an efficient manner. It involves management of capital budgeting, capital structure,
working capital management, etc. Financial management is important as it helps an organization
to set clarity towards its financial goals and helps in efficient utilization of resources.
5. Cash flow is not a suitable judge of profitability as it merely shows the changes in cash
position of a firm in a financial year from its operating activities, from its financing activities and
from its investing activities. Cash flow statement does not help us to determine gross profit
margins, operating profit margins and net profit margins. We can just gauge the reason for
changes in cash position in a year.
6. Financial risk refers to all kinds of risk associated with a financial transaction and an
investment transaction. It can be in the form of credit risk, asset backed risk, investment risk etc.
These risks arise due to the fact that there is a probability of loss that is inherent in any financing
and investment method and this probability of loss cannot be avoided.
Solution
1. Working capital is the capital that a company uses for its day to day operations. Working
capital is computed using the formula: Working capital = current assets – current liabilities.
2. Determinants of working capital requirements are – nature of business, seasonality of
operations, production policy, market conditions and condi.
More Related Content
Similar to Please find my implementationpublic KeyedItem remove() { DO.pdf
The LinkedList1 class implements a Linked list. class.pdf
/**
The LinkedList1 class implements a Linked list.
*/
class LinkedList1
{
/**
The Node class stores a list element
and a reference to the next node.
*/
private class Node
{
String value;
Node next;
/**
Constructor.
@param val The element to store in the node.
@param n The reference to the successor node.
*/
Node(String val, Node n)
{
value = val;
next = n;
}
/**
Constructor.
@param val The element to store in the node.
*/
Node(String val)
{
// Call the other (sister) constructor.
this(val, null);
}
}
private Node first; // list head
private Node last; // last element in list
/**
Constructor.
*/
public LinkedList1()
{
first = null;
last = null;
}
/**
The isEmpty method checks to see
if the list is empty.
@return true if list is empty,
false otherwise.
*/
public boolean isEmpty()
{
return first == null;
}
/**
The size method returns the length of the list.
@return The number of elements in the list.
*/
public int size()
{
int count = 0;
Node p = first;
while (p != null)
{
// There is an element at p
count ++;
p = p.next;
}
return count;
}
/**
The add method adds an element to
the end of the list.
@param e The value to add to the
end of the list.
*/
public void add(String e)
{
if (isEmpty())
{
first = new Node(e);
last = first;
}
else
{
// Add to end of existing list
last.next = new Node(e);
last = last.next;
}
}
/**
The add method adds an element at a position.
@param e The element to add to the list.
@param index The position at which to add
the element.
@exception IndexOutOfBoundsException When
index is out of bounds.
*/
public void add(int index, String e)
{
if (index < 0 || index > size())
{
String message = String.valueOf(index);
throw new IndexOutOfBoundsException(message);
}
// Index is at least 0
if (index == 0)
{
// New element goes at beginning
first = new Node(e, first);
if (last == null)
last = first;
return;
}
// Set a reference pred to point to the node that
// will be the predecessor of the new node
Node pred = first;
for (int k = 1; k <= index - 1; k++)
{
pred = pred.next;
}
// Splice in a node containing the new element
pred.next = new Node(e, pred.next);
// Is there a new last element ?
if (pred.next.next == null)
last = pred.next;
}
/**
The toString method computes the string
representation of the list.
@return The string form of the list.
*/
public String toString()
{
StringBuilder strBuilder = new StringBuilder();
// Use p to walk down the linked list
Node p = first;
while (p != null)
{
strBuilder.append(p.value + \"\ \");
p = p.next;
}
return strBuilder.toString();
}
/**
The remove method removes the element at an index.
@param index The index of the element to remove.
@return The element removed.
@exception IndexOutOfBoundsException When index is
out of bounds.
*/
public String remove(int index)
{
if (index < 0 || index >= size())
{
String message = String.valueOf(index);
throw new IndexOutOfBoundsException(message);
}
String element; // The element to return
if (index == 0)
{
// Removal of first item in the list
element.
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.
Program to insert in a sorted list #includestdio.h#include.pdf
* Program to insert in a sorted list */
#include
#include
/* Link list node */
struct node
{
int data;
struct node* next;
};
/* function to insert a new_node in a list. Note that this
function expects a pointer to head_ref as this can modify the
head of the input linked list (similar to push())*/
void sortedInsert(struct node** head_ref, struct node* new_node)
{
struct node* current;
/* Special case for the head end */
if (*head_ref == NULL || (*head_ref)->data >= new_node->data)
{
new_node->next = *head_ref;
*head_ref = new_node;
}
else
{
/* Locate the node before the point of insertion */
current = *head_ref;
while (current->next!=NULL &&
current->next->data < new_node->data)
{
current = current->next;
}
new_node->next = current->next;
current->next = new_node;
}
}
/* BELOW FUNCTIONS ARE JUST UTILITY TO TEST sortedInsert */
/* A utility function to create a new node */
struct node *newNode(int new_data)
{
/* allocate node */
struct node* new_node =
(struct node*) malloc(sizeof(struct node));
/* put in the data */
new_node->data = new_data;
new_node->next = NULL;
return new_node;
}
/* Function to print linked list */
void printList(struct node *head)
{
struct node *temp = head;
while(temp != NULL)
{
printf(\"%d \", temp->data);
temp = temp->next;
}
}
/* Drier program to test count function*/
int main()
{
/* Start with the empty list */
struct node* head = NULL;
struct node *new_node = newNode(5);
sortedInsert(&head, new_node);
new_node = newNode(10);
sortedInsert(&head, new_node);
new_node = newNode(7);
sortedInsert(&head, new_node);
new_node = newNode(3);
sortedInsert(&head, new_node);
new_node = newNode(1);
sortedInsert(&head, new_node);
new_node = newNode(9);
sortedInsert(&head, new_node);
printf(\"\ Created Linked List\ \");
printList(head);
return 0;
}
public class Listnode {
//*** fields ***
private Object data;
private Listnode next;
//*** methods ***
// 2 constructors
public Listnode(Object d) {
this(d, null);
}
public Listnode(Object d, Listnode n) {
data = d;
next = n;
}
// access to fields
public Object getData() {
return data;
}
public Listnode getNext() {
return next;
}
// modify fields
public void setData(Object ob) {
data = ob;
}
public void setNext(Listnode n) {
next = n;
}
}
Thsi below program print out all the varibles in SLL
#include
#include
#include
/* Link list node */
struct node
{
int data;
struct node* next;
};
/* Given a reference (pointer to pointer) to the head
of a list and an int, push a new node on the front
of the list. */
void push(struct node** head_ref, int new_data)
{
/* allocate node */
struct node* new_node =
(struct node*) malloc(sizeof(struct node));
/* put in the data */
new_node->data = new_data;
/* link the old list off the new node */
new_node->next = (*head_ref);
/* move the head to point to the new node */
(*head_ref) = new_node;
}
/* Takes head pointer of the linked list and index
as arguments and return data at index*/
int GetNth(struct node* head, int index)
{
struct node* current = head;
int .
5. Design and implement a method contains 2 for BinarySearchTree, fu.pdf
5. Design and implement a method contains 2 for BinarySearchTree, functionall equivalent to
the contains method, that does not use recursion.
show the driver code and do this in java
this is the binarysearchtree
import java.util.*; // Iterator, Comparator
public class BinarySearchTree implements BSTInterface
{
protected BSTNode root; // reference to the root of this BST
protected Comparator comp; // used for all comparisons
protected boolean found; // used by remove
public BinarySearchTree()
// Precondition: T implements Comparable
// Creates an empty BST object - uses the natural order of elements.
{
root = null;
comp = new Comparator()
{
public int compare(T element1, T element2)
{
return ((Comparable)element1).compareTo(element2);
}
};
}
public BinarySearchTree(Comparator comp)
// Creates an empty BST object - uses Comparator comp for order
// of elements.
{
root = null;
this.comp = comp;
}
public boolean isFull()
// Returns false; this link-based BST is never full.
{
return false;
}
public boolean isEmpty()
// Returns true if this BST is empty; otherwise, returns false.
{
return (root == null);
}
public T min()
// If this BST is empty, returns null;
// otherwise returns the smallest element of the tree.
{
if (isEmpty())
return null;
else
{
BSTNode node = root;
while (node.getLeft() != null)
node = node.getLeft();
return node.getInfo();
}
}
public T max()
// If this BST is empty, returns null;
// otherwise returns the largest element of the tree.
{
if (isEmpty())
return null;
else
{
BSTNode node = root;
while (node.getRight() != null)
node = node.getRight();
return node.getInfo();
}
}
private int recSize(BSTNode node)
// Returns the number of elements in subtree rooted at node.
{
if (node == null)
return 0;
else
return 1 + recSize(node.getLeft()) + recSize(node.getRight());
}
public int size()
// Returns the number of elements in this BST.
{
return recSize(root);
}
public int size2()
// Returns the number of elements in this BST.
{
int count = 0;
if (root != null)
{
LinkedStack> nodeStack = new LinkedStack>();
BSTNode currNode;
nodeStack.push(root);
while (!nodeStack.isEmpty())
{
currNode = nodeStack.top();
nodeStack.pop();
count++;
if (currNode.getLeft() != null)
nodeStack.push(currNode.getLeft());
if (currNode.getRight() != null)
nodeStack.push(currNode.getRight());
}
}
return count;
}
private boolean recContains(T target, BSTNode node)
// Returns true if the subtree rooted at node contains info i such that
// comp.compare(target, i) == 0; otherwise, returns false.
{
if (node == null)
return false; // target is not found
else if (comp.compare(target, node.getInfo()) < 0)
return recContains(target, node.getLeft()); // Search left subtree
else if (comp.compare(target, node.getInfo()) > 0)
return recContains(target, node.getRight()); // Search right subtree
else
return true; // target is found
}
public boolean contains (T target)
// Returns true if this BST contains a node with info i such that
// comp.compare(target, i) == 0; otherwise, re.
Implement the additional 5 methods as indicated in the LinkedList fi.pdf
Implement a minimum spanning tree using Boruvka\'s algorithm.
Implement a minimum spanning tree using Boruvka\'s algorithm.
Solution
The psuedo code is as follows:
1 Graph input = /* read input */;
2 UnionFind uf (input.getNodes ());
3 Workset ws = input.getNodes();
4 foreach (Node n : ws) {
5 Edge e = minWeight (input.getOutEdges (n));
6 Node rep1 = uf.find (e.src);
7 Node rep2 = uf.find (e.dst);
8 if (rep1 != rep2) {
9 e.markInMST();
10 Node rep = uf.union (rep1, rep2);
11 ws.add (rep)
12 }
13 }.
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) Create a function called reverselist that will take a simple list.pdf
1) Create a function called reverselist that will take a simple list as a parameter and return the
reversed list. (We aren’t using the word reverse, since it is also the name of a built-in function.)
2) Create a function called deleteall that will take an item and a list as parameters, and return the
list with that item removed.
Solution
Hi, Please find my function.
Please let me know in case of any issue.
Let assume structure of node is:
/* Link list node */
struct node
{
int data;
struct node* next;
};
a)
/* Function to reverse the linked list */
struct node* reverse(struct node* head)
{
struct node* prev = NULL;
struct node* current = head;
struct node* next;
while (current != NULL)
{
next = current->next;
current->next = prev;
prev = current;
current = next;
}
return prev;
}
b)
struct node* deleteNode(struct node *head, int item)
{
if(head == NULL)
return NULL;
// When node to be deleted is head node
if(head->data == item)
{
return head->next;
}
// When not first node, follow the normal deletion process
// find the previous node
struct node *prev = head;
while(prev->next != NULL && prev->item != item)
prev = prev->next;
// Check if node really exists in Linked List
if(prev->next == NULL)
{
printf(\"\ Given node is not present in Linked List\");
}else{
// Remove node from Linked List
prev->next = prev->next->next;
}
return head;
}.
Write the Java source code necessary to build a solution for the pro.pdf
Write the Java source code necessary to build a solution for the problem below:
Create a MyLinkedList class. Create methods in the class to add an item to the head, tail, or
middle of a linked list; remove an item from the head, tail, or middle of a linked list; check the
size of the list; and search for an element in the list.
Create a test class to use the newly created MyLinkedList class. Add the following names in to
the list: James, John, Michael, Peter, Allison, Daniel, George, Simon, Jason, and Mark. Your
program should allow the user to enter a name from the console, and then search to see if the
name exists in the list.
Solution
Hi, Please find my implementation.
Please let me know in case of any issue.
public class MyLinkedList {
static class Node{
String data;
Node next;
Node(String d){
data = d;
next =null;
}
}
private Node head;
public MyLinkedList() {
head = null;
}
public void append(String data){
if(head == null)
head = new Node(data);
else{
Node temp = head;
while(temp.next != null)
temp = temp.next;
temp.next = new Node(data);
}
}
public void addFront(String data){
Node newNode = new Node(data);
newNode.next = head;
head = newNode;
}
public void removeFromLast(){
if(head == null || head.next == null)
head = null;
else{
Node temp = head;
while(temp.next.next != null)
temp = temp.next;
temp.next = null; // removing last element
}
}
public void removeFirst(){
if(head == null)
return;
else
head = head.next;
}
public boolean search(String data){
Node temp = head;
while(temp != null){
if(temp.data.equals(data))
return true;
temp = temp.next;
}
return false;
}
public void addAtMiddle(String data){
Node slow = head;
Node fast = head;
Node prev = null;
Node newNode = new Node(data);
if(head == null || head.next == null){
newNode.next = head;
head = newNode;
return;
}
while(fast != null && fast.next != null){
fast = fast.next.next;
prev = slow;
slow = slow.next;
}
if(prev != null)
prev.next =newNode;
newNode.next = slow;
}
public void removeAtMiddle(){
Node slow = head;
Node fast = head;
Node prev = null;
if(head == null || head.next == null){
head = null;
return;
}
while(fast != null && fast.next != null){
fast = fast.next.next;
prev = slow;
slow = slow.next;
}
prev.next = slow.next;
}
public void display(){
Node temp = head;
while(temp != null){
System.out.print(temp.data+\" \");
temp =temp.next;
}
System.out.println();
}
}
public class MyLinkedListTest {
public static void main(String[] args) {
MyLinkedList list = new MyLinkedList();
list.addAtMiddle(\"James\");
list.display();
list.addAtMiddle(\"John\");
list.display();
list.addAtMiddle(\"Michael\");
list.display();
list.addAtMiddle(\"Peter\");
list.display();
list.addAtMiddle(\"Allison\");
list.display();
list.addFront(\"Daniel\");
list.display();
list.append(\"George\");
list.display();
list.addFront(\"Simon\");
list.display();
list.append(\"Jason\");
list.display();
list.addAtMiddle(\"Mark\");
list.display();
list.removeAtMiddle();
list.display();
list.removeFirst();
list.displ.
implement the ListLinked ADT (the declaration is given in ListLinked.pdf
implement the ListLinked ADT (the declaration is given in ListLinked.h)(60 points)
- implement the following operations:
- constructor, assignment operator, destructor
- insert, remove, replace, clear
- isFull, isEmpty
- gotoBeginning, gotoEnd, gotoNext, gotoPrior, getCursor
implement the function moveToBeginning() that removes the data item marked by the cursor and
reinserts it at the beginning of the list
- implement the function insertBefore(..) that will insert the new data item before the cursor or if
the list is empty as the first element of the list
#include \"ListLinked.h\"
// ListNode member functions
template
List::ListNode::ListNode(const DataType& nodeData, ListNode* nextPtr)
{
this->dataItem = nodeData;
this->next = nextPtr;
}
// List member functions
template
List::List(int ignored = 0)
{
}
template
List::List(const List& other)
{
}
template
List& List::operator=(const List& other)
{
}
template
List::~List()
{
}
template
void List::insert(const DataType& newDataItem) throw (logic_error)
{
}
template
void List::remove() throw (logic_error)
{
}
template
void List::replace(const DataType& newDataItem) throw (logic_error)
{
}
template
void List::clear()
{
}
template
bool List::isEmpty() const
{
return false;
}
template
bool List::isFull() const
{
return false;
}
template
void List::gotoBeginning() throw (logic_error)
{
}
template
void List::gotoEnd() throw (logic_error)
{
}
template
bool List::gotoNext() throw (logic_error)
{
return false;
}
template
bool List::gotoPrior() throw (logic_error)
{
return false;
}
template
DataType List::getCursor() const throw (logic_error)
{
DataType t;
return t;
}
template
void List::moveToBeginning () throw (logic_error)
{
}
template
void List::insertBefore(const DataType& newDataItem) throw (logic_error)
{
}
#include \"show5.cpp\"
Solution
#include
#include
#include
using namespace std;
struct Node
{
int data;
Node *next;
};
Node *tail=NULL;
Node* Insert_atHead(Node *head, int data)
{
Node *temp=new Node;
temp->data=data;
temp->next=head;
head=temp;
return head;
}
Node* Insert_atTail(Node *head, int data)
{
Node *tail=head;
if(tail==NULL)
{
Node *temp = new Node;
temp->data=data;
temp->next=NULL;
head=temp;
return head;
}
while(tail!= NULL)
{
if(tail->next==NULL)
{
Node *temp=new Node;
temp->data=data;
temp->next=NULL;
tail->next=temp;
return tail;
}
else
{
tail=tail->next;
}
}
}
Node *Insert_atPosition(Node *head, int data, int position)
{
int i=0;
int j=position-1;
if(position==0)
{
Node *temp = new Node;
temp->data=data;
temp->next=head;
head=temp;
return head;
}
else
{
Node *temp=head;
while(inext;
i++;
}
Node *temp1 = new Node;
temp1->data=data;
temp1->next=temp->next;
temp->next=temp1;
return head;
}
return head;
}
Node* Delete(Node *head, int position)
{
Node *temp=head;
int i=1;
int j=position;
if(j==0)
{
head=head->next;
return head;
}
Node *temp1 = new Node;
while(j>0)
{
temp1=temp;
temp=temp->next;
j--;
}
temp1->next=temp->next;
delete temp;
return head;
}
int GetNode(Node *head,int posi.
Assignment 9 (Parent reference for BST) Redefine TreeNode by adding .pdf
Assignment 9 (Parent reference for BST) Redefine TreeNode by adding a reference to a node’s
parent, as shown below:
BST.TreeNode
#element
#left : TreeNode
#right: TreeNode
#parent: TreeNode
Implement the insert and delete methods in BST class to update the parent for each node in the
tree.
Add the following new method in BST:
/** Return the node for the specific element.
* Return null if the element is not in the tree. */
private TreeNode getNode(E element)
/** Returns true if the node for the element is a lead */
private boolean isLeaf(E element)
/** Returns the path of the element from the specific element to the root in an array list */
public ArrayList getPath(E e)
Write a test program that prompts the user to enter 10 integers, adds them to the tree, deletes the
first integer from the tree, and displays the paths for all leaf nodes.
Sample run
Enter 10 integers :
45 54 67 56 50 45 23 59 23 67
[50, 54, 23]
[59, 56, 67, 54, 23]
Solution
import java.util.NoSuchElementException; public class TreeSet> implements Set {
private TreeNode root; private int size; // Constructs an empty set. public
TreeSet() { root = null; size = 0; } // Adds the given value to this
set, if it was not already in the set. // If the element is already a member of this set, adding it
again has no effect. public void add(E value) { root = add(root, value); }
// private recursive helper for add // uses the \"x = change(x)\" pattern: // pass in
current state of root // return out desired new state of root private TreeNode
add(TreeNode node, E value) { if (node == null) { node = new
TreeNode(value); // reached dead end; put new node here size++; }
else if (value.compareTo(node.data) > 0) { node.right = add(node.right, value);
} else if (value.compareTo(node.data) < 0) { node.left = add(node.left,
value); } // else a duplicate; do nothing return node; } // Returns
true if this set contains the given element value. public boolean contains(E value) {
return contains(root, value); } // private recursive helper for contains private
boolean contains(TreeNode node, E value) { if (node == null) { return
false; } else if (value.compareTo(node.data) > 0) { return
contains(node.right, value); } else if (value.compareTo(node.data) < 0) {
return contains(node.left, value); } else { // value.equals(root.data);
found it! return true; } } // Returns the minimum value in this
set. // Throws a NoSuchElementException if this set is empty. public E getMin() {
if (root == null) { throw new NoSuchElementException(\"empty tree\");
} return getMin(root); } // private recursive helper for getMin
private E getMin(TreeNode node) { if (node.left == null) { return
node.data; } else { return getMin(node.left); } }
// Returns true if this set does not contain any elements. public boolean isEmpty() {
return size == 0; } // Prints all elements of this tree in a left-to-right order (in-order)
traversal. public void print() { print(root); } // private recursive helper
for print private void print(TreeNode .
How to do the main method for this programBinaryNode.javapublic.pdf
How to do the main method for this program?
BinaryNode.java
public class BinaryNode
implements Parent{
/** The item associated with this node. */
private E item;
/** The node at the root of the left subtree. */
private BinaryNode left;
/** The node at the root of the right subtree. */
private BinaryNode right;
/** Put item in a leaf node. */
public BinaryNode(E item) {
this.item = item;
// left and right are set to null by default
}
/** no-argument constructor sets everything to null */
public BinaryNode() {
item = null;
left = null;
right = null;
}
/** Put item in a node with the specified subtrees. */
public BinaryNode(E item, BinaryNode left,
BinaryNode right) {
this.item = item;
this.left = left;
this.right = right;
}
/** Put item in a node with the specified subtrees. */
public BinaryNode getChild(int direction) {
if (direction < 0) {
return left;
} else {
return right;
}
}
/** Return the item associated with this node. */
public E getItem() {
return item;
}
/** Return the root of the left subtree. */
public BinaryNode getLeft() {
return left;
}
/** Return the root of the right subtree. */
public BinaryNode getRight() {
return right;
}
/** Return true if this is a leaf. */
public boolean isLeaf() {
return (left == null) && (right == null);
}
/** Replace the item associated with this node. */
public void setItem(E item) {
this.item = item;
}
/** Replace the left subtree with the one rooted at left. */
public void setLeft(BinaryNode left) {
this.left = left;
}
/** Replace the right subtree with the one rooted at right. */
public void setRight(BinaryNode right) {
this.right = right;
}
public void setChild(int direction, BinaryNode child) {
if (direction < 0) {
left = child;
} else {
right = child;
}
}
/**
* Return the String representation of the tree rooted at this node
* traversed preorder.
**/
public String toStringPreorder() {
String result = \"\";
result += item;
if (left != null) {
result += left.toStringPreorder();
}
if (right != null) {
result += right.toStringPreorder();
}
return result;
}
/** Return a String representation of the tree rooted at this node
* traversed inorder.
**/
public String toStringInOrder() {
String result = \"\";
if (left != null) {
result += left.toStringInOrder();
}
result += item;
if (right != null) {
result += right.toStringInOrder();
}
return result;
}
/** Return a String representation of the tree rooted at this node,
* traversed postorder.
**/
public String toStringPostorder() {
String result = \"\";
if (left != null) {
result += left.toStringPostorder();
}
if (right != null) {
result += right.toStringPostorder();
}
result += item;
return result;
}
/**
* Return a String representation of the tree rooted at this node,
* traversed level order.
**/
public String toStringLevelOrder() {
String result = \"\";
Queue> q = new ArrayQueue>();
q.add (this);
while (!(q.isEmpty())) {
BinaryNode node = q.remove ();
result += node.item;
if (node.left != null) {
q.add(node.left);
}
if (node.right != null) {
q.add(node..
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.
Design, implement, test(In Java ) a doubly linked list ADT, using DL.pdf
Design, implement, test(In Java ) a doubly linked list ADT, using DLLNode objects as the
nodes. In addition to our standard list operations, your class should provide for backward
iteration through the list. To support this operation, it should export a resetBack method and get a
getPrevious method.To facilitate this, you may want to include an instance variable last that
always references the last element on the list.
DLLNODE.java
public class DLLNode extends LLNode
{
private DLLNode back;
public DLLNode(T info)
{
super(info);
back = null;
}
public void setBack(DLLNode back)
// Sets back link of this DLLNode.
{
this.back = back;
}
public DLLNode getBack()
// Returns back link of this DLLNode.
{
return back;
}
}
LLNODE.java
public class LLNode
{
private LLNode link;
private T info;
public LLNode(T info)
{
this.info = info;
link = null;
}
public void setInfo(T info)
// Sets info of this LLNode.
{
this.info = info;
}
public T getInfo()
// Returns info of this LLONode.
{
return info;
}
public void setLink(LLNode link)
// Sets link of this LLNode.
{
this.link = link;
}
public LLNode getLink()
// Returns link of this LLNode.
{
return link;
}
}
This list can be an unsorted list. My professor suggested to reference off the RefUnsortedList
ADT and modifying it to be a doubly linked list.you need to create resetBack and getPrevious
methods which means you will need another variable to keep track of where you are in the
backward iteration. It is not correct to use currentPos to keep track of the backward iteration, so
make another variable (reference) for this, maybe call it currentBackPos.
RefUnsortedList.java
public class RefUnsortedList implements ListInterface
{
protected int numElements; // number of elements in this list
protected LLNode currentPos; // current position for iteration
// set by find method
protected boolean found; // true if element found, else false
protected LLNode location; // node containing element, if found
protected LLNode previous; // node preceeding location
protected LLNode list; // first node on the list
public RefUnsortedList()
{
numElements = 0;
list = null;
currentPos = null;
}
public void add(T element)
// Adds element to this list.
{
LLNode newNode = new LLNode(element);
newNode.setLink(list);
list = newNode;
numElements++;
}
protected void find(T target)
// Searches list for an occurence of an element e such that
// e.equals(target). If successful, sets instance variables
// found to true, location to node containing e, and previous
// to the node that links to location. If not successful, sets
// found to false.
{
location = list;
found = false;
while (location != null)
{
if (location.getInfo().equals(target)) // if they match
{
found = true;
return;
}
else
{
previous = location;
location = location.getLink();
}
}
}
public int size()
// Returns the number of elements on this list.
{
return numElements;
}
public boolean contains (T element)
// Returns true if this list contains an element e such that
// e.equals(el.
Implement the following specification of UnsortedType using circular.pdf
Implement the following specification of UnsortedType using circular linked list as the
implementation structure.
*** I have seen this question answered here before but it is not a good answer. Can someone
please give me a original answer.***
// Deliverables:
// - A listing of the specification and implementation files for UnsortedType
// - A listing of the driver program for your test plan
// - A listing of the test plan as input to the driver.
// - A listing of the output from the driver.
template
struct NodeType;
/* Assumption: ItemType is a type for which the operators
\"<\" and \"==\" are defined-either an appropriate built-in type or a
class that overloads these operators. */
template
class UnsortedType
{
public:
// Class constructor, destructor, and copy constructor
UnsortedType();
~UnsortedType();
UnsortedType(const UnsortedType&);
void operator=(UnsortedType);
bool IsFull() const;
// Determines whether list is full.
//Post: Function value = (list is full)
int GetLength() const;
// Determines the number of elements in list.
// Post: Function value = number of elements in list.
void RetrieveItem(ItemType& item, bool& found);
// Retrieves list element whose key matches item\'s key
// (if present).
// Pre: Key member of item is initialized.
// Post: If there is an element someItem whose key matches
// item\'s key, then found = true and item is a copy of
// someItem; otherwise found = false and item is unchanged.
// List is unchanged.
void InsertItem(ItemType item);
// Adds item to list.
// Pre: List is not full.
// Item is not in list.
// Post: item is in list.
void DeleteItem(ItemType item);
// Deletes the element whose key matches item\'s key
// Pre: Key member of item is initialized.
// One and only one element in list has a key matching
// item\'s key.
// Post: No element in list has a key matching item\'s key.
void ResetList();
// Initializes current position for an iteration through the list.
// Post: Current position is prior to list.
void GetNextItem(ItemType&);
// Gets the next element in list.
// Pre: Current position is defined.
// Element at current position is not last in list.
// Post: Current position is updated to next position.
// item is a copy of element at current position.
private:
NodeType* listData;
int length;
NodeType* currentPos;
};
Solution
#include
#include
/* structure for a node */
struct node
{
int data;
struct node *next;
};
/* function to insert a new_node in a list in sorted way.
Note that this function expects a pointer to head node
as this can modify the head of the input linked list */
void sortedInsert(struct node** head_ref, struct node* new_node)
{
struct node* current = *head_ref;
// Case 1 of the above algo
if (current == NULL)
{
new_node->next = new_node;
*head_ref = new_node;
}
// Case 2 of the above algo
else if (current->data >= new_node->data)
{
/* If value is smaller than head\'s value then
we need to change next of last node */
while(current->next != *head_ref)
current = current->next;
cur.
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.
1)(JAVA) Extend the Binary Search Tree ADT to include a public metho.pdf
1)(JAVA) Extend the Binary Search Tree ADT to include a public method leafCount that returns
the number of leaf nodes in the tree.
Thank You in Advanced.
Below, I also have attached the BinarySearchTree and the Interface File.
BinarySearchTree:
//----------------------------------------------------------------------------
// BinarySearchTree.java by Dale/Joyce/Weems Chapter 8
//
// Defines all constructs for a reference-based BST
//----------------------------------------------------------------------------
package ch08.trees;
import ch05.queues.*;
import ch03.stacks.*;
import support.BSTNode;
public class BinarySearchTree>
implements BSTInterface
{
protected BSTNode root; // reference to the root of this BST
boolean found; // used by remove
// for traversals
protected LinkedUnbndQueue inOrderQueue; // queue of info
protected LinkedUnbndQueue preOrderQueue; // queue of info
protected LinkedUnbndQueue postOrderQueue; // queue of info
public BinarySearchTree()
// Creates an empty BST object.
{
root = null;
}
public boolean isEmpty()
// Returns true if this BST is empty; otherwise, returns false.
{
return (root == null);
}
private int recSize(BSTNode tree)
// Returns the number of elements in tree.
{
if (tree == null)
return 0;
else
return recSize(tree.getLeft()) + recSize(tree.getRight()) + 1;
}
public int size()
// Returns the number of elements in this BST.
{
return recSize(root);
}
public int size2()
// Returns the number of elements in this BST.
{
int count = 0;
if (root != null)
{
LinkedStack> hold = new LinkedStack>();
BSTNode currNode;
hold.push(root);
while (!hold.isEmpty())
{
currNode = hold.top();
hold.pop();
count++;
if (currNode.getLeft() != null)
hold.push(currNode.getLeft());
if (currNode.getRight() != null)
hold.push(currNode.getRight());
}
}
return count;
}
private boolean recContains(T element, BSTNode tree)
// Returns true if tree contains an element e such that
// e.compareTo(element) == 0; otherwise, returns false.
{
if (tree == null)
return false; // element is not found
else if (element.compareTo(tree.getInfo()) < 0)
return recContains(element, tree.getLeft()); // Search left subtree
else if (element.compareTo(tree.getInfo()) > 0)
return recContains(element, tree.getRight()); // Search right subtree
else
return true; // element is found
}
public boolean contains (T element)
// Returns true if this BST contains an element e such that
// e.compareTo(element) == 0; otherwise, returns false.
{
return recContains(element, root);
}
private T recGet(T element, BSTNode tree)
// Returns an element e from tree such that e.compareTo(element) == 0;
// if no such element exists, returns null.
{
if (tree == null)
return null; // element is not found
else if (element.compareTo(tree.getInfo()) < 0)
return recGet(element, tree.getLeft()); // get from left subtree
else
if (element.compareTo(tree.getInfo()) > 0)
return recGet(element, tree.getRight()); // get from right subtree
else
return tree.getInfo(); // element is found
}
public T get(T.
Javascript tid-bits
An introductory presentation I'm doing at my workplace for other developers. This is geared toward programmers that are very new to javascript and covers some basics, but focuses on Functions, Objects and prototypal inheritance ideas.
Similar to Please find my implementationpublic KeyedItem remove() { DO.pdf (20)
The LinkedList1 class implements a Linked list. class.pdf
The LinkedList1 class implements a Linked list. class.pdf
Given below is the completed implementation of MyLinkedList class. O.pdf
Given below is the completed implementation of MyLinkedList class. O.pdf
Program to insert in a sorted list #includestdio.h#include.pdf
Program to insert in a sorted list #includestdio.h#include.pdf
5. Design and implement a method contains 2 for BinarySearchTree, fu.pdf
5. Design and implement a method contains 2 for BinarySearchTree, fu.pdf
Implement the additional 5 methods as indicated in the LinkedList fi.pdf
Implement the additional 5 methods as indicated in the LinkedList fi.pdf
Here is the editable codeSolutionimport java.util.NoSuchEleme.pdf
Here is the editable codeSolutionimport java.util.NoSuchEleme.pdf
1) Create a function called reverselist that will take a simple list.pdf
1) Create a function called reverselist that will take a simple list.pdf
Write the Java source code necessary to build a solution for the pro.pdf
Write the Java source code necessary to build a solution for the pro.pdf
implement the ListLinked ADT (the declaration is given in ListLinked.pdf
implement the ListLinked ADT (the declaration is given in ListLinked.pdf
Assignment 9 (Parent reference for BST) Redefine TreeNode by adding .pdf
Assignment 9 (Parent reference for BST) Redefine TreeNode by adding .pdf
How to do the main method for this programBinaryNode.javapublic.pdf
How to do the main method for this programBinaryNode.javapublic.pdf
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.pdf
Design, implement, test(In Java ) a doubly linked list ADT, using DL.pdf
Design, implement, test(In Java ) a doubly linked list ADT, using DL.pdf
Implement the following specification of UnsortedType using circular.pdf
Implement the following specification of UnsortedType using circular.pdf
Help please!!(Include your modified DList.java source code file in.pdf
Help please!!(Include your modified DList.java source code file in.pdf
1)(JAVA) Extend the Binary Search Tree ADT to include a public metho.pdf
1)(JAVA) Extend the Binary Search Tree ADT to include a public metho.pdf
More from anjaliselectionahd
10. The push button is pushed to the second stop when we pipette out.pdf
10. The push button is pushed to the second stop when we pipette out or transfer the sample, and
to completely void the sample without leaving any sample in the pipette tips
11. The button is to be released after it is withdrawn from the solution/liquid. If it is released
prior to withdrawal, the solution reenters the pipette tip.
12. If the push button is pressed to the second stop and is released even before the pipette tip is
withdrawn from the solution, the solution enters the pipette.
13. When concentrations or dilutions of the sample that are to be transferred changes, when
different solutions or chemicals are transferred, when containment is required, tips need to be
changed with each transfer.
14. The fragments obtained will have blunt ends if the restriction enzyme cuts at the center. Yes.
They are still useful because linkers or adapters can be attached to the blunt end to make them
useful. Moreover, new restriction sites can be created by attaching linkers or adapters.
15. Yes it can be done. The restriction enzyme creates the same overhanging ends since it
recognizes the same restriction site in both the DNA. Therefore, the two different DNA can
basepair at the sticky ends.
Solution
10. The push button is pushed to the second stop when we pipette out or transfer the sample, and
to completely void the sample without leaving any sample in the pipette tips
11. The button is to be released after it is withdrawn from the solution/liquid. If it is released
prior to withdrawal, the solution reenters the pipette tip.
12. If the push button is pressed to the second stop and is released even before the pipette tip is
withdrawn from the solution, the solution enters the pipette.
13. When concentrations or dilutions of the sample that are to be transferred changes, when
different solutions or chemicals are transferred, when containment is required, tips need to be
changed with each transfer.
14. The fragments obtained will have blunt ends if the restriction enzyme cuts at the center. Yes.
They are still useful because linkers or adapters can be attached to the blunt end to make them
useful. Moreover, new restriction sites can be created by attaching linkers or adapters.
15. Yes it can be done. The restriction enzyme creates the same overhanging ends since it
recognizes the same restriction site in both the DNA. Therefore, the two different DNA can
basepair at the sticky ends..
1. Working capital is the capital that a company uses for its day to.pdf
1. Working capital is the capital that a company uses for its day to day operations. Working
capital is computed using the formula: Working capital = current assets – current liabilities.
2. Determinants of working capital requirements are – nature of business, seasonality of
operations, production policy, market conditions and conditions of supply. A service company
will have a lower working capital requirement than a manufacturing company. Firms with
seasonality in operations will have higher fluctuations with regards to their working capital
requirements. Market conditions in the form of degree of competition will affect working capital
requirements. Higher competitive pressure will increase working capital requirements.
3. Three major decisions that managers have to take while performing the finance function are:
(i) Investment decision – Managers have to select those assets that the business will invest in. It
is also known as capital budgeting decisions.
(ii) Financing decision – These decisions pertain to determining how the total funds that are
required for the business will be obtained – will it be through debt or equity or a mix of debt or
equity.
(iii) Dividend decision – This pertains to determining what quantum of earnings should be
distributed to shareholders as dividends and what quantum should be retained for meeting future
growth requirements of the company.
4. Financial management involves planning, directing, monitoring and controlling the monetary
resources of a company in such a manner that the goals and objectives of the company are
achieved in an efficient manner. It involves management of capital budgeting, capital structure,
working capital management, etc. Financial management is important as it helps an organization
to set clarity towards its financial goals and helps in efficient utilization of resources.
5. Cash flow is not a suitable judge of profitability as it merely shows the changes in cash
position of a firm in a financial year from its operating activities, from its financing activities and
from its investing activities. Cash flow statement does not help us to determine gross profit
margins, operating profit margins and net profit margins. We can just gauge the reason for
changes in cash position in a year.
6. Financial risk refers to all kinds of risk associated with a financial transaction and an
investment transaction. It can be in the form of credit risk, asset backed risk, investment risk etc.
These risks arise due to the fact that there is a probability of loss that is inherent in any financing
and investment method and this probability of loss cannot be avoided.
Solution
1. Working capital is the capital that a company uses for its day to day operations. Working
capital is computed using the formula: Working capital = current assets – current liabilities.
2. Determinants of working capital requirements are – nature of business, seasonality of
operations, production policy, market conditions and condi.
1. no2.The Waterfall model has some disadvantages.Agile software.pdf
1. no
2.The Waterfall model has some disadvantages.
Agile software development evolved to eliminate the issues the Waterfall model has. It has a
completely new framework. While the Waterfall model has a sequential design, the Agile model
followed an incremental approach.When clients who used to follow the Waterfall model
switched to Agile, the transition brought many issues with it. The reason being inadaptability to a
different approach to software development. The end product turned out to be a disaster.
3. yes
4. The initialization step creates a base version of the system. The goal for this initial
implementation is to create a product to which the user can react. It should offer a sampling of
the key aspects of the problem and provide a solution that is simple enough to understand and
implement easily. To guide the iteration process, a project control list is created that contains a
record of all tasks that need to be performed. It includes such items as new features to be
implemented and areas of redesign of the existing solution.
5.yes
6.the mainly reason is to testing should be conducted faulty elements of the software can be
quickly identified because few changes are made within any single iteration.Customer can
respond to features and review the product for any needed or useful changes., a plan is developed
for the next increments, and modifications are made accordingly. This process continues, with
increments being delivered until the complete product is delivered.
7.Agile Software Development
Because a framework that is used to structure, plan, and control the process of developing an
information system.The methods attempt to minimize risk by developing software in short
timeboxes, called iterations, Each iteration is like a miniature software project of its own, and
includes all the tasks necessary to release the mini increment of new functionality: planning,
requirements analysis, design, coding, testing, and documentation. While iteration may not add
enough functionality to warrant releasing the product, an agile software project intends to be
capable of releasing new software at the end of every iteration emphasize working software as
the primary measure of progress. Combined with the preference for face-to-face communication,
agile methods produce very little written documentation relative to other methods.
Solution
1. no
2.The Waterfall model has some disadvantages.
Agile software development evolved to eliminate the issues the Waterfall model has. It has a
completely new framework. While the Waterfall model has a sequential design, the Agile model
followed an incremental approach.When clients who used to follow the Waterfall model
switched to Agile, the transition brought many issues with it. The reason being inadaptability to a
different approach to software development. The end product turned out to be a disaster.
3. yes
4. The initialization step creates a base version of the system. The goal for this initial
implementat.
True ; this is known as Tyndal effect .pdf
True ; this is known as Tyndal effect
Solution
True ; this is known as Tyndal effect.
TLC is used to separate the compounds.the benzoic.pdf
TLC is used to separate the compounds.the benzoic acid and methanol are more
polar so these have small rf value.so we can easyly separate the ester
Solution
TLC is used to separate the compounds.the benzoic acid and methanol are more
polar so these have small rf value.so we can easyly separate the ester.
The answer to this question is (E) If you look at.pdf
The answer to this question is (E) If you look at N2, you can see that as 2 moles of
N2 is formed 4 moles of NH3 is reacting. Thus, since the rate of formation of N2 is 2.0
mol/(L*s), the rate of formation of NH3 is double that (2*2.0mol/(L*s))=4.0 mol/(L*s). I hope
this helped!
Solution
The answer to this question is (E) If you look at N2, you can see that as 2 moles of
N2 is formed 4 moles of NH3 is reacting. Thus, since the rate of formation of N2 is 2.0
mol/(L*s), the rate of formation of NH3 is double that (2*2.0mol/(L*s))=4.0 mol/(L*s). I hope
this helped!.
Redox reactions are analogous in that they are el.pdf
Redox reactions are analogous in that they are electron transfer reactions. Certain
chemicals are oxidizers, like O2, which take electrons. While others are reducers, which are
oxidizing agents, and give electrons. The better the reducing agent a chemical it is, the worse
oxidizing agent it is.
Solution
Redox reactions are analogous in that they are electron transfer reactions. Certain
chemicals are oxidizers, like O2, which take electrons. While others are reducers, which are
oxidizing agents, and give electrons. The better the reducing agent a chemical it is, the worse
oxidizing agent it is..
moles NH4NO3 = 2.57 g 80.04 gmol=0.0321 moles H.pdf
moles NH4NO3 = 2.57 g /80.04 g/mol=0.0321 moles H2O = 4 x 0.0321 /2= 0.0642
moles O2 = 0.0321/2 =0.0161 moles N2 = 0.0321 total moles = 0.112 so p = 0.112 x 0.08206 x
520 K/ 4.50=1.06 atm
Solution
moles NH4NO3 = 2.57 g /80.04 g/mol=0.0321 moles H2O = 4 x 0.0321 /2= 0.0642
moles O2 = 0.0321/2 =0.0161 moles N2 = 0.0321 total moles = 0.112 so p = 0.112 x 0.08206 x
520 K/ 4.50=1.06 atm.
mole fraction of He = mole of He total mole now.pdf
mole fraction of He = mole of He/ total mole now mole of He = weight/M.wt = 2/4
= 0.5 mole of O2 = 5.99/32 = 0.187 total mole = 0.687 mole fraction of He = 0.5/0.687 = 0.727
Solution
mole fraction of He = mole of He/ total mole now mole of He = weight/M.wt = 2/4
= 0.5 mole of O2 = 5.99/32 = 0.187 total mole = 0.687 mole fraction of He = 0.5/0.687 = 0.727.
It is a molecular process involving the exchange .pdf
It is a molecular process involving the exchange of bonds between the two reacting
chemical species, which results in the creation of products with similar or identical bonding
affiliations. This is represented by the general reaction scheme: AX + BY ? BX + AY These
chemical species can either be ionic or covalent. When referring to precipitation reactions
between solutions of ions in inorganic chemistry, these were formerly referred to as double
displacement or double replacement reactions, and these terms are still encouraged. It seems that
the term double decomposition is more specifically used when at least one of the substances does
not dissolve in the liquor, as the ligand or ion exchange takes place in the solid state of the
reactant, i.e. AX(aq) + BY(s) ? AY(aq) + BX(s). Types: Neutralization A neutralization reaction
is a specific type of double displacement reaction. Neutralization occurs when an acid reacts with
an equal amount of a base. A neutralization reaction creates a solution of a salt and water. For
example, hydrochloric acid reacts with sodium hydroxide to produce salt and water: HCl (aq) +
NaOH (aq) ? NaCl (aq) + H2O (l) Aqueous metathesis (precipitation) Metathesis reactions can
occur between two inorganic salts when one product is insoluble in water, driving the reaction
forward. For example, the precipitation of silver chloride from a mixture of silver nitrate and
sodium chloride causes sodium nitrate to be left in solution: AgNO3 (aq) + NaCl (aq) ? AgCl (s)
+ NaNO3 (aq) The formation of an insoluble gas that bubbles out of the solution, or a molecular
compound such as water, also drives the reaction to completion. Therefore, a solubility chart (or
general knowledge of solubility rules) can be used to predict whether two aqueous solutions will
react. HSAB theory can also be used to predict the products of a metathesis reaction. Aqueous
metathesis (double decomposition) The reactants need not to be dissolved for metathesis
reactions to take place. An example of this is the formation of barium thiocyanate when boiling a
mixture of copper(I)thiocyanate and barium hydroxide in water: Ba(OH)2 (s) + 2 CuCNS (s) ?
Ba(CNS)2 (aq) + 2CuOH (s) Acid and carbonates A subcategory of aqueous metathesis
reactions is the reaction of an acid with a carbonate or bicarbonate. Such a reaction always yields
carbonic acid as a product, which spontaneously decomposes into carbon dioxide and water. The
release of carbon dioxide gas from the reaction mixture drives the reaction to completion. For
example, a common, science-fair \"volcano\" reaction involves the reaction of acetic acid with
sodium bicarbonate: HCH3COO (aq) + NaHCO3 (s) ? NaCH3COO (aq) + CO2 (g) + H2O (l)
Solution
It is a molecular process involving the exchange of bonds between the two reacting
chemical species, which results in the creation of products with similar or identical bonding
affiliations. This is represented by the general reaction scheme: AX + BY ? BX + AY These
che.
Helium contains a 1s^2 orbital. .pdf
Helium contains a 1s^2 orbital.
Solution
Helium contains a 1s^2 orbital..
From the LCAO method The overlap of the 1s AO on.pdf
From the LCAO method: The overlap of the 1s AO on one H atom with the is AO
on a second gives one bonding MO (s) at lower energy to the constituent AOs and one
antibonding MO (s*) at higher energy. Each MO can hold 2 e-. H2^- has 3e- and so the MO
\"scheme\" is s(2e-) s*(1e-) Bond Order = ½[S (bonding e-) - S (antibonding e-)] = ½[2-1] = 0.5
so H2^2- is predicted to be bonding. When irradiated with UV light an e- in the s MO is
promoted to the s*: s(2e-) s*(1e-) ? h? ? s(1e-) s*(2e-) ? dissociation The bond order of the
excited state is formally ½[1-2] = -0.5 which is repulsive: the species flies apart into H^- and H.
(H atom not a period). You have to look at an MO diagram for O2; if you do that, focusing on
the p-based orbitals, you\'ll see that there are 6 bonding electrons (2 in the p-sigma orbital, and 4
in the p-pi orbitals), and two electrons in the p-pi* (one in each). Thus there are six bonding
electrons and two antibonding electrons, so the net is four bonding electrons. Since it takes two
bonding electrons to make a bond, the bond order is 2 for O2. If you take away one of the
antibonding electrons, now you have a net of five bonding electrons, which - when divided by 2 -
gives you a bond order of 2.5. Because you\'ve taken away one electron from neutral O2, the
charge will be +1.
Solution
From the LCAO method: The overlap of the 1s AO on one H atom with the is AO
on a second gives one bonding MO (s) at lower energy to the constituent AOs and one
antibonding MO (s*) at higher energy. Each MO can hold 2 e-. H2^- has 3e- and so the MO
\"scheme\" is s(2e-) s*(1e-) Bond Order = ½[S (bonding e-) - S (antibonding e-)] = ½[2-1] = 0.5
so H2^2- is predicted to be bonding. When irradiated with UV light an e- in the s MO is
promoted to the s*: s(2e-) s*(1e-) ? h? ? s(1e-) s*(2e-) ? dissociation The bond order of the
excited state is formally ½[1-2] = -0.5 which is repulsive: the species flies apart into H^- and H.
(H atom not a period). You have to look at an MO diagram for O2; if you do that, focusing on
the p-based orbitals, you\'ll see that there are 6 bonding electrons (2 in the p-sigma orbital, and 4
in the p-pi orbitals), and two electrons in the p-pi* (one in each). Thus there are six bonding
electrons and two antibonding electrons, so the net is four bonding electrons. Since it takes two
bonding electrons to make a bond, the bond order is 2 for O2. If you take away one of the
antibonding electrons, now you have a net of five bonding electrons, which - when divided by 2 -
gives you a bond order of 2.5. Because you\'ve taken away one electron from neutral O2, the
charge will be +1..
Ecell=E(nought) -RT(2F)ln[Mg2+][Zn2+] .pdf
Ecell=E(nought) -RT/(2F)*ln[Mg2+]/[Zn2+]
Solution
Ecell=E(nought) -RT/(2F)*ln[Mg2+]/[Zn2+].
Cis-trans isomers occur because it is impossible .pdf
Cis-trans isomers occur because it is impossible to rotate the double bond without
breaking it. Thus, isomers that are related by \"rotation\" about the double bond are actually
separate compounds - cis/trans isomers. In the example you have drawn, keep the -CH2CH3
group and the right-hand H in place and reverse the position of the -CH2CH2CH3 group and the
other H (so that the H\'s are on \"opposite\" sides of the double bond). This is the trans isomer of
the compound you drew (you have the cis isomer). Now, imagine that instead of the
CH2CH2CH3 group you had another H. In that case, switching the position of the two H\'s
would result in the same compound, and cis-trans isomers would not be possible. In general,
cis/trans isomers are possible only if each carbon that is part of the double bond is bonded to two
DIFFERENT groups. This is only true for I and III. In II, the right-hand carbon of the double
bond is bonded to two H\'s. And in IV, the left hand carbon of the double bond is bonded to two -
CH3 groups. Thus neither of these has cis-trans isomers. So the correct answer is (b), I and III.
Solution
Cis-trans isomers occur because it is impossible to rotate the double bond without
breaking it. Thus, isomers that are related by \"rotation\" about the double bond are actually
separate compounds - cis/trans isomers. In the example you have drawn, keep the -CH2CH3
group and the right-hand H in place and reverse the position of the -CH2CH2CH3 group and the
other H (so that the H\'s are on \"opposite\" sides of the double bond). This is the trans isomer of
the compound you drew (you have the cis isomer). Now, imagine that instead of the
CH2CH2CH3 group you had another H. In that case, switching the position of the two H\'s
would result in the same compound, and cis-trans isomers would not be possible. In general,
cis/trans isomers are possible only if each carbon that is part of the double bond is bonded to two
DIFFERENT groups. This is only true for I and III. In II, the right-hand carbon of the double
bond is bonded to two H\'s. And in IV, the left hand carbon of the double bond is bonded to two -
CH3 groups. Thus neither of these has cis-trans isomers. So the correct answer is (b), I and III..
When a heterozygote (Aa) is not an exact intermediate between the tw.pdf
When a heterozygote (Aa) is not an exact intermediate between the two homozygotes (AA and
aa), then not all of the genetic variance in the population can be accounted for by differences in
the average effect of the A and a alleles.
In this case, the total genetic variance of the population can be subdivided into two components:
Additive Genetic Variance (sa2): Genetic variation attributed to average differences between
different allelic characters.
Dominance Genetic Variance (sd2): Variance due to heterozygotes not being exact midpoints of
homozygote parents.
So that,
Sg2 = Sa2 + Sd2
And now, total phenotypic variance can be rewritten as:
Sp2 = Se2 + Sg2 = Se2 + Sa2 + Sd2
From this, we can define a new kind of heritability:
Heritability in the narrow sense (h2):Proportion of phenotypic variance due to additive genetic
variance alone
h2 = Sa2 / Sp2 = Sa2 / Se2 + Sg2 = Sa2 / Se2 + Sd2 + Sa2
The greater h2 is for a population, the greater the fraction of the difference between selected
parents and the population as a whole that will be preserved in the offspring of those parents.
______________________________________________________________
To see why it is h2 that matters for response to selection, consider an extreme case:
2 homozygotes are equal in phenotype, say with a value of 20. (AA=aa=20)
But the heterozygote is overdominant, maybe with a value of 24. (Aa=24)
So for this population, there is only dominance variance, and no additive genetic variance
because there is no average difference between the carriers of a alleles and the carriers of A
alleles.
Now suppose that the population mates randomly and the genotype proportions are:
If only individuals with the highest values were selected to breed, all parents would be
heterozygotes.
Offspring of heterozygotes would exactly reproduce the 1:2:1 distribution of genotypes seen in
the parental generation.
Thus, there would be no change in genetic composition of the F1 generation, despite the fact
that there is genetic variation in the population.
So, selection proves to be ineffective when all variance is due to dominance and there is no
additive variance.
It is important to consider that dominance variance arises from more than just the deviation of
heterozygotes from the exact midpoint of homozygotes.
Dominance variance (sd2) is considered to be any genetic variation that cannot be explained by
average allelic differences, or additive genetic variance (sa2)
For example, if a trait is affected by multiple loci then any epistatic interactions between the loci
will appear as variance not associated with additive variance.
In theory, this interaction variance (si2) could be separated from dominance variance (sd2).
In practice, however, it is not possible to achieve accurate measures of separating these two
parameters so all nonadditive variance is attributed to dominance variance (sd2).
_____________________________________________________________________________
________________
Important Mess.
Volume of water = masssolubility of calcium phosphate= 13.41 x 1.pdf
Volume of water = mass/solubility of calcium phosphate
= 1/3.41 x 10-5
= 2.93 x 104 L
Solution
Volume of water = mass/solubility of calcium phosphate
= 1/3.41 x 10-5
= 2.93 x 104 L.
Astatine is a halogen. Column VII(7) on the perio.pdf
Astatine is a halogen. Column VII(7) on the periodic table. Therefore, the elements
that would have similar properties to it are the other halogens: Iodine(I), Bromine(Br),
Chlorine(Cl), Fluorine(F)
Solution
Astatine is a halogen. Column VII(7) on the periodic table. Therefore, the elements
that would have similar properties to it are the other halogens: Iodine(I), Bromine(Br),
Chlorine(Cl), Fluorine(F).
More from anjaliselectionahd (20)
10. The push button is pushed to the second stop when we pipette out.pdf
10. The push button is pushed to the second stop when we pipette out.pdf
1. Working capital is the capital that a company uses for its day to.pdf
1. Working capital is the capital that a company uses for its day to.pdf
1. no2.The Waterfall model has some disadvantages.Agile software.pdf
1. no2.The Waterfall model has some disadvantages.Agile software.pdf
TLC is used to separate the compounds.the benzoic.pdf
TLC is used to separate the compounds.the benzoic.pdf
The answer to this question is (E) If you look at.pdf
The answer to this question is (E) If you look at.pdf
Redox reactions are analogous in that they are el.pdf
Redox reactions are analogous in that they are el.pdf
moles NH4NO3 = 2.57 g 80.04 gmol=0.0321 moles H.pdf
moles NH4NO3 = 2.57 g 80.04 gmol=0.0321 moles H.pdf
mole fraction of He = mole of He total mole now.pdf
mole fraction of He = mole of He total mole now.pdf
It is a molecular process involving the exchange .pdf
It is a molecular process involving the exchange .pdf
From the LCAO method The overlap of the 1s AO on.pdf
From the LCAO method The overlap of the 1s AO on.pdf
Cis-trans isomers occur because it is impossible .pdf
Cis-trans isomers occur because it is impossible .pdf
When a heterozygote (Aa) is not an exact intermediate between the tw.pdf
When a heterozygote (Aa) is not an exact intermediate between the tw.pdf
Volume of water = masssolubility of calcium phosphate= 13.41 x 1.pdf
Volume of water = masssolubility of calcium phosphate= 13.41 x 1.pdf
Astatine is a halogen. Column VII(7) on the perio.pdf
Astatine is a halogen. Column VII(7) on the perio.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.
special B.ed 2nd year old paper_20240531.pdf
Instagram:-
https://instagram.com/special_education_needs_01?igshid=YmMyMTA2M2Y=
WhatsApp:-
https://chat.whatsapp.com/JVakNIYlSV94x7bwunO3Dc
YouTube:-
https://youtube.com/@special_education_needs
Teligram :- https://t.me/special_education_needs
Slide Shere :-
https://www.slideshare.net/shabnambano20?utm_campaign=profiletracking&utm_medium=sssite&utm_source=ssslideview
TESDA TM1 REVIEWER FOR NATIONAL ASSESSMENT WRITTEN AND ORAL QUESTIONS WITH A...
TESDA TM1 REVIEWER FOR NATIONAL ASSESSMENT WRITTEN AND ORAL QUESTIONS WITH ANSWERS.
The approach at University of Liverpool.pptx
How libraries can support authors with open access requirements for UKRI funded books
Wednesday 22 May 2024, 14:00-15:00.
Advantages and Disadvantages of CMS from an SEO Perspective
Advantages and Disadvantages of CMS from an SEO Perspective
Digital Tools and AI for Teaching Learning and Research
This Presentation in details discusses on Digital Tools and AI for Teaching Learning and Research
A Survey of Techniques for Maximizing LLM Performance.pptx
A Survey of Techniques for Maximizing LLM Performance
Exploiting Artificial Intelligence for Empowering Researchers and Faculty, In...
Exploiting Artificial Intelligence for Empowering Researchers and Faculty, In...Dr. Vinod Kumar Kanvaria
Exploiting Artificial Intelligence for Empowering Researchers and Faculty,
International FDP on Fundamentals of Research in Social Sciences
at Integral University, Lucknow, 06.06.2024
By Dr. Vinod Kumar KanvariaAzure Interview Questions and Answers PDF By ScholarHat
Azure Interview Questions and Answers PDF By ScholarHat
How to Make a Field invisible in Odoo 17
It is possible to hide or invisible some fields in odoo. Commonly using “invisible” attribute in the field definition to invisible the fields. This slide will show how to make a field invisible in odoo 17.
The French Revolution Class 9 Study Material pdf free download
The French Revolution, which began in 1789, was a period of radical social and political upheaval in France. It marked the decline of absolute monarchies, the rise of secular and democratic republics, and the eventual rise of Napoleon Bonaparte. This revolutionary period is crucial in understanding the transition from feudalism to modernity in Europe.
For more information, visit-www.vavaclasses.com
"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
The Challenger.pdf DNHS Official Publication
Read| The latest issue of The Challenger is here! We are thrilled to announce that our school paper has qualified for the NATIONAL SCHOOLS PRESS CONFERENCE (NSPC) 2024. Thank you for your unwavering support and trust. Dive into the stories that made us stand out!
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.
Supporting (UKRI) OA monographs at Salford.pptx
How libraries can support authors with open access requirements for UKRI funded books
Wednesday 22 May 2024, 14:00-15:00.
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.
Digital Artifact 2 - Investigating Pavilion Designs
Digital Artifact 2 - Pavilions
NGV Architecture Commission Competition
MPavilion Commission Competition
Other Pavilion Designs
Thesis Statement for students diagnonsed withADHD.ppt
Presentation required for the master in Education.
Recently uploaded (20)
TESDA TM1 REVIEWER FOR NATIONAL ASSESSMENT WRITTEN AND ORAL QUESTIONS WITH A...
TESDA TM1 REVIEWER FOR NATIONAL ASSESSMENT WRITTEN AND ORAL QUESTIONS WITH A...
Advantages and Disadvantages of CMS from an SEO Perspective
Advantages and Disadvantages of CMS from an SEO Perspective
Digital Tools and AI for Teaching Learning and Research
Digital Tools and AI for Teaching Learning and Research
A Survey of Techniques for Maximizing LLM Performance.pptx
A Survey of Techniques for Maximizing LLM Performance.pptx
Exploiting Artificial Intelligence for Empowering Researchers and Faculty, In...
Exploiting Artificial Intelligence for Empowering Researchers and Faculty, In...
Azure Interview Questions and Answers PDF By ScholarHat
Azure Interview Questions and Answers PDF By ScholarHat
The French Revolution Class 9 Study Material pdf free download
The French Revolution Class 9 Study Material pdf free download
"Protectable subject matters, Protection in biotechnology, Protection of othe...
"Protectable subject matters, Protection in biotechnology, Protection of othe...
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
Digital Artifact 2 - Investigating Pavilion Designs
Digital Artifact 2 - Investigating Pavilion Designs
Thesis Statement for students diagnonsed withADHD.ppt
Thesis Statement for students diagnonsed withADHD.ppt
Please find my implementationpublic KeyedItem remove() { DO.pdf
- 1. Please find my implementation: public KeyedItem remove() { //DO THIS //remove the smallest item // since Linked List is in sorted order, so head is the samllest element if(head == null) return null; // return head element and move head one step forward KeyedItem item = head.getItem(); head = head.getNext(); return item; } private Node locateNodeAdd(KeyedItem item) { //DO THIS //find the insertion location (remember FIFO for duplicates) Node curr = head; Node prev = null; while(curr != null){ if((current.getItem().getKey()).compareTo(item.getKey) >= 0){ return prev; } prev = curr; curr = curr.getNext(); } return prev; } Solution
- 2. Please find my implementation: public KeyedItem remove() { //DO THIS //remove the smallest item // since Linked List is in sorted order, so head is the samllest element if(head == null) return null; // return head element and move head one step forward KeyedItem item = head.getItem(); head = head.getNext(); return item; } private Node locateNodeAdd(KeyedItem item) { //DO THIS //find the insertion location (remember FIFO for duplicates) Node curr = head; Node prev = null; while(curr != null){ if((current.getItem().getKey()).compareTo(item.getKey) >= 0){ return prev; } prev = curr; curr = curr.getNext(); } return prev; }