package DataStructures; public class HelloWorld AnyType extends.pdf
•
0 likes•2 views
package DataStructures; public class HelloWorld > { public HelloWorld( ) { root = null; } public void insert( AnyType x ) { root = insert( x, root ); } public void remove( AnyType x ) { root = remove( x, root ); } public AnyType findMin( ) { if( isEmpty( ) ) System.out.println(\"tree is empty\"); return findMin( root ).element; } public AnyType findMax( ) { if( isEmpty( ) ) System.out.println(\"tree is empty\"); return findMax( root ).element; } public boolean contains( AnyType x ) { return contains( x, root ); } public void makeEmpty( ) { root = null; } public boolean isEmpty( ) { return root == null; } public void printTree( ) { if( isEmpty( ) ) System.out.println( \"Empty tree\" ); else printTree( root ); } private BinaryNode insert( AnyType x, BinaryNode t ) { if( t == null ) return new BinaryNode( x, null, null ); int compareResult = x.compareTo( t.element ); if( compareResult < 0 ) t.left = insert( x, t.left ); else if( compareResult > 0 ) t.right = insert( x, t.right ); else ; // Duplicate; do nothing return t; } private BinaryNode remove( AnyType x, BinaryNode t ) { if( t == null ) return t; // Item not found; do nothing int compareResult = x.compareTo( t.element ); if( compareResult < 0 ) t.left = remove( x, t.left ); else if( compareResult > 0 ) t.right = remove( x, t.right ); else if( t.left != null && t.right != null ) // Two children { t.element = findMin( t.right ).element; t.right = remove( t.element, t.right ); } else t = ( t.left != null ) ? t.left : t.right; return t; } private BinaryNode findMin( BinaryNode t ) { if( t == null ) return null; else if( t.left == null ) return t; return findMin( t.left ); } private BinaryNode findMax( BinaryNode t ) { if( t != null ) while( t.right != null ) t = t.right; return t; } private boolean contains( AnyType x, BinaryNode t ) { if( t == null ) return false; int compareResult = x.compareTo( t.element ); if( compareResult < 0 ) return contains( x, t.left ); else if( compareResult > 0 ) return contains( x, t.right ); else return true; // Match } private void printTree( BinaryNode t ) { if( t != null ) { printTree( t.left ); System.out.println( t.element ); printTree( t.right ); } } private int height( BinaryNode t ) { if( t == null ) return -1; else return 1 + Math.max( height( t.left ), height( t.right ) ); } // Basic node stored in unbalanced binary search trees private static class BinaryNode { // Constructors BinaryNode( AnyType theElement ) { this( theElement, null, null ); } BinaryNode( AnyType theElement, BinaryNode lt, BinaryNode rt ) { element = theElement; left = lt; right = rt; } AnyType element; // The data in the node BinaryNode left; // Left child BinaryNode right; // Right child } /** The tree root. */ private BinaryNode root; public static void main( String [ ] args ) { HelloWorld t = new HelloWorld( ); final int NUMS = 4000; final int GAP = 37; System.out.println( \"Checking... (no more output means success)\" ); for( int i = GAP; i != 0; i = ( i + GAP ) % NUMS ) t.insert.
Report
Share
Report
Share
Download to read offline
Recommended
Required to augment the authors Binary Search Tree (BST) code to .docx
The document provides instructions for augmenting a Binary Search Tree (BST) class to support new operations like returning the nth element, rank of an element, median element, and determining if the tree is perfect or complete. It explains that these operations could be done with in-order traversal but would be inefficient. Instead, each node should store the size of its subtree to guide searches more efficiently. The BST class code is provided to test the augmented operations on.
import java.util.Scanner;class BinaryNode{ BinaryNode left.pdf
This Java program defines classes to represent nodes and binary search trees. It implements methods to insert, delete, search for nodes in the tree as well as traverse the tree using inorder, preorder and postorder traversal. The main method tests the binary search tree operations by prompting the user to insert, delete, search for nodes and check if the tree is empty.
Create a class BinarySearchTree- A class that implements the ADT binar.pdf
Create a class BinarySearchTree. A class that implements the ADT binary search tree by
extending BinaryTree. Recursive version.
public class BinarySearchTree<T extends Comparable<? super T>>
extends BinaryTree<T> implements SearchTreeInterface<T>
{
public BinarySearchTree ()
{
super();
} // end default constructor
public BinarySearchTree (T rootEntry)
{
super();
setRootNode(new BinaryNode<>(rootEntry));
} // end constructor
public void setTree (T rootData) // Disable setTree (see Segment 25.6)
{
throw new UnsupportedOperationException();
} // end setTree
public void setTree (T rootData, BinaryTreeInterface<T> leftTree, BinaryTreeInterface<T>
rightTree)
{
throw new UnsupportedOperationException();
} // end setTree
//...
public T remove (T entry)
{
ReturnObject oldEntry = new ReturnObject(null);
BinaryNode<T> newRoot = removeEntry(getRootNode(), entry, oldEntry);
setRootNode(newRoot);
return oldEntry.get();
} // end remove
//...
private class ReturnObject
{
private T item;
private ReturnObject(T entry)
{
item = entry;
} // end constructor
public T get()
{
return item;
} // end get
public void set(T entry)
{
item = entry;
} // end set
} // end ReturnObject
} // end BinarySearchTree
HERE IS BinaryTree.java
import java.util.Iterator;
import java.util.NoSuchElementException;
public class BinaryTree<T> implements BinaryTreeInterface<T> {
private BinaryNode<T> root;
public BinaryTree() {
root = null;
}
public BinaryTree(T rootData) {
root = new BinaryNode<>(rootData);
}
public BinaryTree(T rootData, BinaryTree<T> leftTree, BinaryTree<T> rightTree) {
privateSetTree(rootData, leftTree, rightTree);
}
private void privateSetTree(T rootData, BinaryTree<T> leftTree, BinaryTree<T>
rightTree) {
root = new BinaryNode<>(rootData);
if (leftTree != null && !leftTree.isEmpty()) {
root.setLeftChild(leftTree.root);
}
if (rightTree != null && !rightTree.isEmpty()) {
if (rightTree != leftTree) {
root.setRightChild(rightTree.root);
} else {
root.setRightChild(rightTree.root.copy());
}
}
if (leftTree != null && leftTree != this) {
leftTree.clear();
}
if (rightTree != null && rightTree != this) {
rightTree.clear();
}
}
@Override
public T getRootData() {
if (isEmpty()) {
throw new EmptyTreeException("The tree is empty.");
}
return root.getData();
}
@Override
public int getHeight() {
return root.getHeight();
}
@Override
public int getNumberOfNodes() {
return root.getNumberOfNodes();
}
@Override
public boolean isEmpty() {
return root == null;
}
@Override
public void clear() {
root = null;
}
@Override
public Iterator<T> getPreorderIterator() {
return new PreorderIterator();
}
@Override
public Iterator<T> getInorderIterator() {
return new InorderIterator();
}
@Override
public Iterator<T> getPostorderIterator() {
return new PostorderIterator();
}
private class PreorderIterator implements Iterator<T> {
private StackInterface<BinaryNode<T>> nodeStack;
public PreorderIterator() {
nodeStack = new LinkedStack<>();
if (root != null) {
nodeStack.push(root);
}
}
public boolean hasNex.
It is the main program that implement the min(), max(), floor(), cei.pdf
It is the main program that implement the min(), max(), floor(), ceiling(), select(), rank(),delete(),
deleteMin(), deleteMax(), keys()
import java.util.NoSuchElementException;
public class BST, Value> {
private Node root;
private class Node {
private Key key;
private Value val;
private Node left, right;
private int size;
public Node(Key key, Value val, int size) {
this.key = key;
this.val = val;
this.size = size;
}
}
public BST() {
}
public boolean isEmpty() {
return size() == 0;
}
public int size() {
return size(root);
}
// return number of key-value pairs in BST rooted at x
private int size(Node x) {
if (x == null) return 0;
else return x.size;
}
public boolean contains(Key key) {
if (key == null) throw new NullPointerException(\"argument to contains() is null\");
return get(key) != null;
}
public Value get(Key key) {
return get(root, key);
}
private Value get(Node x, Key key) {
if (x == null) return null;
int cmp = key.compareTo(x.key);
if (cmp < 0) return get(x.left, key);
else if (cmp > 0) return get(x.right, key);
else return x.val;
}
public void put(Key key, Value val) {
if (key == null) throw new NullPointerException(\"first argument to put() is null\");
if (val == null) {
delete(key);
return;
}
root = put(root, key, val);
assert check();
}
private Node put(Node x, Key key, Value val) {
if (x == null) return new Node(key, val, 1);
int cmp = key.compareTo(x.key);
if (cmp < 0) x.left = put(x.left, key, val);
else if (cmp > 0) x.right = put(x.right, key, val);
else x.val = val;
x.size = 1 + size(x.left) + size(x.right);
return x;
}
public void deleteMax() {
if (isEmpty()) throw new NoSuchElementException(\"Symbol table underflow\");
root = deleteMax(root);
assert check();
}
private Node deleteMax(Node x) {
if (x.right == null) return x.left;
x.right = deleteMax(x.right);
x.size = size(x.left) + size(x.right) + 1;
return x;
}
public void delete(Key key) {
if (key == null) throw new NullPointerException(\"argument to delete() is null\");
root = delete(root, key);
assert check();
}
private Node delete(Node x, Key key) {
if (x == null) return null;
int cmp = key.compareTo(x.key);
if (cmp < 0) x.left = delete(x.left, key);
else if (cmp > 0) x.right = delete(x.right, key);
else {
if (x.right == null) return x.left;
if (x.left == null) return x.right;
Node t = x;
x = min(t.right);
x.right = deleteMin(t.right);
x.left = t.left;
}
x.size = size(x.left) + size(x.right) + 1;
return x;
}
public Key min() {
if (isEmpty()) throw new NoSuchElementException(\"called min() with empty symbol
table\");
return min(root).key;
}
private Node min(Node x) {
if (x.left == null) return x;
else return min(x.left);
}
public Key max() {
if (isEmpty()) throw new NoSuchElementException(\"called max() with empty symbol
table\");
return max(root).key;
}
private Node max(Node x) {
if (x.right == null) return x;
else return max(x.right);
}
public Key floor(Key key) {
if (key == null) throw new NullPointerException(\"argument to floor() is null\");
if (isEmpty()) throw ne.
package edu-ser222-m03_02- --- - A binary search tree based impleme.docx
package edu.ser222.m03_02;
/**
* A binary search tree based implementation of a symbol table.
*
* Completion time: (your completion time)
*
* @author (your name), Sedgewick, Acuna
* @version (version)
*/
import java.util.Collections;
import java.util.LinkedList;
import java.util.NoSuchElementException;
import java.util.Queue;
public class CompletedBST<Key extends Comparable<Key>, Value> implements BST<Key, Value> {
private Node<Key, Value> root;
@Override
public int size() {
return size(root);
}
private int size(Node x) {
if (x == null)
return 0;
else
return x.N;
}
@Override
public Value get(Key key) {
Node<Key, Value> iter = root;
while(iter != null) {
int cmp = key.compareTo(iter.key);
if (cmp < 0)
iter = iter.left;
else if (cmp > 0)
iter = iter.right;
else
return iter.val;
}
return null;
}
private Value get(Node<Key, Value> x, Key key) {
// Return value associated with key in the subtree rooted at x;
// return null if key not present in subtree rooted at x.
if (x == null) return null;
int cmp = key.compareTo(x.key);
if (cmp < 0) return get(x.left, key);
else if (cmp > 0) return get(x.right, key);
else return x.val;
}
@Override
public void put(Key key, Value val) {
root = put(root, key, val);
}
private Node put(Node<Key, Value> x, Key key, Value val) {
if (x == null)
return new Node(key, val, 1);
int cmp = key.compareTo(x.key);
if (cmp < 0)
x.left = put(x.left, key, val);
else if (cmp > 0)
x.right = put(x.right, key, val);
else
x.val = val;
x.N = size(x.left) + size(x.right) + 1;
return x;
}
@Override
public Key min() {
if(root == null)
throw new NoSuchElementException();
return min(root).key;
}
private Node<Key, Value> min(Node x) {
if (x.left == null)
return x;
return min(x.left);
}
@Override
public Key max() {
if(root == null)
throw new NoSuchElementException();
return max(root).key;
}
private Node<Key, Value> max(Node x) {
if (x.right == null) return x;
return max(x.right);
}
@Override
public Key floor(Key key) {
if(root == null)
throw new NoSuchElementException();
Node<Key, Value> x = floor(root, key);
if (x == null)
return null;
return x.key;
}
private Node<Key, Value> floor(Node<Key, Value> x, Key key) {
if (x == null)
return null;
int cmp = key.compareTo(x.key);
if (cmp == 0) return x;
if (cmp < 0) return floor(x.left, key);
Node<Key, Value> t = floor(x.right, key);
if (t != null) return t;
else return x;
}
@Override
public Key select(int k) {
return select(root, k).key;
}
private Node<Key, Value> select(Node x, int k) {
if (x == null) return null;
int t = size(x.left);
if (t > k) return select(x.left, k);
else if (t < k) return select(x.right, k-t-1);
else return x;
}
@Override
public int rank(Key key) {
return rank(key, root);
}
private int rank(Key key, Node<Key, Value> x) {
// Return number of keys less than x.key in the subtree rooted at x.
if (x == null) return 0;
int cmp = key.compareTo(x.key);
if (cmp < 0) return rank(key, x.left);
else if (cmp > 0) return 1 + size(x.left) + rank(key, x.right);
else return size(x.left);
}
@O.
A perfect left-sided binary tree is a binary tree where every intern.pdf
The document describes an algorithm to determine if an undirected graph G can be viewed as a perfect left-sided binary tree. It provides BFS and DFS algorithms in pseudocode that take G as input and return true if G is a perfect left-sided binary tree and false otherwise. Both algorithms have a time complexity of O(V+E) where V is the number of vertices and E is the number of edges in G.
import javautilQueue import javautilLinkedList import .pdf
import java.util.Queue;
import java.util.LinkedList;
import java.util.NoSuchElementException;
public class BinaryTree<T extends Comparable<T>> {
BTNode root;
public BinaryTree() {
root = null;
}
public BinaryTree(BTNode root) {
root = null;
}
public void purge(){
root = null;
}
public boolean isEmpty(){
return root == null;
}
public void insert(T key){
if (root == null) {
root = new BTNode(key);
return;
}
BTNode temp;
Queue<BTNode> q = new LinkedList<BTNode>();
q.add(root);
// Do level order traversal until we find the first empty left or right child.
while (!q.isEmpty()) {
temp = q.poll();
if (temp.left == null) {
temp.left = new BTNode(key);
break;
}
else
q.add(temp.left);
if (temp.right == null) {
temp.right = new BTNode(key);
break;
}
else
q.add(temp.right);
}
}
// delete by copying last node
public void deleteByCopying(T data){
if(root == null)
throw new UnsupportedOperationException("Tree is empty!");
else if(root.left == null && root.right == null){
if(root.data.equals(data))
root = null;
else
throw new NoSuchElementException(data + " not in the tree.");
return;
}
Queue<BTNode> queue = new LinkedList<BTNode>();
queue.add(root);
BTNode keyNode = null;
BTNode currentNode = null;
BTNode parentNode = root;
boolean found = false;
while(! queue.isEmpty()){
currentNode = queue.poll();
if(currentNode.data.equals(data)){
if(! found){
keyNode = currentNode;
found = true;
}
}
if(currentNode.left != null){
queue.add(currentNode.left);
parentNode = currentNode;
}
if(currentNode.right != null){
queue.add(currentNode.right);
parentNode = currentNode;
}
}
if(! found)
throw new NoSuchElementException(data + " not in tree.");
while(! queue.isEmpty()){
currentNode = queue.poll();
System.out.print(currentNode.data + " ");
if(currentNode.left != null){
queue.add(currentNode.left);
parentNode = currentNode;
}
if(currentNode.right != null){
queue.add(currentNode.right);
parentNode = currentNode;
}
}
keyNode.data = currentNode.data;
if(parentNode.left == currentNode)
parentNode.left = null;
else if(parentNode.right == currentNode)
parentNode.right = null;
}
public void levelOrderTraversal(){ // BreadthFirstTraversal
levelOrderTraversal(root);
}
// BreadthFirst Traversal
protected void levelOrderTraversal(BTNode root){
if(root == null)
return;
Queue<BTNode> queue = new LinkedList<BTNode>();
BTNode node = root;
queue.add(node);
while(! queue.isEmpty()){
node = queue.poll();
visit(node);
if(node.left != null)
queue.add(node.left);
if(node.right != null)
queue.add(node.right);
}
}
public void levelOrderTraversalByLevels(){
levelOrderTraversalByLevels(root);
}
protected void levelOrderTraversalByLevels(BTNode<T> root){
Queue q = new LinkedList();
int levelNodes = 0;
if(root==null)
return;
q.add(root);
while(!q.isEmpty()){
levelNodes = q.size();
while(levelNodes>0){
BTNode n = (BTNode)q.remove();
System.out.print(" " + n.data);
if(n.left!=null)
q.add(n.left);
if(n.right!=null)
q.add(n.right);
levelNodes--;
}
System.out.println("");
}
}
protected void visit(BTNode<T.
6. Generics. Collections. Streams
This document discusses Java generics, collections, streams and related concepts. It provides code examples of:
- Defining generic classes and methods
- Using common collection interfaces like List, Set, Map and their implementations
- Working with streams to perform operations on data in a declarative way
- Using lambda expressions and functional interfaces with streams
Recommended
Required to augment the authors Binary Search Tree (BST) code to .docx
The document provides instructions for augmenting a Binary Search Tree (BST) class to support new operations like returning the nth element, rank of an element, median element, and determining if the tree is perfect or complete. It explains that these operations could be done with in-order traversal but would be inefficient. Instead, each node should store the size of its subtree to guide searches more efficiently. The BST class code is provided to test the augmented operations on.
import java.util.Scanner;class BinaryNode{ BinaryNode left.pdf
This Java program defines classes to represent nodes and binary search trees. It implements methods to insert, delete, search for nodes in the tree as well as traverse the tree using inorder, preorder and postorder traversal. The main method tests the binary search tree operations by prompting the user to insert, delete, search for nodes and check if the tree is empty.
Create a class BinarySearchTree- A class that implements the ADT binar.pdf
Create a class BinarySearchTree. A class that implements the ADT binary search tree by
extending BinaryTree. Recursive version.
public class BinarySearchTree<T extends Comparable<? super T>>
extends BinaryTree<T> implements SearchTreeInterface<T>
{
public BinarySearchTree ()
{
super();
} // end default constructor
public BinarySearchTree (T rootEntry)
{
super();
setRootNode(new BinaryNode<>(rootEntry));
} // end constructor
public void setTree (T rootData) // Disable setTree (see Segment 25.6)
{
throw new UnsupportedOperationException();
} // end setTree
public void setTree (T rootData, BinaryTreeInterface<T> leftTree, BinaryTreeInterface<T>
rightTree)
{
throw new UnsupportedOperationException();
} // end setTree
//...
public T remove (T entry)
{
ReturnObject oldEntry = new ReturnObject(null);
BinaryNode<T> newRoot = removeEntry(getRootNode(), entry, oldEntry);
setRootNode(newRoot);
return oldEntry.get();
} // end remove
//...
private class ReturnObject
{
private T item;
private ReturnObject(T entry)
{
item = entry;
} // end constructor
public T get()
{
return item;
} // end get
public void set(T entry)
{
item = entry;
} // end set
} // end ReturnObject
} // end BinarySearchTree
HERE IS BinaryTree.java
import java.util.Iterator;
import java.util.NoSuchElementException;
public class BinaryTree<T> implements BinaryTreeInterface<T> {
private BinaryNode<T> root;
public BinaryTree() {
root = null;
}
public BinaryTree(T rootData) {
root = new BinaryNode<>(rootData);
}
public BinaryTree(T rootData, BinaryTree<T> leftTree, BinaryTree<T> rightTree) {
privateSetTree(rootData, leftTree, rightTree);
}
private void privateSetTree(T rootData, BinaryTree<T> leftTree, BinaryTree<T>
rightTree) {
root = new BinaryNode<>(rootData);
if (leftTree != null && !leftTree.isEmpty()) {
root.setLeftChild(leftTree.root);
}
if (rightTree != null && !rightTree.isEmpty()) {
if (rightTree != leftTree) {
root.setRightChild(rightTree.root);
} else {
root.setRightChild(rightTree.root.copy());
}
}
if (leftTree != null && leftTree != this) {
leftTree.clear();
}
if (rightTree != null && rightTree != this) {
rightTree.clear();
}
}
@Override
public T getRootData() {
if (isEmpty()) {
throw new EmptyTreeException("The tree is empty.");
}
return root.getData();
}
@Override
public int getHeight() {
return root.getHeight();
}
@Override
public int getNumberOfNodes() {
return root.getNumberOfNodes();
}
@Override
public boolean isEmpty() {
return root == null;
}
@Override
public void clear() {
root = null;
}
@Override
public Iterator<T> getPreorderIterator() {
return new PreorderIterator();
}
@Override
public Iterator<T> getInorderIterator() {
return new InorderIterator();
}
@Override
public Iterator<T> getPostorderIterator() {
return new PostorderIterator();
}
private class PreorderIterator implements Iterator<T> {
private StackInterface<BinaryNode<T>> nodeStack;
public PreorderIterator() {
nodeStack = new LinkedStack<>();
if (root != null) {
nodeStack.push(root);
}
}
public boolean hasNex.
It is the main program that implement the min(), max(), floor(), cei.pdf
It is the main program that implement the min(), max(), floor(), ceiling(), select(), rank(),delete(),
deleteMin(), deleteMax(), keys()
import java.util.NoSuchElementException;
public class BST, Value> {
private Node root;
private class Node {
private Key key;
private Value val;
private Node left, right;
private int size;
public Node(Key key, Value val, int size) {
this.key = key;
this.val = val;
this.size = size;
}
}
public BST() {
}
public boolean isEmpty() {
return size() == 0;
}
public int size() {
return size(root);
}
// return number of key-value pairs in BST rooted at x
private int size(Node x) {
if (x == null) return 0;
else return x.size;
}
public boolean contains(Key key) {
if (key == null) throw new NullPointerException(\"argument to contains() is null\");
return get(key) != null;
}
public Value get(Key key) {
return get(root, key);
}
private Value get(Node x, Key key) {
if (x == null) return null;
int cmp = key.compareTo(x.key);
if (cmp < 0) return get(x.left, key);
else if (cmp > 0) return get(x.right, key);
else return x.val;
}
public void put(Key key, Value val) {
if (key == null) throw new NullPointerException(\"first argument to put() is null\");
if (val == null) {
delete(key);
return;
}
root = put(root, key, val);
assert check();
}
private Node put(Node x, Key key, Value val) {
if (x == null) return new Node(key, val, 1);
int cmp = key.compareTo(x.key);
if (cmp < 0) x.left = put(x.left, key, val);
else if (cmp > 0) x.right = put(x.right, key, val);
else x.val = val;
x.size = 1 + size(x.left) + size(x.right);
return x;
}
public void deleteMax() {
if (isEmpty()) throw new NoSuchElementException(\"Symbol table underflow\");
root = deleteMax(root);
assert check();
}
private Node deleteMax(Node x) {
if (x.right == null) return x.left;
x.right = deleteMax(x.right);
x.size = size(x.left) + size(x.right) + 1;
return x;
}
public void delete(Key key) {
if (key == null) throw new NullPointerException(\"argument to delete() is null\");
root = delete(root, key);
assert check();
}
private Node delete(Node x, Key key) {
if (x == null) return null;
int cmp = key.compareTo(x.key);
if (cmp < 0) x.left = delete(x.left, key);
else if (cmp > 0) x.right = delete(x.right, key);
else {
if (x.right == null) return x.left;
if (x.left == null) return x.right;
Node t = x;
x = min(t.right);
x.right = deleteMin(t.right);
x.left = t.left;
}
x.size = size(x.left) + size(x.right) + 1;
return x;
}
public Key min() {
if (isEmpty()) throw new NoSuchElementException(\"called min() with empty symbol
table\");
return min(root).key;
}
private Node min(Node x) {
if (x.left == null) return x;
else return min(x.left);
}
public Key max() {
if (isEmpty()) throw new NoSuchElementException(\"called max() with empty symbol
table\");
return max(root).key;
}
private Node max(Node x) {
if (x.right == null) return x;
else return max(x.right);
}
public Key floor(Key key) {
if (key == null) throw new NullPointerException(\"argument to floor() is null\");
if (isEmpty()) throw ne.
package edu-ser222-m03_02- --- - A binary search tree based impleme.docx
package edu.ser222.m03_02;
/**
* A binary search tree based implementation of a symbol table.
*
* Completion time: (your completion time)
*
* @author (your name), Sedgewick, Acuna
* @version (version)
*/
import java.util.Collections;
import java.util.LinkedList;
import java.util.NoSuchElementException;
import java.util.Queue;
public class CompletedBST<Key extends Comparable<Key>, Value> implements BST<Key, Value> {
private Node<Key, Value> root;
@Override
public int size() {
return size(root);
}
private int size(Node x) {
if (x == null)
return 0;
else
return x.N;
}
@Override
public Value get(Key key) {
Node<Key, Value> iter = root;
while(iter != null) {
int cmp = key.compareTo(iter.key);
if (cmp < 0)
iter = iter.left;
else if (cmp > 0)
iter = iter.right;
else
return iter.val;
}
return null;
}
private Value get(Node<Key, Value> x, Key key) {
// Return value associated with key in the subtree rooted at x;
// return null if key not present in subtree rooted at x.
if (x == null) return null;
int cmp = key.compareTo(x.key);
if (cmp < 0) return get(x.left, key);
else if (cmp > 0) return get(x.right, key);
else return x.val;
}
@Override
public void put(Key key, Value val) {
root = put(root, key, val);
}
private Node put(Node<Key, Value> x, Key key, Value val) {
if (x == null)
return new Node(key, val, 1);
int cmp = key.compareTo(x.key);
if (cmp < 0)
x.left = put(x.left, key, val);
else if (cmp > 0)
x.right = put(x.right, key, val);
else
x.val = val;
x.N = size(x.left) + size(x.right) + 1;
return x;
}
@Override
public Key min() {
if(root == null)
throw new NoSuchElementException();
return min(root).key;
}
private Node<Key, Value> min(Node x) {
if (x.left == null)
return x;
return min(x.left);
}
@Override
public Key max() {
if(root == null)
throw new NoSuchElementException();
return max(root).key;
}
private Node<Key, Value> max(Node x) {
if (x.right == null) return x;
return max(x.right);
}
@Override
public Key floor(Key key) {
if(root == null)
throw new NoSuchElementException();
Node<Key, Value> x = floor(root, key);
if (x == null)
return null;
return x.key;
}
private Node<Key, Value> floor(Node<Key, Value> x, Key key) {
if (x == null)
return null;
int cmp = key.compareTo(x.key);
if (cmp == 0) return x;
if (cmp < 0) return floor(x.left, key);
Node<Key, Value> t = floor(x.right, key);
if (t != null) return t;
else return x;
}
@Override
public Key select(int k) {
return select(root, k).key;
}
private Node<Key, Value> select(Node x, int k) {
if (x == null) return null;
int t = size(x.left);
if (t > k) return select(x.left, k);
else if (t < k) return select(x.right, k-t-1);
else return x;
}
@Override
public int rank(Key key) {
return rank(key, root);
}
private int rank(Key key, Node<Key, Value> x) {
// Return number of keys less than x.key in the subtree rooted at x.
if (x == null) return 0;
int cmp = key.compareTo(x.key);
if (cmp < 0) return rank(key, x.left);
else if (cmp > 0) return 1 + size(x.left) + rank(key, x.right);
else return size(x.left);
}
@O.
A perfect left-sided binary tree is a binary tree where every intern.pdf
The document describes an algorithm to determine if an undirected graph G can be viewed as a perfect left-sided binary tree. It provides BFS and DFS algorithms in pseudocode that take G as input and return true if G is a perfect left-sided binary tree and false otherwise. Both algorithms have a time complexity of O(V+E) where V is the number of vertices and E is the number of edges in G.
import javautilQueue import javautilLinkedList import .pdf
import java.util.Queue;
import java.util.LinkedList;
import java.util.NoSuchElementException;
public class BinaryTree<T extends Comparable<T>> {
BTNode root;
public BinaryTree() {
root = null;
}
public BinaryTree(BTNode root) {
root = null;
}
public void purge(){
root = null;
}
public boolean isEmpty(){
return root == null;
}
public void insert(T key){
if (root == null) {
root = new BTNode(key);
return;
}
BTNode temp;
Queue<BTNode> q = new LinkedList<BTNode>();
q.add(root);
// Do level order traversal until we find the first empty left or right child.
while (!q.isEmpty()) {
temp = q.poll();
if (temp.left == null) {
temp.left = new BTNode(key);
break;
}
else
q.add(temp.left);
if (temp.right == null) {
temp.right = new BTNode(key);
break;
}
else
q.add(temp.right);
}
}
// delete by copying last node
public void deleteByCopying(T data){
if(root == null)
throw new UnsupportedOperationException("Tree is empty!");
else if(root.left == null && root.right == null){
if(root.data.equals(data))
root = null;
else
throw new NoSuchElementException(data + " not in the tree.");
return;
}
Queue<BTNode> queue = new LinkedList<BTNode>();
queue.add(root);
BTNode keyNode = null;
BTNode currentNode = null;
BTNode parentNode = root;
boolean found = false;
while(! queue.isEmpty()){
currentNode = queue.poll();
if(currentNode.data.equals(data)){
if(! found){
keyNode = currentNode;
found = true;
}
}
if(currentNode.left != null){
queue.add(currentNode.left);
parentNode = currentNode;
}
if(currentNode.right != null){
queue.add(currentNode.right);
parentNode = currentNode;
}
}
if(! found)
throw new NoSuchElementException(data + " not in tree.");
while(! queue.isEmpty()){
currentNode = queue.poll();
System.out.print(currentNode.data + " ");
if(currentNode.left != null){
queue.add(currentNode.left);
parentNode = currentNode;
}
if(currentNode.right != null){
queue.add(currentNode.right);
parentNode = currentNode;
}
}
keyNode.data = currentNode.data;
if(parentNode.left == currentNode)
parentNode.left = null;
else if(parentNode.right == currentNode)
parentNode.right = null;
}
public void levelOrderTraversal(){ // BreadthFirstTraversal
levelOrderTraversal(root);
}
// BreadthFirst Traversal
protected void levelOrderTraversal(BTNode root){
if(root == null)
return;
Queue<BTNode> queue = new LinkedList<BTNode>();
BTNode node = root;
queue.add(node);
while(! queue.isEmpty()){
node = queue.poll();
visit(node);
if(node.left != null)
queue.add(node.left);
if(node.right != null)
queue.add(node.right);
}
}
public void levelOrderTraversalByLevels(){
levelOrderTraversalByLevels(root);
}
protected void levelOrderTraversalByLevels(BTNode<T> root){
Queue q = new LinkedList();
int levelNodes = 0;
if(root==null)
return;
q.add(root);
while(!q.isEmpty()){
levelNodes = q.size();
while(levelNodes>0){
BTNode n = (BTNode)q.remove();
System.out.print(" " + n.data);
if(n.left!=null)
q.add(n.left);
if(n.right!=null)
q.add(n.right);
levelNodes--;
}
System.out.println("");
}
}
protected void visit(BTNode<T.
6. Generics. Collections. Streams
This document discusses Java generics, collections, streams and related concepts. It provides code examples of:
- Defining generic classes and methods
- Using common collection interfaces like List, Set, Map and their implementations
- Working with streams to perform operations on data in a declarative way
- Using lambda expressions and functional interfaces with streams
Binary Tree
The document provides C code examples for various binary tree operations and traversals including: finding the height/depth and size of a tree, deleting a tree by freeing its nodes, determining if two trees are identical, finding the minimum value in a BST, creating a mirror copy of a tree, computing the maximum depth, returning a pointer to the nth node of an inorder traversal, level order traversal, deleting a node from a BST, searching a BST, counting leaves, and iterative preorder, inorder and postorder traversals. For each operation, the code is presented and discussed.
Given the following codepackage data1;import java.util.;p.pdf
Given the following code
package data1;
import java.util.*;
/*public class BST> implementing a set ADT and containing the following:
* private inner class BinaryNode representing a node with a (possibly) left child and a (possibly)
right child
** instance fields BinaryNode root, int size
* contains/insert/remove method - w/ O(height) complexity
** size O(1), isEmpty O(1), clear O(1),
*** findMin, findMax, findHeight methods - w/ O(height) complexity
**** toString() method printing set (in-order traversal) and the tree (BFS traversal)
**
*/
publicclass BST> {
private BinaryNode root;
privateint size;
//Search opertion of Set ADT
publicboolean contains(E value) {
return contains(root, value);
}
//Insert opertion of Set ADT
publicvoid insert(E value) {
root = insert(root, value);
size++;
}
//Remove operation of Set ADT
publicvoid remove(E value){
root = remove(root, value);
size--;
}
publicint size(){
return size;
}
publicboolean isEmpty(){
return root == null;
}
publicvoid clear(){
root = null;
size = 0;
}
public E findMin(){
return findMin(root);
}
public E findMax(){
return findMax(root);
}
publicint findHeight(){
return root.height();
}
public String toString(){
if(root == null)
return "set {} stored in an empty tree.\n";
String elements = root.inOrder().toString();
return "set {" + elements.substring(1,elements.length()-1) + "} stored in tree \n" + root;
}
private E findMin(BinaryNode node){
if(node == null)
returnnull;
if(node.left == null)
return node.element;
return findMin(node.left);
}
private E findMax(BinaryNode node){
if(node == null)
returnnull;
if(node.right == null)
return node.element;
return findMax(node.right);
}
privateboolean contains(BinaryNode node, E value) {
if (node == null)//node represents an empty substree
returnfalse;
int comparisonResult = value.compareTo(node.element);
if(comparisonResult < 0)//if value is less than root's value
return contains(node.left, value);
if(comparisonResult > 0)//if value is greater than root's value
return contains(node.right, value);
returntrue;//successful search
}
private BinaryNode insert(BinaryNode node, E value) {
if (node == null)//base case: empty tree
returnnew BinaryNode<>(value);
if (value.compareTo(node.element) < 0)
node.left = insert(node.left, value);//insert recursively to left-subtree
elseif (value.compareTo(node.element) > 0)
node.right = insert(node.right, value);//insert recursively to right-subtree
else {//duplicate value cannot be inserted in a BST implementing the Set ADT
size--;//insertion failed!
//System.out.print("BST.insert: Warning: " + value + " is already stored in the tree \n" + node);
}
return node;
}
private BinaryNode remove(BinaryNode node, E value) {
if (node == null) {//base case: empty tree
System.out.println("BST.remove: Warning: " + value + " doesn't exist in the tree.");
size++;//removal failed!
return node;
}
if (value.compareTo(node.element) < 0)
node.left = remove(node.left, value);
elseif (value.compareTo(node.element) > 0)
node.right = remov.
I have a .java program that I need to modify so that it1) reads i.pdf
I have a .java program that I need to modify so that it:
1) reads in a file called books.txt (i will provide a few lines of the text file below)
2) outputs a statement every time there's a collision (see the example output below in the original
prompt)
THIS IS THE ORIGINAL PROMPT:
Part A: Modify the attached code to build and customize a AVL tree of Book nodes. Using an
input file, insert Book nodes and detect imbalance. If imbalance is true, then call the proper
rotation function as discussed in the lecture to fix the imbalance condition.
Must read AVLNode data from a text file
Create a Book Object; and an AVL node object to be inserted into the AVL tree
At each insert, detect imbalance and fix the AVL tree
Report each imbalance detection and the node where it occurred; and output the message:
Example Output:
Imbalance condition occurred at inserting ISBN 12345; fixed in LeftRight Rotation
Imbalance condition occurred at inserting ISBN 87654; fixed in Left Rotation
Imbalance condition occurred at inserting ISBN 974321; fixed in RightLeft Rotation
class AVLNode {
Book bookObject;
int height;
AVLNode leftPtr;
AVLNode rightPtr;
}
BELOW IS THE CODE I NEED TO MODIFY:
// AVL Binary search tree implementation in Java
// Author: AlgorithmTutor
// data structure that represents a node in the tree
class Node {
int data; // holds the key
Node parent; // pointer to the parent
Node left; // pointer to left child
Node right; // pointer to right child
int bf; // balance factor of the node
public Node(int data) {
this.data = data;
this.parent = null;
this.left = null;
this.right = null;
this.bf = 0;
}
}
public class AVLTree {
private Node root;
public AVLTree() {
root = null;
}
private void printHelper(Node currPtr, String indent, boolean last) {
// print the tree structure on the screen
if (currPtr != null) {
System.out.print(indent);
if (last) {
System.out.print("R----");
indent += " ";
} else {
System.out.print("L----");
indent += "| ";
}
System.out.println(currPtr.data + "(BF = " + currPtr.bf + ")");
printHelper(currPtr.left, indent, false);
printHelper(currPtr.right, indent, true);
}
}
private Node searchTreeHelper(Node node, int key) {
if (node == null || key == node.data) {
return node;
}
if (key < node.data) {
return searchTreeHelper(node.left, key);
}
return searchTreeHelper(node.right, key);
}
private Node deleteNodeHelper(Node node, int key) {
// search the key
if (node == null) return node;
else if (key < node.data) node.left = deleteNodeHelper(node.left, key);
else if (key > node.data) node.right = deleteNodeHelper(node.right, key);
else {
// the key has been found, now delete it
// case 1: node is a leaf node
if (node.left == null && node.right == null) {
node = null;
}
// case 2: node has only one child
else if (node.left == null) {
Node temp = node;
node = node.right;
}
else if (node.right == null) {
Node temp = node;
node = node.left;
}
// case 3: has both children
else {
Node temp = minimum(node.right);
node.data = temp.data;
node.right = .
mainpublic class AssignmentThree { public static void ma.pdf
// main
public class AssignmentThree
{
public static void main(String[] args)
{
List myList = new List(15);
// Cause List Empty Message
myList.removeFront();
myList.removeRear();
myList.removeItem(\"a\");
// Cause Not found message
myList.addToFront(\"x\");
myList.removeItem(\"y\");
myList.removeItem(\"x\");
myList.addAfterItem(\"x\", \"z\");
myList.addBeforeItem(\"x\", \"z\");
// Normal behavior
myList.addToFront(\"not.\");
myList.addToFront(\"or\");
myList.addToRear(\"is\");
myList.addToRear(\"try.\");
myList.addAfterItem(\"is\", \"no\");
myList.addBeforeItem(\"is\", \"There\");
myList.addToFront(\"Do\");
myList.addAfterItem(\"or\", \"do\");
myList.print(\"Original list\");
myList.printSorted(\"Sorted Original List\");
sop(\"\ Front is \" + myList.getFront());
sop(\"Rear is \" + myList.getRear());
sop(\"Count is \" + myList.askCount());
sop(\"Is There present? \" + myList.isPresent(\"There\"));
sop(\"Is Dog present? \" + myList.isPresent(\"Dog\"));
myList.addToFront(\"junk\");
myList.addToRear(\"morejunk\");
myList.addAfterItem(\"or\", \"moremorejunk\");
myList.print(\"List with junk\");
sop(\"Count is \" + myList.askCount());
myList.removeFront();
myList.removeRear();
myList.removeItem(\"moremorejunk\");
myList.print(\"List with junk removed\");
sop(\"Count is \" + myList.askCount());
sop(\"\");
// Cause List Full message
for(int ii = 0; ii < 10; ++ii)
{
myList.addToFront(DUMMY);
}
myList.addToRear(DUMMY);
myList.addBeforeItem(\"no\", DUMMY);
myList.addAfterItem(\"There\", DUMMY);
myList.print(\"After filling List\");
sop(\"Count is \" + myList.askCount());
while(myList.isPresent(DUMMY)) myList.removeItem(DUMMY);
myList.print(\"After removing \" + DUMMY );
sop(\"Count is \" + myList.askCount());
}
private static void sop(String s)
{
System.out.println(s);
}
private static final String DUMMY = \"dummy\";
}
Solution
Following is MyList implementation for your output as:
Java Code:
import java.util.Comparator;
public class MyList {
private Node start;
private Node end;
private int size;
private int capacity;
public MyList(int capacity) {
start = null;
end = null;
size = 0;
this.capacity = capacity;
}
/* Function to check if list is empty */
public boolean isEmpty() {
return start == null;
}
public void removeFront() {
if (isEmpty()) {
System.out.println(\"List Empty\");
return;
} else {
start = start.next;
size--;
return;
}
}
public void removeRear() {
if (size == 0) {
System.out.println(\"List Empty\");
return;
}
if (start.next == null) {
start=null;
end=null;
size=0;
}
Node node = start.next;
while (node.next != null) {
node = node.next;
}
node.next = null;
end = node;
size--;
}
public void removeItem(String key) {
if (size == 0) {
System.out.println(\"List Empty\");
return;
}
if (start.next == null) {
if (start.key.equals(key)) {
start=null;
end=null;
size=0;
} else {
System.out.println(\"\");
}
return;
}
Node node = start;
Node nodeNext = node.next;
while (nodeNext.next != null) {
if (nodeNext.key.equals(key)) {
node.next=nodeNext.next;
}.
Once you have all the structures working as intended- it is time to co.docx
Once you have all the structures working as intended, it is time to compare the
performances of the 2. Use runBenchmark() to start.
a. First, generate an increasing number (N) of random integers (1000, 5000, 10000,
50000, 75000, 100000, 500000 or as far as your computing power will let you)
i. Time and print how long it takes to insert the random integers into an initially
empty BST. Do not print the tree.
You can get a random list using the java class Random, located in
java.util.Random. To test the speed of the insertion algorithm, you should use
the System.currentTimeMillis() method, which returns a long that contains the
current time (in milliseconds). Call System.currentTimeMillis() before and after
the algorithm runs and subtract the two times. (Instant.now() is an alternative
way of recording the time.)
ii. Time and print how long it takes to insert the same random integers into an
initially empty AVL tree. Do not print the tree.
iii. If T(N) is the time function, how does the growth of TBST(N) compare with the
growth of TAVL(N)?
Plot a simple graph to of time against N for the two types of BSTs to visualize
your results.
b. Second, generate a list of k random integers. k is also some large value.
i. Time how long it takes to search your various N-node BSTs for all k random
integers. It does not matter whether the search succeeds.
ii. Time how long it takes to search your N-node AVL trees for the same k random
integers.
iii. Compare the growth rates of these two search time-functions with a graph the
same way you did in part a.
public class BinarySearchTree<AnyType extends Comparable<? super AnyType>> {
protected BinaryNode<AnyType> root;
public BinarySearchTree() {
root = null;
}
/**
* Insert into the tree; duplicates are ignored.
*
* @param x the item to insert.
* @param root
* @return
*/
protected BinaryNode<AnyType> insert(AnyType x, BinaryNode<AnyType> root) {
// If the root is null, we've reached an empty leaf node, so we create a new node
// with the value x and return it
if (root == null) {
return new BinaryNode<>(x, null, null);
}
// Compare the value of x to the value stored in the root node
int compareResult = x.compareTo(root.element);
// If x is less than the value stored in the root node, we insert it into the left subtree
if (compareResult < 0) {
root.left = insert(x, root.left);
}
// If x is greater than the value stored in the root node, we insert it into the right subtree
else if (compareResult > 0) {
root.right = insert(x, root.right);
}
// If x is equal to the value stored in the root node, we ignore it since the tree does not allow duplicates
return root;
}
/**
* Counts the number of leaf nodes in this tree.
*
* @param t The root of the tree.
* @return
*/
private int countLeafNodes(BinaryNode<AnyType> root) {
// If the root is null, it means the tree is empty, so we return 0
if (root == null) {
return 0;
}
// If the root has no children, it means it is a leaf node, so we return 1
if (root.left == .
( PLEASE SHOW HOW TO IMPLEMENT THE DELETION FUNCTION )SAMPLE OUTPU.pdf
( PLEASE SHOW HOW TO IMPLEMENT THE DELETION FUNCTION )
SAMPLE OUTPUT: Instead of using a linked list to resolve collisions, as in separate chaining,
use a binary search tree. That is, create a hash table that is an array of trees. You could use H(X)
= X % arraysize as the hash function in your hash table implementation. The arraySize needs to
be an input parameter from users. Your solution should support the basic hash table inserting,
searching, and displaying functions. To display a small tree-based hash table, you could use an
in-order traversal of each tree. The advantage of a tree over a linked list is that it can be searched
in O(logN) instead of O(N) time. Checking 15 items takes a maximum of 15 comparisons in a
list but only 4 in a tree. Duplicates can present problems in both trees and hash tables, so add
some code that prevents a duplicate key from being inserted in the hash table. To shorten the
listing for this program, you can forget about deletion, which for trees requires a lot of code. [ten
bonus points will be given to those who implement the deletion function.]
Solution
import java.util.Scanner;
class BinaryNode
{
BinaryNode lchild, rchild;
int data;
public BinaryNode(int d)
{
data = d;
lchild = null;
rchild = null;
}
}
class HashTableusingBinaryTree
{
private BinaryNode[] t;
private int size ;
public HashTableusingBinaryTree(int tableSize)
{
t = new BinaryNode[ nextPosition(tableSize) ];
size = 0;
}
public boolean isEmpty()
{
return size == 0;
}
public void Empty()
{
int l = t.length;
t = new BinaryNode[l];
size = 0;
}
public int sizeofht()
{
return size;
}
public void insert(int val)
{
size++;
int pos = myhashtable(val);
BinaryNode head = t[pos];
head = insert(head, val);
t[pos] = head;
}
private BinaryNode insert(BinaryNode node, int data)
{
if (node == null)
node = new BinaryNode(data);
else
{
if (data <= node.data)
node.lchild = insert(node.lchild, data);
else
node.rchild = insert(node.rchild, data);
}
return node;
}
public void remove(int val)
{
int pos = myhashtable(val);
BinaryNode head = t[pos];
try
{
head = delete(head, val);
size--;
}
catch (Exception e)
{
System.out.println(\"\ Element not present\ \");
}
t[pos] = head;
}
private BinaryNode delete(BinaryNode head, int k)
{
BinaryNode a, b, n;
if (head.data == k)
{
BinaryNode lt, rt;
lt = head.lchild;
rt = head.rchild;
if (lt == null && rt == null)
return null;
else if (lt == null)
{
a = rt;
return a;
}
else if (rt == null)
{
a = lt;
return a;
}
else
{
b = rt;
a = rt;
while (a.lchild != null)
a = a.lchild;
a.lchild = lt;
return b;
}
}
if (k < head.data)
{
n = delete(head.lchild, k);
head.lchild = n;
}
else
{
n = delete(head.rchild, k);
head.rchild = n;
}
return head;
}
private int myhashtable(Integer x )
{
int hashVal = x.hashCode( );
hashVal %= t.length;
if (hashVal < 0)
hashVal += t.length;
return hashVal;
}
private static int nextPosition( int r )
{
if (r % 2 == 0)
r++;
for ( ; !isnext( r ); r += 2);
return r;
}
private static boolean isnext( int r )
{
if (r ==.
1. Add a breadth-first (level-order) traversal function to the binar.pdf
1. Add a breadth-first (level-order) traversal function to the binary tree code.
2. Add a function to find the height of a tree.
3. Re-implement one of the depth-first traversal methods using a stack instead of recursion.
4. Add a link to each nodes parent node.
#include
#include
#include
using namespace std;
template < typename T >
class TreeNode
{
public:
T element; //
TreeNode < T > * left; //
TreeNode < T > * right; //
TreeNode * next;
TreeNode() //
{
left = NULL;
next = NULL;
}
TreeNode(T element) // Constructor
{
this->element = element;
left = NULL;
right = NULL;
}
};
template < typename T >
class BinaryTree
{
public:
BinaryTree();
BinaryTree(T elements[], int arraySize);
bool insert(T element);
void inorder();
void preorder();
void postorder();
int getSize();
bool search(T element);
void breadthFirstTraversal();
int depth();
private:
TreeNode < T > * root;
int size;
void inorder(TreeNode < T > * root);
void postorder(TreeNode < T > * root);
void preorder(TreeNode < T > * root);
bool search(T element, TreeNode < T > * root);
int depth(TreeNode * root);
};
template < typename T >
BinaryTree < T >::BinaryTree()
{
root = NULL;
size = 0;
}
template < typename T >
BinaryTree < T >::BinaryTree(T elements[], int arraySize)
{
root = NULL;
size = 0;
for (int i = 0; i < arraySize; i++)
{
insert(elements[i]);
}
}
template < typename T >
bool BinaryTree < T >::insert(T element)
{
if (root == NULL)
root = new TreeNode < T > (element); // Create a new root
else
{
// Locate the parent node
TreeNode < T > * parent = NULL;
TreeNode < T > * current = root;
while (current != NULL)
if (element < current->element)
{
parent = current;
current = current->left;
}
else if (element > current->element)
{
parent = current;
current = current->right;
}
else
return false; // Duplicate node not inserted
// Create the new node and attach it to the parent node
if (element < parent->element)
parent->left = new TreeNode < T > (element);
else
parent->right = new TreeNode < T > (element);
}
size++;
return true; // Element inserted
}
/* Inorder traversal */
template < typename T >
void BinaryTree < T >::inorder()
{
inorder(root);
}
/* Inorder traversal from a subtree */
template < typename T >
void BinaryTree < T >::inorder(TreeNode < T > * root)
{
if (root == NULL) return;
inorder(root->left);
cout << root->element << \" \";
inorder(root->right);
}
/* Postorder traversal */
template < typename T >
void BinaryTree < T >::postorder()
{
postorder(root);
}
/** Inorder traversal from a subtree */
template < typename T >
void BinaryTree < T >::postorder(TreeNode < T > * root)
{
if (root == NULL) return;
postorder(root->left);
postorder(root->right);
cout << root->element << \" \";
}
/* */
template < typename T >
void BinaryTree < T >::preorder()
{
preorder(root);
}
/* */
template < typename T >
void BinaryTree < T >::preorder(TreeNode < T > * root)
{
if (root == NULL) return;
cout << root->element << \" \";
preorder(root->left);
preorder(root->right);
}
/**/
template < typename .
I need help finishing this code in JavaYou will need to create t.pdf
I need help finishing this code in Java
You will need to create the preOrder and postOrder traversal methods, as these will be used to
determine if your insertion methods are correct.
protected class Node {
public int data;
public Node left, right, parent;
public Node(int _data) {
data = _data;
left = right = parent = null;
}
public Node(int _data, Node _parent) {
data = _data;
left = right = null;
parent = _parent;
}
}
protected Node root;
public BST() {
root = null;
}
public void insert(int data) {
if (root == null) {
root = new Node(data);
} else {
insert(data, root);
}
}
protected void insert(int data, Node n) {
// TODO: Insert Method
}
public ArrayList inOrderTraversal() {
return inOrderTraversal(root);
}
private ArrayList inOrderTraversal(Node n) {
if (n == null) {
return new ArrayList<>();
}
ArrayList traversal = new ArrayList<>();
traversal.addAll(inOrderTraversal(n.left));
traversal.add(n.data);
traversal.addAll(inOrderTraversal(n.right));
return traversal;
}
public ArrayList preOrderTraversal() {
return preOrderTraversal(root);
}
private ArrayList preOrderTraversal(Node n) {
// TODO: preOrderTraveral Method
return new ArrayList();
}
public ArrayList postOrderTraversal() {
return postOrderTraversal(root);
}
private ArrayList postOrderTraversal(Node n) {
// TODO: postOrderTraversal Method
return new ArrayList();
}
protected static int height(Node n) {
if (n == null) {
return -1;
}
int lheight = height(n.left);
int rheight = height(n.right);
if (lheight > rheight) {
return 1 + lheight;
}
return 1 + rheight;
}
public int height() {
return height(root);
}
} BST Insertion protected void insert(int data, Node n ) if data < n.data if n. left is null n.left =
new Node(data, n ) else insert(data, n.left) else if data > n.data if n.right is null n.right = new
Node(data, n) else insert(data, n.right)
BST Traversals You are responsible for implementing the and postOrderTraversal(Node n )
methods that generate the string representation of the tree using the specified traversal. The
inorderTraversal (Node n ) method has been implemented for you; use that to match the
formatting of the output strings (this is the most "output matching" you will have to do this
semester)..
Table.java Huffman code frequency tableimport java.io.;im.docx
The document defines classes for building a Huffman coding tree from character frequencies in a file. It includes classes for a frequency table, priority queue, tree nodes, and the Huffman algorithm. The Huffman class constructs the tree from a file, inserts codewords, and can encode and decode a string using the tree. It outputs entropy and average code length metrics.
ANSimport java.util.Scanner; class Bina_node { Bina_node .pdf
This document contains Java code that defines a binary tree class with methods for inserting nodes, searching for values, counting nodes, checking if the tree is empty, and traversing the tree in preorder, inorder and postorder manners. A main method is included that allows a user to test the binary tree operations by selecting options from a menu to insert nodes, search, count nodes or check emptiness and displays the results of tree traversals.
week-14x
This C program uses functions to perform operations on a doubly linked list including creation, insertion, deletion, and traversal. The main menu allows the user to choose these operations. Functions are defined to allocate memory for nodes, search for a node, print the list, append a new node, create the initial list, delete a node, and insert a new node into the middle of the list.
This is to test a balanced tree. I need help testing an unbalanced t.pdf
this is business analytics question. (using gurobi) The days-off scheduling problem must be
solved routinely by businesses that operate 6 or 7 days a week. Examples include hospitals,
airlines, municipal transportation companies, and the postal service. The most common example
is the (5,7)-cyclic staffing problem. The objective of it is to minimize the cost of assigning
workers to a 7-day cyclic schedule so that 1) Sufficient workers are available every day. 2) Each
person works 5 consecutive days and is idle to the remaining 2 days. Here is the table showing
the cost of having an employee for each day and the number of employees required for each day.
For example, the pattern that one works from Sunday to Thursday costs 90+604=330. Formulate
and solve an integer programming problem to represent this problem. How many employees
work Monday-Friday?.
Scala vs Java 8 in a Java 8 World
Scala is becoming the language of choice for many development teams. This talk highlights how Scala excels in the world of multi-core processing and explores how it compares to Java 8.
Video Presentation: http://youtu.be/8vxTowBXJSg
Here is the code given in the instructionsclass AVL {.pdf
Here is the code given in the instructions:
class AVL {
Node root;
private class Node {
int data;
Node left, right;
int height;
private Node(int D, Node L, Node R, int H) {
data=D;
left=L;
right=R;
height=H; // user has to set height
} // of constructor Node
} //of Node
static private void UpdateHeight(Node T) {
if (T ==null) return;
else T.height = Math.max(HEIGHT(T.left),HEIGHT(T.right)) + 1;
} // UPdate Height
static private int HEIGHT(Node T) {
if (T== null ) return(-1);
else return (T.height);
}
// we need to more our right child up
static private Node LeftRotate(Node T) {
System.out.println(\"left rotate with data \" + T.data);
Node Tr;
Tr=T.right; // right child
T.right=Tr.left; // our right child IS NOW hhh
Tr.left=T; // move T down to the left
UpdateHeight(Tr.left); // update the height of T
UpdateHeight(Tr); // update hte height of the new root
return Tr;
} // of LeftRotate
// we move our immediate left node up.
// in doing so, we are now immediat right of our left child
static private Node RightRotate(Node T) {
Node Tl;
System.out.println(\"left rotate with data \" + T.data);
Tl=T.left; // left child
T.left=Tl.right; // our left child is now what our left was pointing to
Tl.right=T; // move T down to the right
UpdateHeight(Tl.right); // update the height of T
UpdateHeight(Tl); // update hte height of the new root
return Tl;
} // of RightRotate
public AVL() {
root=null;
} // of constructor AVL
// method to allow external entity to insert an element into the tree
public void insert(int D)
{
root=insert_internal(D, root);
} // of insert
private Node insert_internal(int D, Node T) {
if (T==null) return( new Node (D, null, null, 0));
if (T.data == D) return T; // the data is already in there
if ( D < T. data ) // go left
{ if (T.left == null)
{
T.left = insert_internal(D,null);
UpdateHeight(T);
}
else { //interior node
T.left = insert_internal(D, T.left);
}
} // of go left
else // D goes to the right
{ if (T.right == null)
{
T.right = insert_internal(D,null);
UpdateHeight(T);
}
else { //interior node
T.right = insert_internal(D, T.right);
}
} // of go right
// now we have to figure out if things are out of
// balance
int diff= HEIGHT(T.right) - HEIGHT(T.left);
System.out.println(\"difference is \" + diff + \" data is \" + T.data);
if ( Math.abs(diff) <= 1) // we are good to go at this level
{
UpdateHeight(T);
return(T);
}
// only if diff is bigger than 1
if ( diff > 1)// right leaning
{ // look at right child and figure out how it is leaning
} // of right leaning
else // left leaning
{ // look at left child to see how it is leaning
Node child = T.left;
int cdiff;
cdiff = HEIGHT(child.right) - HEIGHT(child.left);
System.out.println(\"cdiff is \" + cdiff);
if ( cdiff < 0 ) // left left lean
{ T=RightRotate(T); }
else
{
System.out.println(\"SHAUN\");
preorder_internal(T);
T.left = LeftRotate(T.left);
System.out.println(\"SHAUN\");
preorder_internal(T);
T=RightRotate(T);
}
} // of left leaning
// at this point we have rotated, so we need to.
Modify HuffmanTree.java and HuffmanNode.java to allow the user to se.pdf
Modify HuffmanTree.java and HuffmanNode.java to allow the user to select the value of n 9 to
construct an n ary Huffman Tree. Once finished, verify the accuracy of your tree by running it
for the English Alphabet for n = 3, 4, 5, 6, 7, 8, 9. For each value of n, compute the average
codeword length. Write these in a table (n vs. ACW L(Cn)).
/ HuffmanTree.java
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.util.ArrayList;
import java.util.Scanner;
public class HuffmanTree {
public static void main(String[] args){
Scanner in = new Scanner(System.in);
System.out.print(\"Enter the file name: \");
String fileName = in.nextLine();
ArrayList nodes = new ArrayList<>();
ArrayList temp = new ArrayList<>();
try {
Scanner fin = new Scanner(new FileReader(fileName));
String symbol;
double prob;
while(fin.hasNext()){
symbol = fin.next();
prob = fin.nextDouble();
nodes.add(findInsertIndex(nodes, prob), new HuffmanNode(symbol, prob));
}
fin.close();
temp.addAll(nodes);
HuffmanNode root = createHuffmanTree(temp);
setCodeWords(root);
double avg = 0;
for (HuffmanNode node : nodes) {
System.out.println(node.getS() + \": \" + node.getC() + \": \" + node.getL());
avg += node.getL();
}
if(avg != 0)
avg /= nodes.size();
System.out.println(\"Average code length is: \" + avg);
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
private static HuffmanNode createHuffmanTree(ArrayList nodes){
HuffmanNode root = null;
if(nodes.size() > 0) {
HuffmanNode node0, node1, node;
while (nodes.size() > 1) {
node0 = nodes.get(0);
node1 = nodes.get(1);
node = new HuffmanNode(null, node0.getP() + node1.getP());
node.setLeft(node0);
node.setRight(node1);
nodes.remove(0);
nodes.remove(0);
nodes.add(findInsertIndex(nodes, node.getP()), node);
}
root = nodes.get(0);
}
return root;
}
private static void setCodeWords(HuffmanNode root){
if(root != null){
setCodeWords(root, \"\");
}
}
private static void setCodeWords(HuffmanNode root, String codeWord){
if(root.getS() != null){
root.setC(codeWord);
root.setL(codeWord.length());
}
else{
setCodeWords(root.getLeft(), codeWord + \"0\");
setCodeWords(root.getRight(), codeWord + \"1\");
}
}
private static int findInsertIndex(ArrayList nodes, double prob){
for(int i = 0; i < nodes.size(); ++i){
if(prob < nodes.get(i).getP()){
return i;
}
}
return nodes.size();
}
}
// HuffmanNode.java
public class HuffmanNode {
private String S;
private double P;
private String C;
private int L;
private HuffmanNode left, right;
public HuffmanNode(String s, double p) {
S = s;
P = p;
}
public String getS() {
return S;
}
public void setS(String s) {
S = s;
}
public double getP() {
return P;
}
public void setP(double p) {
P = p;
}
public String getC() {
return C;
}
public void setC(String c) {
C = c;
}
public int getL() {
return L;
}
public void setL(int l) {
L = l;
}
public HuffmanNode getLeft() {
return left;
}
public void setLeft(HuffmanNode left) {
this.left = left;
}
public HuffmanNode getRight() {
return right;
}
public void se.
Please help write BinaryTree-java Thank you! Create a class BinaryTr.pdf
Please help write BinaryTree.java Thank you!
Create a class BinaryTree. A class that implements the ADT binary tree.
import java.util.Iterator;
import java.util.NoSuchElementException;
import StackAndQueuePackage.*;
public class BinaryTree <T> implements BinaryTreeInterface<T>
{
private BinaryNode<T> root;
public BinaryTree()
{
root = null;
} // end default constructor
public BinaryTree(T rootData)
{
root = new BinaryNode<>(rootData);
} // end constructor
public BinaryTree(T rootData, BinaryTree<T> leftTree,
BinaryTree<T> rightTree)
{
privateSetTree(rootData, leftTree, rightTree);
} // end constructor
public void setTree(T rootData)
{
root = new BinaryNode<>(rootData);
} // end setTree
public void setTree(T rootData, BinaryTreeInterface<T> leftTree,
BinaryTreeInterface<T> rightTree)
{
privateSetTree(rootData, (BinaryTree<T>)leftTree,
(BinaryTree<T>)rightTree);
} // end setTree
private void privateSetTree(T rootData, BinaryTree<T> leftTree,
BinaryTree<T> rightTree)
{
root = new BinaryNode<>(rootData);
if ((leftTree != null) && !leftTree.isEmpty())
root.setLeftChild(leftTree.root);
if ((rightTree != null) && !rightTree.isEmpty())
{
if (rightTree != leftTree)
root.setRightChild(rightTree.root);
else
root.setRightChild(rightTree.root.copy());
} // end if
if ((leftTree != null) && (leftTree != this))
leftTree.clear();
if ((rightTree != null) && (rightTree != this))
rightTree.clear();
} // end privateSetTree
//...
private class PreorderIterator implements Iterator<T>
{
private StackInterface<BinaryNode<T>> nodeStack;
public PreorderIterator()
{
nodeStack = new LinkedStack<>();
if (root != null)
nodeStack.push(root);
} // end default constructor
public boolean hasNext()
{
return !nodeStack.isEmpty();
} // end hasNext
public T next()
{
BinaryNode<T> nextNode;
if (hasNext())
{
nextNode = nodeStack.pop();
BinaryNode<T> leftChild = nextNode.getLeftChild();
BinaryNode<T> rightChild = nextNode.getRightChild();
// Push into stack in reverse order of recursive calls
if (rightChild != null)
nodeStack.push(rightChild);
if (leftChild != null)
nodeStack.push(leftChild);
}
else
{
throw new NoSuchElementException();
}
return nextNode.getData();
} // end next
public void remove()
{
throw new UnsupportedOperationException();
} // end remove
} // end PreorderIterator
public void iterativePreorderTraverse ()
{
StackInterface<BinaryNode<T>> nodeStack = new LinkedStack<>();
if (root != null)
nodeStack.push(root);
BinaryNode<T> nextNode;
while (!nodeStack.isEmpty())
{
nextNode = nodeStack.pop();
BinaryNode<T> leftChild = nextNode.getLeftChild();
BinaryNode<T> rightChild = nextNode.getRightChild();
// Push into stack in reverse order of recursive calls
if (rightChild != null)
nodeStack.push(rightChild);
if (leftChild != null)
nodeStack.push(leftChild);
System.out.print(nextNode.getData() + " ");
} // end while
} // end iterativePreorderTraverse
private class InorderIterator implements Iterator<T>
{
private StackInterface<BinaryNode<T>> nodeStack;
private BinaryNode<T> cu.
You can list anything, it doesnt matter. I just want to see code f.pdf
You can list anything, it doesn\'t matter. I just want to see code for this problem. Thank you
Solution
Include header files .......
Source code:
public class SinglyLinkedListImpl {
private Node head;
private Node tail;
public void add(T element){
Node nd = new Node();
nd.setValue(element);
System.out.println(\"Adding: \"+element);
if(head == null){
head = nd;
tail = nd;
} else {
tail.setNextRef(nd);
}
tail = nd;
}
}
public void addAfter(T element, T after){
Node tmp = head;
Node refNode = null;
System.out.println(\"Traversing to all nodes..\");
while(true){
if(tmp == null){
break;
}
if(tmp.compareTo(after) == 0){
refNode = tmp;
break;
}
tmp = tmp.getNextRef();
}
if(refNode != null){
Node nd = new Node();
nd.setValue(element);
nd.setNextRef(tmp.getNextRef());
if(tmp == tail){
tail = nd;
}
tmp.setNextRef(nd);
} else {
System.out.println(\"Unable to find the given element...\");
}
}
public void deleteFront(){
if(head == null){
System.out.println(\"Underflow...\");
}
Node tmp = head;
head = tmp.getNextRef();
if(head == null){
tail = null;
}
System.out.println(\"Deleted: \"+tmp.getValue());
}
public void deleteAfter(T after){
Node tmp = head;
Node refNode = null;
System.out.println(\"Traversing to all nodes..\");
while(true){
if(tmp == null){
break;
}
if(tmp.compareTo(after) == 0){
refNode = tmp;
break;
}
tmp = tmp.getNextRef();
}
if(refNode != null){
tmp = refNode.getNextRef();
refNode.setNextRef(tmp.getNextRef());
if(refNode.getNextRef() == null){
tail = refNode;
}
System.out.println(\"Deleted: \"+tmp.getValue());
} else {
System.out.println(\"Unable to find the given element...\");
}
}
public void traverse(){
Node tmp = head;
while(true){
if(tmp == null){
break;
}
System.out.println(tmp.getValue());
tmp = tmp.getNextRef();
}
}
public static void main(String a[]){
SinglyLinkedListImpl sl = new SinglyLinkedListImpl();
sl.add(3);
sl.add(32);
sl.add(54);
sl.add(89);
sl.addAfter(76, 54);
sl.deleteFront();
sl.deleteAfter(76);
sl.traverse();
}
}
class Node implements Comparable {
private T value;
private Node nextRef;
public T getValue() {
return value;
}
public void setValue(T value) {
this.value = value;
}
public Node getNextRef() {
return nextRef;
}
public void setNextRef(Node ref) {
this.nextRef = ref;
}
public int compareTo(T arg) {
if(arg == this.value){
return 0;
} else {
return 1;
}
}
}
This program implement the concept of single linked list..
Write a program that displays an AVL tree along with its balance fac.docx
This document provides code for an AVL tree implementation that:
1. Inserts nodes into the tree and rebalances it using rotations to maintain the AVL property.
2. Includes methods for searching, counting nodes, checking if the tree is empty, clearing the tree, and traversing the tree in different orders.
3. Contains a test program that uses the AVL tree to insert random numbers, perform operations on the tree, and display the results.
Here is the following code mentioned in the instructions.pdf
Here is the following code mentioned in the instructions:
class AVL {
Node root;
private class Node {
int data;
Node left, right;
int height;
private Node(int D, Node L, Node R, int H) {
data=D;
left=L;
right=R;
height=H; // user has to set height
} // of constructor Node
} //of Node
static private void UpdateHeight(Node T) {
if (T ==null) return;
else T.height = Math.max(HEIGHT(T.left),HEIGHT(T.right)) + 1;
} // UPdate Height
static private int HEIGHT(Node T) {
if (T== null ) return(-1);
else return (T.height);
}
// we need to more our right child up
static private Node LeftRotate(Node T) {
System.out.println(\"left rotate with data \" + T.data);
Node Tr;
Tr=T.right; // right child
T.right=Tr.left; // our right child IS NOW hhh
Tr.left=T; // move T down to the left
UpdateHeight(Tr.left); // update the height of T
UpdateHeight(Tr); // update hte height of the new root
return Tr;
} // of LeftRotate
// we move our immediate left node up.
// in doing so, we are now immediat right of our left child
static private Node RightRotate(Node T) {
Node Tl;
System.out.println(\"left rotate with data \" + T.data);
Tl=T.left; // left child
T.left=Tl.right; // our left child is now what our left was pointing to
Tl.right=T; // move T down to the right
UpdateHeight(Tl.right); // update the height of T
UpdateHeight(Tl); // update hte height of the new root
return Tl;
} // of RightRotate
public AVL() {
root=null;
} // of constructor AVL
// method to allow external entity to insert an element into the tree
public void insert(int D)
{
root=insert_internal(D, root);
} // of insert
private Node insert_internal(int D, Node T) {
if (T==null) return( new Node (D, null, null, 0));
if (T.data == D) return T; // the data is already in there
if ( D < T. data ) // go left
{ if (T.left == null)
{
T.left = insert_internal(D,null);
UpdateHeight(T);
}
else { //interior node
T.left = insert_internal(D, T.left);
}
} // of go left
else // D goes to the right
{ if (T.right == null)
{
T.right = insert_internal(D,null);
UpdateHeight(T);
}
else { //interior node
T.right = insert_internal(D, T.right);
}
} // of go right
// now we have to figure out if things are out of
// balance
int diff= HEIGHT(T.right) - HEIGHT(T.left);
System.out.println(\"difference is \" + diff + \" data is \" + T.data);
if ( Math.abs(diff) <= 1) // we are good to go at this level
{
UpdateHeight(T);
return(T);
}
// only if diff is bigger than 1
if ( diff > 1)// right leaning
{ // look at right child and figure out how it is leaning
} // of right leaning
else // left leaning
{ // look at left child to see how it is leaning
Node child = T.left;
int cdiff;
cdiff = HEIGHT(child.right) - HEIGHT(child.left);
System.out.println(\"cdiff is \" + cdiff);
if ( cdiff < 0 ) // left left lean
{ T=RightRotate(T); }
else
{
System.out.println(\"SHAUN\");
preorder_internal(T);
T.left = LeftRotate(T.left);
System.out.println(\"SHAUN\");
preorder_internal(T);
T=RightRotate(T);
}
} // of left leaning
// at this point we have rotated,.
Implement a function TNode copy_tree(TNode t) that creates a copy .pdf
Implement a function TNode* copy_tree(TNode* t) that creates a copy of the tree t and returns a
pointer to the root of the copy. Test this function by writing a main( that creates a tree and uses
the function to create a copy. Print both trees to verify they are the same.
Solution
// BSTree.h #ifndef BSTREE_H #define BSTREE_H #include using namespace std;
template struct TNode { TNode(const T &); T data; TNode* left, * right;
}; template TNode::TNode(const T & newItem) { data = newItem; left = right = NULL;
} template class BSTree { public: enum {T_OK = 0, T_DUPLICATE = -1,
T_NOT_FOUND = -2}; BSTree(); BSTree(const BSTree&); ~BSTree();
void clear(); int insert(const T&); int remove(const T&); int height() const; int
size() const; void printPreorder() const; void printInorder() const; void
printPostorder() const; const BSTree& operator=(const BSTree&); private:
TNode * root; void destroyTree(TNode*); int size(TNode*) const; int
height(TNode*) const; TNode* copyTree(TNode*); void preTrav(TNode*) const;
void inTrav(TNode*) const; void postTrav(TNode*) const; }; template
BSTree::BSTree() { root = NULL; } template BSTree::BSTree(const BSTree&
treeToCopy) { root = copyTree(treeToCopy.root); } template BSTree::~BSTree()
{ destroyTree(root); } template void BSTree::destroyTree(TNode* current) { if
(current != NULL) { destroyTree(current->left); destroyTree(current->right);
delete current; } } template void BSTree::clear() { destroyTree(root); root =
NULL; } template int BSTree::insert(const T& newItem) { TNode* current = root,
* parent = NULL; while (current != NULL && newItem != current->data) { parent
= current; if (newItem < current->data) current = current->left; else // if (newItem >
current->data) current = current->right; } if (current != NULL) return
T_DUPLICATE; else { TNode* newNode = new TNode(newItem); if (parent ==
NULL) root = newNode; else if (newNode->data < parent->data) parent-
>left = newNode; else parent->right = newNode; return T_OK; }
} template int BSTree::remove(const T& deleteItem) { TNode* delNode = root, *
delParent = NULL, * replNode, * replParent; while (delNode != NULL && deleteItem
!= delNode->data) { delParent = delNode; if (deleteItem < delNode->data)
delNode = delNode->left; else // if (newItem > current->data) delNode = delNode-
>right; } if (delNode != NULL) { if (delNode->left == NULL) replNode =
delNode->right; else if (!delNode->right) replNode = delNode->left; else {
replParent = delNode; replNode = delNode-> right; while (replNode->left !=
NULL) { replParent = replNode; replNode = replNode->left; }
if (replParent != delNode) { replParent->left = replNode->right;
replNode->right = delNode->right; } replNode->left = delNode->left; }
if (delParent == NULL) root = replNode; else { if (delParent->left ==
delNode) delParent->left = replNode; else delParent->right = replNode;
} delete delNode; return T_OK; } else return T_NOT_FOUND; }
template int BSTree::size() const { return size(root); } template int BSTree::size(.
While a majority of the worlds current electricity supply is gener.pdf
While a majority of the world\'s current electricity supply is generated from fossil fuels such as
coal, oil and natural gas, these traditional energy sources face a number of challenges including
rising prices, security concerns over dependence on imports from a limited number of countries
which have significant fossil fuel supplies, and growing environmental concerns over the climate
change risks associated with power generation using fossil fuels. As a result of these and other
challenges facing traditional energy sources, governments, businesses and consumers are
increasingly supporting the development of alternative energy sources and new technologies for
electricity generation. Renewable energy sources such as solar, biomass, geothermal,
hydroelectric and windpower generation have emerged as potential alternatives which address
some of these concerns. As opposed to fossil fuels, which draw on finite resources that may
eventually become too expensive to retrieve, renewable energy sources are generally unlimited
in availability.
Solar power generation has emerged as one of the most rapidly growing renewable sources of
electricity. Solar power generation has several advantages over other forms of electricity
generation:
Reduced Dependence on Fossil Fuels. Solar energy production does not require fossil fuels and
is therefore less dependent on this limited and expensive natural resource. Although there is
variability in the amount and timing of sunlight over the day, season and year, a properly sized
and configured system can be designed to be highly reliable while providing long-term, fixed
price electricity supply.
Environmental Advantages. Solar power production generates electricity with a limited impact
on the environment as compared to other forms of electricity production.
Matching Peak Time Output with Peak Time Demand. Solar energy can effectively supplement
electricity supply from an electricity transmission grid, such as when electricity demand peaks in
the summer
Modularity and Scalability. As the size and generating capacity of a solar system are a function
of the number of solar modules installed, applications of solar technology are readily scalable
and versatile.
Flexible Locations. Solar power production facilities can be installed at the customer site
which reduces required investments in production and transportation infrastructure.
Government Incentives. A growing number of countries have established incentive programs
for the development of solar and other renewable energy sources, such as (i) net metering laws
that allow on-grid end users to sell electricity back to the grid at retail prices, (ii) direct subsidies
to end users to offset costs of photovoltaic equipment and installation charges, (iii) low interest
loans for financing solar power systems and tax incentives; and (iv) government standards that
mandate minimum usage levels of renewable energy sources.
Despite the cost, an advantage of photovoltaic systems is.
What is broadbandWhat is the potential for broadband wireless syste.pdf
What is broadband?What is the potential for broadband wireless systems?Do you think it will
ever really catch on here in the US?
sol:
Broadband is a transmission technique with high capcaticy using wide range of frequency for
data transmission
and communication.it has an capability of sending multiple singnals through different medium
like optical fiber,coaxial fiber.
potential for broadband wireless systems:
1)wireless broadband network has potencial of data rates which is equal to wired networks
2)it supports both symmetric (it means same data rates in both the direction)and asymmetric
3)it has also capable of sending high data rates and communicate with satellite systems
4)it has a wide range of signal strength upto 50 km
Do you think it will ever really catch on here in the US?:
no it will catch on here in the us also because as the techology increases the needs also increases
so broadband will play a major role in day today life.according to us analysis the wireless
broadband subscription is 46.9% of population in 2009 and it has increased to 89.8% of the
population in 2012 and coming to the broadband usage it was 2.5% in 2000 and as in 2012 it was
28.0% in the world.
so the above analysis is one of the proof for developing of wireless Broadband in us
Solution
What is broadband?What is the potential for broadband wireless systems?Do you think it will
ever really catch on here in the US?
sol:
Broadband is a transmission technique with high capcaticy using wide range of frequency for
data transmission
and communication.it has an capability of sending multiple singnals through different medium
like optical fiber,coaxial fiber.
potential for broadband wireless systems:
1)wireless broadband network has potencial of data rates which is equal to wired networks
2)it supports both symmetric (it means same data rates in both the direction)and asymmetric
3)it has also capable of sending high data rates and communicate with satellite systems
4)it has a wide range of signal strength upto 50 km
Do you think it will ever really catch on here in the US?:
no it will catch on here in the us also because as the techology increases the needs also increases
so broadband will play a major role in day today life.according to us analysis the wireless
broadband subscription is 46.9% of population in 2009 and it has increased to 89.8% of the
population in 2012 and coming to the broadband usage it was 2.5% in 2000 and as in 2012 it was
28.0% in the world.
so the above analysis is one of the proof for developing of wireless Broadband in us.
More Related Content
Similar to package DataStructures; public class HelloWorld AnyType extends.pdf
Binary Tree
The document provides C code examples for various binary tree operations and traversals including: finding the height/depth and size of a tree, deleting a tree by freeing its nodes, determining if two trees are identical, finding the minimum value in a BST, creating a mirror copy of a tree, computing the maximum depth, returning a pointer to the nth node of an inorder traversal, level order traversal, deleting a node from a BST, searching a BST, counting leaves, and iterative preorder, inorder and postorder traversals. For each operation, the code is presented and discussed.
Given the following codepackage data1;import java.util.;p.pdf
Given the following code
package data1;
import java.util.*;
/*public class BST> implementing a set ADT and containing the following:
* private inner class BinaryNode representing a node with a (possibly) left child and a (possibly)
right child
** instance fields BinaryNode root, int size
* contains/insert/remove method - w/ O(height) complexity
** size O(1), isEmpty O(1), clear O(1),
*** findMin, findMax, findHeight methods - w/ O(height) complexity
**** toString() method printing set (in-order traversal) and the tree (BFS traversal)
**
*/
publicclass BST> {
private BinaryNode root;
privateint size;
//Search opertion of Set ADT
publicboolean contains(E value) {
return contains(root, value);
}
//Insert opertion of Set ADT
publicvoid insert(E value) {
root = insert(root, value);
size++;
}
//Remove operation of Set ADT
publicvoid remove(E value){
root = remove(root, value);
size--;
}
publicint size(){
return size;
}
publicboolean isEmpty(){
return root == null;
}
publicvoid clear(){
root = null;
size = 0;
}
public E findMin(){
return findMin(root);
}
public E findMax(){
return findMax(root);
}
publicint findHeight(){
return root.height();
}
public String toString(){
if(root == null)
return "set {} stored in an empty tree.\n";
String elements = root.inOrder().toString();
return "set {" + elements.substring(1,elements.length()-1) + "} stored in tree \n" + root;
}
private E findMin(BinaryNode node){
if(node == null)
returnnull;
if(node.left == null)
return node.element;
return findMin(node.left);
}
private E findMax(BinaryNode node){
if(node == null)
returnnull;
if(node.right == null)
return node.element;
return findMax(node.right);
}
privateboolean contains(BinaryNode node, E value) {
if (node == null)//node represents an empty substree
returnfalse;
int comparisonResult = value.compareTo(node.element);
if(comparisonResult < 0)//if value is less than root's value
return contains(node.left, value);
if(comparisonResult > 0)//if value is greater than root's value
return contains(node.right, value);
returntrue;//successful search
}
private BinaryNode insert(BinaryNode node, E value) {
if (node == null)//base case: empty tree
returnnew BinaryNode<>(value);
if (value.compareTo(node.element) < 0)
node.left = insert(node.left, value);//insert recursively to left-subtree
elseif (value.compareTo(node.element) > 0)
node.right = insert(node.right, value);//insert recursively to right-subtree
else {//duplicate value cannot be inserted in a BST implementing the Set ADT
size--;//insertion failed!
//System.out.print("BST.insert: Warning: " + value + " is already stored in the tree \n" + node);
}
return node;
}
private BinaryNode remove(BinaryNode node, E value) {
if (node == null) {//base case: empty tree
System.out.println("BST.remove: Warning: " + value + " doesn't exist in the tree.");
size++;//removal failed!
return node;
}
if (value.compareTo(node.element) < 0)
node.left = remove(node.left, value);
elseif (value.compareTo(node.element) > 0)
node.right = remov.
I have a .java program that I need to modify so that it1) reads i.pdf
I have a .java program that I need to modify so that it:
1) reads in a file called books.txt (i will provide a few lines of the text file below)
2) outputs a statement every time there's a collision (see the example output below in the original
prompt)
THIS IS THE ORIGINAL PROMPT:
Part A: Modify the attached code to build and customize a AVL tree of Book nodes. Using an
input file, insert Book nodes and detect imbalance. If imbalance is true, then call the proper
rotation function as discussed in the lecture to fix the imbalance condition.
Must read AVLNode data from a text file
Create a Book Object; and an AVL node object to be inserted into the AVL tree
At each insert, detect imbalance and fix the AVL tree
Report each imbalance detection and the node where it occurred; and output the message:
Example Output:
Imbalance condition occurred at inserting ISBN 12345; fixed in LeftRight Rotation
Imbalance condition occurred at inserting ISBN 87654; fixed in Left Rotation
Imbalance condition occurred at inserting ISBN 974321; fixed in RightLeft Rotation
class AVLNode {
Book bookObject;
int height;
AVLNode leftPtr;
AVLNode rightPtr;
}
BELOW IS THE CODE I NEED TO MODIFY:
// AVL Binary search tree implementation in Java
// Author: AlgorithmTutor
// data structure that represents a node in the tree
class Node {
int data; // holds the key
Node parent; // pointer to the parent
Node left; // pointer to left child
Node right; // pointer to right child
int bf; // balance factor of the node
public Node(int data) {
this.data = data;
this.parent = null;
this.left = null;
this.right = null;
this.bf = 0;
}
}
public class AVLTree {
private Node root;
public AVLTree() {
root = null;
}
private void printHelper(Node currPtr, String indent, boolean last) {
// print the tree structure on the screen
if (currPtr != null) {
System.out.print(indent);
if (last) {
System.out.print("R----");
indent += " ";
} else {
System.out.print("L----");
indent += "| ";
}
System.out.println(currPtr.data + "(BF = " + currPtr.bf + ")");
printHelper(currPtr.left, indent, false);
printHelper(currPtr.right, indent, true);
}
}
private Node searchTreeHelper(Node node, int key) {
if (node == null || key == node.data) {
return node;
}
if (key < node.data) {
return searchTreeHelper(node.left, key);
}
return searchTreeHelper(node.right, key);
}
private Node deleteNodeHelper(Node node, int key) {
// search the key
if (node == null) return node;
else if (key < node.data) node.left = deleteNodeHelper(node.left, key);
else if (key > node.data) node.right = deleteNodeHelper(node.right, key);
else {
// the key has been found, now delete it
// case 1: node is a leaf node
if (node.left == null && node.right == null) {
node = null;
}
// case 2: node has only one child
else if (node.left == null) {
Node temp = node;
node = node.right;
}
else if (node.right == null) {
Node temp = node;
node = node.left;
}
// case 3: has both children
else {
Node temp = minimum(node.right);
node.data = temp.data;
node.right = .
mainpublic class AssignmentThree { public static void ma.pdf
// main
public class AssignmentThree
{
public static void main(String[] args)
{
List myList = new List(15);
// Cause List Empty Message
myList.removeFront();
myList.removeRear();
myList.removeItem(\"a\");
// Cause Not found message
myList.addToFront(\"x\");
myList.removeItem(\"y\");
myList.removeItem(\"x\");
myList.addAfterItem(\"x\", \"z\");
myList.addBeforeItem(\"x\", \"z\");
// Normal behavior
myList.addToFront(\"not.\");
myList.addToFront(\"or\");
myList.addToRear(\"is\");
myList.addToRear(\"try.\");
myList.addAfterItem(\"is\", \"no\");
myList.addBeforeItem(\"is\", \"There\");
myList.addToFront(\"Do\");
myList.addAfterItem(\"or\", \"do\");
myList.print(\"Original list\");
myList.printSorted(\"Sorted Original List\");
sop(\"\ Front is \" + myList.getFront());
sop(\"Rear is \" + myList.getRear());
sop(\"Count is \" + myList.askCount());
sop(\"Is There present? \" + myList.isPresent(\"There\"));
sop(\"Is Dog present? \" + myList.isPresent(\"Dog\"));
myList.addToFront(\"junk\");
myList.addToRear(\"morejunk\");
myList.addAfterItem(\"or\", \"moremorejunk\");
myList.print(\"List with junk\");
sop(\"Count is \" + myList.askCount());
myList.removeFront();
myList.removeRear();
myList.removeItem(\"moremorejunk\");
myList.print(\"List with junk removed\");
sop(\"Count is \" + myList.askCount());
sop(\"\");
// Cause List Full message
for(int ii = 0; ii < 10; ++ii)
{
myList.addToFront(DUMMY);
}
myList.addToRear(DUMMY);
myList.addBeforeItem(\"no\", DUMMY);
myList.addAfterItem(\"There\", DUMMY);
myList.print(\"After filling List\");
sop(\"Count is \" + myList.askCount());
while(myList.isPresent(DUMMY)) myList.removeItem(DUMMY);
myList.print(\"After removing \" + DUMMY );
sop(\"Count is \" + myList.askCount());
}
private static void sop(String s)
{
System.out.println(s);
}
private static final String DUMMY = \"dummy\";
}
Solution
Following is MyList implementation for your output as:
Java Code:
import java.util.Comparator;
public class MyList {
private Node start;
private Node end;
private int size;
private int capacity;
public MyList(int capacity) {
start = null;
end = null;
size = 0;
this.capacity = capacity;
}
/* Function to check if list is empty */
public boolean isEmpty() {
return start == null;
}
public void removeFront() {
if (isEmpty()) {
System.out.println(\"List Empty\");
return;
} else {
start = start.next;
size--;
return;
}
}
public void removeRear() {
if (size == 0) {
System.out.println(\"List Empty\");
return;
}
if (start.next == null) {
start=null;
end=null;
size=0;
}
Node node = start.next;
while (node.next != null) {
node = node.next;
}
node.next = null;
end = node;
size--;
}
public void removeItem(String key) {
if (size == 0) {
System.out.println(\"List Empty\");
return;
}
if (start.next == null) {
if (start.key.equals(key)) {
start=null;
end=null;
size=0;
} else {
System.out.println(\"\");
}
return;
}
Node node = start;
Node nodeNext = node.next;
while (nodeNext.next != null) {
if (nodeNext.key.equals(key)) {
node.next=nodeNext.next;
}.
Once you have all the structures working as intended- it is time to co.docx
Once you have all the structures working as intended, it is time to compare the
performances of the 2. Use runBenchmark() to start.
a. First, generate an increasing number (N) of random integers (1000, 5000, 10000,
50000, 75000, 100000, 500000 or as far as your computing power will let you)
i. Time and print how long it takes to insert the random integers into an initially
empty BST. Do not print the tree.
You can get a random list using the java class Random, located in
java.util.Random. To test the speed of the insertion algorithm, you should use
the System.currentTimeMillis() method, which returns a long that contains the
current time (in milliseconds). Call System.currentTimeMillis() before and after
the algorithm runs and subtract the two times. (Instant.now() is an alternative
way of recording the time.)
ii. Time and print how long it takes to insert the same random integers into an
initially empty AVL tree. Do not print the tree.
iii. If T(N) is the time function, how does the growth of TBST(N) compare with the
growth of TAVL(N)?
Plot a simple graph to of time against N for the two types of BSTs to visualize
your results.
b. Second, generate a list of k random integers. k is also some large value.
i. Time how long it takes to search your various N-node BSTs for all k random
integers. It does not matter whether the search succeeds.
ii. Time how long it takes to search your N-node AVL trees for the same k random
integers.
iii. Compare the growth rates of these two search time-functions with a graph the
same way you did in part a.
public class BinarySearchTree<AnyType extends Comparable<? super AnyType>> {
protected BinaryNode<AnyType> root;
public BinarySearchTree() {
root = null;
}
/**
* Insert into the tree; duplicates are ignored.
*
* @param x the item to insert.
* @param root
* @return
*/
protected BinaryNode<AnyType> insert(AnyType x, BinaryNode<AnyType> root) {
// If the root is null, we've reached an empty leaf node, so we create a new node
// with the value x and return it
if (root == null) {
return new BinaryNode<>(x, null, null);
}
// Compare the value of x to the value stored in the root node
int compareResult = x.compareTo(root.element);
// If x is less than the value stored in the root node, we insert it into the left subtree
if (compareResult < 0) {
root.left = insert(x, root.left);
}
// If x is greater than the value stored in the root node, we insert it into the right subtree
else if (compareResult > 0) {
root.right = insert(x, root.right);
}
// If x is equal to the value stored in the root node, we ignore it since the tree does not allow duplicates
return root;
}
/**
* Counts the number of leaf nodes in this tree.
*
* @param t The root of the tree.
* @return
*/
private int countLeafNodes(BinaryNode<AnyType> root) {
// If the root is null, it means the tree is empty, so we return 0
if (root == null) {
return 0;
}
// If the root has no children, it means it is a leaf node, so we return 1
if (root.left == .
( PLEASE SHOW HOW TO IMPLEMENT THE DELETION FUNCTION )SAMPLE OUTPU.pdf
( PLEASE SHOW HOW TO IMPLEMENT THE DELETION FUNCTION )
SAMPLE OUTPUT: Instead of using a linked list to resolve collisions, as in separate chaining,
use a binary search tree. That is, create a hash table that is an array of trees. You could use H(X)
= X % arraysize as the hash function in your hash table implementation. The arraySize needs to
be an input parameter from users. Your solution should support the basic hash table inserting,
searching, and displaying functions. To display a small tree-based hash table, you could use an
in-order traversal of each tree. The advantage of a tree over a linked list is that it can be searched
in O(logN) instead of O(N) time. Checking 15 items takes a maximum of 15 comparisons in a
list but only 4 in a tree. Duplicates can present problems in both trees and hash tables, so add
some code that prevents a duplicate key from being inserted in the hash table. To shorten the
listing for this program, you can forget about deletion, which for trees requires a lot of code. [ten
bonus points will be given to those who implement the deletion function.]
Solution
import java.util.Scanner;
class BinaryNode
{
BinaryNode lchild, rchild;
int data;
public BinaryNode(int d)
{
data = d;
lchild = null;
rchild = null;
}
}
class HashTableusingBinaryTree
{
private BinaryNode[] t;
private int size ;
public HashTableusingBinaryTree(int tableSize)
{
t = new BinaryNode[ nextPosition(tableSize) ];
size = 0;
}
public boolean isEmpty()
{
return size == 0;
}
public void Empty()
{
int l = t.length;
t = new BinaryNode[l];
size = 0;
}
public int sizeofht()
{
return size;
}
public void insert(int val)
{
size++;
int pos = myhashtable(val);
BinaryNode head = t[pos];
head = insert(head, val);
t[pos] = head;
}
private BinaryNode insert(BinaryNode node, int data)
{
if (node == null)
node = new BinaryNode(data);
else
{
if (data <= node.data)
node.lchild = insert(node.lchild, data);
else
node.rchild = insert(node.rchild, data);
}
return node;
}
public void remove(int val)
{
int pos = myhashtable(val);
BinaryNode head = t[pos];
try
{
head = delete(head, val);
size--;
}
catch (Exception e)
{
System.out.println(\"\ Element not present\ \");
}
t[pos] = head;
}
private BinaryNode delete(BinaryNode head, int k)
{
BinaryNode a, b, n;
if (head.data == k)
{
BinaryNode lt, rt;
lt = head.lchild;
rt = head.rchild;
if (lt == null && rt == null)
return null;
else if (lt == null)
{
a = rt;
return a;
}
else if (rt == null)
{
a = lt;
return a;
}
else
{
b = rt;
a = rt;
while (a.lchild != null)
a = a.lchild;
a.lchild = lt;
return b;
}
}
if (k < head.data)
{
n = delete(head.lchild, k);
head.lchild = n;
}
else
{
n = delete(head.rchild, k);
head.rchild = n;
}
return head;
}
private int myhashtable(Integer x )
{
int hashVal = x.hashCode( );
hashVal %= t.length;
if (hashVal < 0)
hashVal += t.length;
return hashVal;
}
private static int nextPosition( int r )
{
if (r % 2 == 0)
r++;
for ( ; !isnext( r ); r += 2);
return r;
}
private static boolean isnext( int r )
{
if (r ==.
1. Add a breadth-first (level-order) traversal function to the binar.pdf
1. Add a breadth-first (level-order) traversal function to the binary tree code.
2. Add a function to find the height of a tree.
3. Re-implement one of the depth-first traversal methods using a stack instead of recursion.
4. Add a link to each nodes parent node.
#include
#include
#include
using namespace std;
template < typename T >
class TreeNode
{
public:
T element; //
TreeNode < T > * left; //
TreeNode < T > * right; //
TreeNode * next;
TreeNode() //
{
left = NULL;
next = NULL;
}
TreeNode(T element) // Constructor
{
this->element = element;
left = NULL;
right = NULL;
}
};
template < typename T >
class BinaryTree
{
public:
BinaryTree();
BinaryTree(T elements[], int arraySize);
bool insert(T element);
void inorder();
void preorder();
void postorder();
int getSize();
bool search(T element);
void breadthFirstTraversal();
int depth();
private:
TreeNode < T > * root;
int size;
void inorder(TreeNode < T > * root);
void postorder(TreeNode < T > * root);
void preorder(TreeNode < T > * root);
bool search(T element, TreeNode < T > * root);
int depth(TreeNode * root);
};
template < typename T >
BinaryTree < T >::BinaryTree()
{
root = NULL;
size = 0;
}
template < typename T >
BinaryTree < T >::BinaryTree(T elements[], int arraySize)
{
root = NULL;
size = 0;
for (int i = 0; i < arraySize; i++)
{
insert(elements[i]);
}
}
template < typename T >
bool BinaryTree < T >::insert(T element)
{
if (root == NULL)
root = new TreeNode < T > (element); // Create a new root
else
{
// Locate the parent node
TreeNode < T > * parent = NULL;
TreeNode < T > * current = root;
while (current != NULL)
if (element < current->element)
{
parent = current;
current = current->left;
}
else if (element > current->element)
{
parent = current;
current = current->right;
}
else
return false; // Duplicate node not inserted
// Create the new node and attach it to the parent node
if (element < parent->element)
parent->left = new TreeNode < T > (element);
else
parent->right = new TreeNode < T > (element);
}
size++;
return true; // Element inserted
}
/* Inorder traversal */
template < typename T >
void BinaryTree < T >::inorder()
{
inorder(root);
}
/* Inorder traversal from a subtree */
template < typename T >
void BinaryTree < T >::inorder(TreeNode < T > * root)
{
if (root == NULL) return;
inorder(root->left);
cout << root->element << \" \";
inorder(root->right);
}
/* Postorder traversal */
template < typename T >
void BinaryTree < T >::postorder()
{
postorder(root);
}
/** Inorder traversal from a subtree */
template < typename T >
void BinaryTree < T >::postorder(TreeNode < T > * root)
{
if (root == NULL) return;
postorder(root->left);
postorder(root->right);
cout << root->element << \" \";
}
/* */
template < typename T >
void BinaryTree < T >::preorder()
{
preorder(root);
}
/* */
template < typename T >
void BinaryTree < T >::preorder(TreeNode < T > * root)
{
if (root == NULL) return;
cout << root->element << \" \";
preorder(root->left);
preorder(root->right);
}
/**/
template < typename .
I need help finishing this code in JavaYou will need to create t.pdf
I need help finishing this code in Java
You will need to create the preOrder and postOrder traversal methods, as these will be used to
determine if your insertion methods are correct.
protected class Node {
public int data;
public Node left, right, parent;
public Node(int _data) {
data = _data;
left = right = parent = null;
}
public Node(int _data, Node _parent) {
data = _data;
left = right = null;
parent = _parent;
}
}
protected Node root;
public BST() {
root = null;
}
public void insert(int data) {
if (root == null) {
root = new Node(data);
} else {
insert(data, root);
}
}
protected void insert(int data, Node n) {
// TODO: Insert Method
}
public ArrayList inOrderTraversal() {
return inOrderTraversal(root);
}
private ArrayList inOrderTraversal(Node n) {
if (n == null) {
return new ArrayList<>();
}
ArrayList traversal = new ArrayList<>();
traversal.addAll(inOrderTraversal(n.left));
traversal.add(n.data);
traversal.addAll(inOrderTraversal(n.right));
return traversal;
}
public ArrayList preOrderTraversal() {
return preOrderTraversal(root);
}
private ArrayList preOrderTraversal(Node n) {
// TODO: preOrderTraveral Method
return new ArrayList();
}
public ArrayList postOrderTraversal() {
return postOrderTraversal(root);
}
private ArrayList postOrderTraversal(Node n) {
// TODO: postOrderTraversal Method
return new ArrayList();
}
protected static int height(Node n) {
if (n == null) {
return -1;
}
int lheight = height(n.left);
int rheight = height(n.right);
if (lheight > rheight) {
return 1 + lheight;
}
return 1 + rheight;
}
public int height() {
return height(root);
}
} BST Insertion protected void insert(int data, Node n ) if data < n.data if n. left is null n.left =
new Node(data, n ) else insert(data, n.left) else if data > n.data if n.right is null n.right = new
Node(data, n) else insert(data, n.right)
BST Traversals You are responsible for implementing the and postOrderTraversal(Node n )
methods that generate the string representation of the tree using the specified traversal. The
inorderTraversal (Node n ) method has been implemented for you; use that to match the
formatting of the output strings (this is the most "output matching" you will have to do this
semester)..
Table.java Huffman code frequency tableimport java.io.;im.docx
The document defines classes for building a Huffman coding tree from character frequencies in a file. It includes classes for a frequency table, priority queue, tree nodes, and the Huffman algorithm. The Huffman class constructs the tree from a file, inserts codewords, and can encode and decode a string using the tree. It outputs entropy and average code length metrics.
ANSimport java.util.Scanner; class Bina_node { Bina_node .pdf
This document contains Java code that defines a binary tree class with methods for inserting nodes, searching for values, counting nodes, checking if the tree is empty, and traversing the tree in preorder, inorder and postorder manners. A main method is included that allows a user to test the binary tree operations by selecting options from a menu to insert nodes, search, count nodes or check emptiness and displays the results of tree traversals.
week-14x
This C program uses functions to perform operations on a doubly linked list including creation, insertion, deletion, and traversal. The main menu allows the user to choose these operations. Functions are defined to allocate memory for nodes, search for a node, print the list, append a new node, create the initial list, delete a node, and insert a new node into the middle of the list.
This is to test a balanced tree. I need help testing an unbalanced t.pdf
this is business analytics question. (using gurobi) The days-off scheduling problem must be
solved routinely by businesses that operate 6 or 7 days a week. Examples include hospitals,
airlines, municipal transportation companies, and the postal service. The most common example
is the (5,7)-cyclic staffing problem. The objective of it is to minimize the cost of assigning
workers to a 7-day cyclic schedule so that 1) Sufficient workers are available every day. 2) Each
person works 5 consecutive days and is idle to the remaining 2 days. Here is the table showing
the cost of having an employee for each day and the number of employees required for each day.
For example, the pattern that one works from Sunday to Thursday costs 90+604=330. Formulate
and solve an integer programming problem to represent this problem. How many employees
work Monday-Friday?.
Scala vs Java 8 in a Java 8 World
Scala is becoming the language of choice for many development teams. This talk highlights how Scala excels in the world of multi-core processing and explores how it compares to Java 8.
Video Presentation: http://youtu.be/8vxTowBXJSg
Here is the code given in the instructionsclass AVL {.pdf
Here is the code given in the instructions:
class AVL {
Node root;
private class Node {
int data;
Node left, right;
int height;
private Node(int D, Node L, Node R, int H) {
data=D;
left=L;
right=R;
height=H; // user has to set height
} // of constructor Node
} //of Node
static private void UpdateHeight(Node T) {
if (T ==null) return;
else T.height = Math.max(HEIGHT(T.left),HEIGHT(T.right)) + 1;
} // UPdate Height
static private int HEIGHT(Node T) {
if (T== null ) return(-1);
else return (T.height);
}
// we need to more our right child up
static private Node LeftRotate(Node T) {
System.out.println(\"left rotate with data \" + T.data);
Node Tr;
Tr=T.right; // right child
T.right=Tr.left; // our right child IS NOW hhh
Tr.left=T; // move T down to the left
UpdateHeight(Tr.left); // update the height of T
UpdateHeight(Tr); // update hte height of the new root
return Tr;
} // of LeftRotate
// we move our immediate left node up.
// in doing so, we are now immediat right of our left child
static private Node RightRotate(Node T) {
Node Tl;
System.out.println(\"left rotate with data \" + T.data);
Tl=T.left; // left child
T.left=Tl.right; // our left child is now what our left was pointing to
Tl.right=T; // move T down to the right
UpdateHeight(Tl.right); // update the height of T
UpdateHeight(Tl); // update hte height of the new root
return Tl;
} // of RightRotate
public AVL() {
root=null;
} // of constructor AVL
// method to allow external entity to insert an element into the tree
public void insert(int D)
{
root=insert_internal(D, root);
} // of insert
private Node insert_internal(int D, Node T) {
if (T==null) return( new Node (D, null, null, 0));
if (T.data == D) return T; // the data is already in there
if ( D < T. data ) // go left
{ if (T.left == null)
{
T.left = insert_internal(D,null);
UpdateHeight(T);
}
else { //interior node
T.left = insert_internal(D, T.left);
}
} // of go left
else // D goes to the right
{ if (T.right == null)
{
T.right = insert_internal(D,null);
UpdateHeight(T);
}
else { //interior node
T.right = insert_internal(D, T.right);
}
} // of go right
// now we have to figure out if things are out of
// balance
int diff= HEIGHT(T.right) - HEIGHT(T.left);
System.out.println(\"difference is \" + diff + \" data is \" + T.data);
if ( Math.abs(diff) <= 1) // we are good to go at this level
{
UpdateHeight(T);
return(T);
}
// only if diff is bigger than 1
if ( diff > 1)// right leaning
{ // look at right child and figure out how it is leaning
} // of right leaning
else // left leaning
{ // look at left child to see how it is leaning
Node child = T.left;
int cdiff;
cdiff = HEIGHT(child.right) - HEIGHT(child.left);
System.out.println(\"cdiff is \" + cdiff);
if ( cdiff < 0 ) // left left lean
{ T=RightRotate(T); }
else
{
System.out.println(\"SHAUN\");
preorder_internal(T);
T.left = LeftRotate(T.left);
System.out.println(\"SHAUN\");
preorder_internal(T);
T=RightRotate(T);
}
} // of left leaning
// at this point we have rotated, so we need to.
Modify HuffmanTree.java and HuffmanNode.java to allow the user to se.pdf
Modify HuffmanTree.java and HuffmanNode.java to allow the user to select the value of n 9 to
construct an n ary Huffman Tree. Once finished, verify the accuracy of your tree by running it
for the English Alphabet for n = 3, 4, 5, 6, 7, 8, 9. For each value of n, compute the average
codeword length. Write these in a table (n vs. ACW L(Cn)).
/ HuffmanTree.java
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.util.ArrayList;
import java.util.Scanner;
public class HuffmanTree {
public static void main(String[] args){
Scanner in = new Scanner(System.in);
System.out.print(\"Enter the file name: \");
String fileName = in.nextLine();
ArrayList nodes = new ArrayList<>();
ArrayList temp = new ArrayList<>();
try {
Scanner fin = new Scanner(new FileReader(fileName));
String symbol;
double prob;
while(fin.hasNext()){
symbol = fin.next();
prob = fin.nextDouble();
nodes.add(findInsertIndex(nodes, prob), new HuffmanNode(symbol, prob));
}
fin.close();
temp.addAll(nodes);
HuffmanNode root = createHuffmanTree(temp);
setCodeWords(root);
double avg = 0;
for (HuffmanNode node : nodes) {
System.out.println(node.getS() + \": \" + node.getC() + \": \" + node.getL());
avg += node.getL();
}
if(avg != 0)
avg /= nodes.size();
System.out.println(\"Average code length is: \" + avg);
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
private static HuffmanNode createHuffmanTree(ArrayList nodes){
HuffmanNode root = null;
if(nodes.size() > 0) {
HuffmanNode node0, node1, node;
while (nodes.size() > 1) {
node0 = nodes.get(0);
node1 = nodes.get(1);
node = new HuffmanNode(null, node0.getP() + node1.getP());
node.setLeft(node0);
node.setRight(node1);
nodes.remove(0);
nodes.remove(0);
nodes.add(findInsertIndex(nodes, node.getP()), node);
}
root = nodes.get(0);
}
return root;
}
private static void setCodeWords(HuffmanNode root){
if(root != null){
setCodeWords(root, \"\");
}
}
private static void setCodeWords(HuffmanNode root, String codeWord){
if(root.getS() != null){
root.setC(codeWord);
root.setL(codeWord.length());
}
else{
setCodeWords(root.getLeft(), codeWord + \"0\");
setCodeWords(root.getRight(), codeWord + \"1\");
}
}
private static int findInsertIndex(ArrayList nodes, double prob){
for(int i = 0; i < nodes.size(); ++i){
if(prob < nodes.get(i).getP()){
return i;
}
}
return nodes.size();
}
}
// HuffmanNode.java
public class HuffmanNode {
private String S;
private double P;
private String C;
private int L;
private HuffmanNode left, right;
public HuffmanNode(String s, double p) {
S = s;
P = p;
}
public String getS() {
return S;
}
public void setS(String s) {
S = s;
}
public double getP() {
return P;
}
public void setP(double p) {
P = p;
}
public String getC() {
return C;
}
public void setC(String c) {
C = c;
}
public int getL() {
return L;
}
public void setL(int l) {
L = l;
}
public HuffmanNode getLeft() {
return left;
}
public void setLeft(HuffmanNode left) {
this.left = left;
}
public HuffmanNode getRight() {
return right;
}
public void se.
Please help write BinaryTree-java Thank you! Create a class BinaryTr.pdf
Please help write BinaryTree.java Thank you!
Create a class BinaryTree. A class that implements the ADT binary tree.
import java.util.Iterator;
import java.util.NoSuchElementException;
import StackAndQueuePackage.*;
public class BinaryTree <T> implements BinaryTreeInterface<T>
{
private BinaryNode<T> root;
public BinaryTree()
{
root = null;
} // end default constructor
public BinaryTree(T rootData)
{
root = new BinaryNode<>(rootData);
} // end constructor
public BinaryTree(T rootData, BinaryTree<T> leftTree,
BinaryTree<T> rightTree)
{
privateSetTree(rootData, leftTree, rightTree);
} // end constructor
public void setTree(T rootData)
{
root = new BinaryNode<>(rootData);
} // end setTree
public void setTree(T rootData, BinaryTreeInterface<T> leftTree,
BinaryTreeInterface<T> rightTree)
{
privateSetTree(rootData, (BinaryTree<T>)leftTree,
(BinaryTree<T>)rightTree);
} // end setTree
private void privateSetTree(T rootData, BinaryTree<T> leftTree,
BinaryTree<T> rightTree)
{
root = new BinaryNode<>(rootData);
if ((leftTree != null) && !leftTree.isEmpty())
root.setLeftChild(leftTree.root);
if ((rightTree != null) && !rightTree.isEmpty())
{
if (rightTree != leftTree)
root.setRightChild(rightTree.root);
else
root.setRightChild(rightTree.root.copy());
} // end if
if ((leftTree != null) && (leftTree != this))
leftTree.clear();
if ((rightTree != null) && (rightTree != this))
rightTree.clear();
} // end privateSetTree
//...
private class PreorderIterator implements Iterator<T>
{
private StackInterface<BinaryNode<T>> nodeStack;
public PreorderIterator()
{
nodeStack = new LinkedStack<>();
if (root != null)
nodeStack.push(root);
} // end default constructor
public boolean hasNext()
{
return !nodeStack.isEmpty();
} // end hasNext
public T next()
{
BinaryNode<T> nextNode;
if (hasNext())
{
nextNode = nodeStack.pop();
BinaryNode<T> leftChild = nextNode.getLeftChild();
BinaryNode<T> rightChild = nextNode.getRightChild();
// Push into stack in reverse order of recursive calls
if (rightChild != null)
nodeStack.push(rightChild);
if (leftChild != null)
nodeStack.push(leftChild);
}
else
{
throw new NoSuchElementException();
}
return nextNode.getData();
} // end next
public void remove()
{
throw new UnsupportedOperationException();
} // end remove
} // end PreorderIterator
public void iterativePreorderTraverse ()
{
StackInterface<BinaryNode<T>> nodeStack = new LinkedStack<>();
if (root != null)
nodeStack.push(root);
BinaryNode<T> nextNode;
while (!nodeStack.isEmpty())
{
nextNode = nodeStack.pop();
BinaryNode<T> leftChild = nextNode.getLeftChild();
BinaryNode<T> rightChild = nextNode.getRightChild();
// Push into stack in reverse order of recursive calls
if (rightChild != null)
nodeStack.push(rightChild);
if (leftChild != null)
nodeStack.push(leftChild);
System.out.print(nextNode.getData() + " ");
} // end while
} // end iterativePreorderTraverse
private class InorderIterator implements Iterator<T>
{
private StackInterface<BinaryNode<T>> nodeStack;
private BinaryNode<T> cu.
You can list anything, it doesnt matter. I just want to see code f.pdf
You can list anything, it doesn\'t matter. I just want to see code for this problem. Thank you
Solution
Include header files .......
Source code:
public class SinglyLinkedListImpl {
private Node head;
private Node tail;
public void add(T element){
Node nd = new Node();
nd.setValue(element);
System.out.println(\"Adding: \"+element);
if(head == null){
head = nd;
tail = nd;
} else {
tail.setNextRef(nd);
}
tail = nd;
}
}
public void addAfter(T element, T after){
Node tmp = head;
Node refNode = null;
System.out.println(\"Traversing to all nodes..\");
while(true){
if(tmp == null){
break;
}
if(tmp.compareTo(after) == 0){
refNode = tmp;
break;
}
tmp = tmp.getNextRef();
}
if(refNode != null){
Node nd = new Node();
nd.setValue(element);
nd.setNextRef(tmp.getNextRef());
if(tmp == tail){
tail = nd;
}
tmp.setNextRef(nd);
} else {
System.out.println(\"Unable to find the given element...\");
}
}
public void deleteFront(){
if(head == null){
System.out.println(\"Underflow...\");
}
Node tmp = head;
head = tmp.getNextRef();
if(head == null){
tail = null;
}
System.out.println(\"Deleted: \"+tmp.getValue());
}
public void deleteAfter(T after){
Node tmp = head;
Node refNode = null;
System.out.println(\"Traversing to all nodes..\");
while(true){
if(tmp == null){
break;
}
if(tmp.compareTo(after) == 0){
refNode = tmp;
break;
}
tmp = tmp.getNextRef();
}
if(refNode != null){
tmp = refNode.getNextRef();
refNode.setNextRef(tmp.getNextRef());
if(refNode.getNextRef() == null){
tail = refNode;
}
System.out.println(\"Deleted: \"+tmp.getValue());
} else {
System.out.println(\"Unable to find the given element...\");
}
}
public void traverse(){
Node tmp = head;
while(true){
if(tmp == null){
break;
}
System.out.println(tmp.getValue());
tmp = tmp.getNextRef();
}
}
public static void main(String a[]){
SinglyLinkedListImpl sl = new SinglyLinkedListImpl();
sl.add(3);
sl.add(32);
sl.add(54);
sl.add(89);
sl.addAfter(76, 54);
sl.deleteFront();
sl.deleteAfter(76);
sl.traverse();
}
}
class Node implements Comparable {
private T value;
private Node nextRef;
public T getValue() {
return value;
}
public void setValue(T value) {
this.value = value;
}
public Node getNextRef() {
return nextRef;
}
public void setNextRef(Node ref) {
this.nextRef = ref;
}
public int compareTo(T arg) {
if(arg == this.value){
return 0;
} else {
return 1;
}
}
}
This program implement the concept of single linked list..
Write a program that displays an AVL tree along with its balance fac.docx
This document provides code for an AVL tree implementation that:
1. Inserts nodes into the tree and rebalances it using rotations to maintain the AVL property.
2. Includes methods for searching, counting nodes, checking if the tree is empty, clearing the tree, and traversing the tree in different orders.
3. Contains a test program that uses the AVL tree to insert random numbers, perform operations on the tree, and display the results.
Here is the following code mentioned in the instructions.pdf
Here is the following code mentioned in the instructions:
class AVL {
Node root;
private class Node {
int data;
Node left, right;
int height;
private Node(int D, Node L, Node R, int H) {
data=D;
left=L;
right=R;
height=H; // user has to set height
} // of constructor Node
} //of Node
static private void UpdateHeight(Node T) {
if (T ==null) return;
else T.height = Math.max(HEIGHT(T.left),HEIGHT(T.right)) + 1;
} // UPdate Height
static private int HEIGHT(Node T) {
if (T== null ) return(-1);
else return (T.height);
}
// we need to more our right child up
static private Node LeftRotate(Node T) {
System.out.println(\"left rotate with data \" + T.data);
Node Tr;
Tr=T.right; // right child
T.right=Tr.left; // our right child IS NOW hhh
Tr.left=T; // move T down to the left
UpdateHeight(Tr.left); // update the height of T
UpdateHeight(Tr); // update hte height of the new root
return Tr;
} // of LeftRotate
// we move our immediate left node up.
// in doing so, we are now immediat right of our left child
static private Node RightRotate(Node T) {
Node Tl;
System.out.println(\"left rotate with data \" + T.data);
Tl=T.left; // left child
T.left=Tl.right; // our left child is now what our left was pointing to
Tl.right=T; // move T down to the right
UpdateHeight(Tl.right); // update the height of T
UpdateHeight(Tl); // update hte height of the new root
return Tl;
} // of RightRotate
public AVL() {
root=null;
} // of constructor AVL
// method to allow external entity to insert an element into the tree
public void insert(int D)
{
root=insert_internal(D, root);
} // of insert
private Node insert_internal(int D, Node T) {
if (T==null) return( new Node (D, null, null, 0));
if (T.data == D) return T; // the data is already in there
if ( D < T. data ) // go left
{ if (T.left == null)
{
T.left = insert_internal(D,null);
UpdateHeight(T);
}
else { //interior node
T.left = insert_internal(D, T.left);
}
} // of go left
else // D goes to the right
{ if (T.right == null)
{
T.right = insert_internal(D,null);
UpdateHeight(T);
}
else { //interior node
T.right = insert_internal(D, T.right);
}
} // of go right
// now we have to figure out if things are out of
// balance
int diff= HEIGHT(T.right) - HEIGHT(T.left);
System.out.println(\"difference is \" + diff + \" data is \" + T.data);
if ( Math.abs(diff) <= 1) // we are good to go at this level
{
UpdateHeight(T);
return(T);
}
// only if diff is bigger than 1
if ( diff > 1)// right leaning
{ // look at right child and figure out how it is leaning
} // of right leaning
else // left leaning
{ // look at left child to see how it is leaning
Node child = T.left;
int cdiff;
cdiff = HEIGHT(child.right) - HEIGHT(child.left);
System.out.println(\"cdiff is \" + cdiff);
if ( cdiff < 0 ) // left left lean
{ T=RightRotate(T); }
else
{
System.out.println(\"SHAUN\");
preorder_internal(T);
T.left = LeftRotate(T.left);
System.out.println(\"SHAUN\");
preorder_internal(T);
T=RightRotate(T);
}
} // of left leaning
// at this point we have rotated,.
Implement a function TNode copy_tree(TNode t) that creates a copy .pdf
Implement a function TNode* copy_tree(TNode* t) that creates a copy of the tree t and returns a
pointer to the root of the copy. Test this function by writing a main( that creates a tree and uses
the function to create a copy. Print both trees to verify they are the same.
Solution
// BSTree.h #ifndef BSTREE_H #define BSTREE_H #include using namespace std;
template struct TNode { TNode(const T &); T data; TNode* left, * right;
}; template TNode::TNode(const T & newItem) { data = newItem; left = right = NULL;
} template class BSTree { public: enum {T_OK = 0, T_DUPLICATE = -1,
T_NOT_FOUND = -2}; BSTree(); BSTree(const BSTree&); ~BSTree();
void clear(); int insert(const T&); int remove(const T&); int height() const; int
size() const; void printPreorder() const; void printInorder() const; void
printPostorder() const; const BSTree& operator=(const BSTree&); private:
TNode * root; void destroyTree(TNode*); int size(TNode*) const; int
height(TNode*) const; TNode* copyTree(TNode*); void preTrav(TNode*) const;
void inTrav(TNode*) const; void postTrav(TNode*) const; }; template
BSTree::BSTree() { root = NULL; } template BSTree::BSTree(const BSTree&
treeToCopy) { root = copyTree(treeToCopy.root); } template BSTree::~BSTree()
{ destroyTree(root); } template void BSTree::destroyTree(TNode* current) { if
(current != NULL) { destroyTree(current->left); destroyTree(current->right);
delete current; } } template void BSTree::clear() { destroyTree(root); root =
NULL; } template int BSTree::insert(const T& newItem) { TNode* current = root,
* parent = NULL; while (current != NULL && newItem != current->data) { parent
= current; if (newItem < current->data) current = current->left; else // if (newItem >
current->data) current = current->right; } if (current != NULL) return
T_DUPLICATE; else { TNode* newNode = new TNode(newItem); if (parent ==
NULL) root = newNode; else if (newNode->data < parent->data) parent-
>left = newNode; else parent->right = newNode; return T_OK; }
} template int BSTree::remove(const T& deleteItem) { TNode* delNode = root, *
delParent = NULL, * replNode, * replParent; while (delNode != NULL && deleteItem
!= delNode->data) { delParent = delNode; if (deleteItem < delNode->data)
delNode = delNode->left; else // if (newItem > current->data) delNode = delNode-
>right; } if (delNode != NULL) { if (delNode->left == NULL) replNode =
delNode->right; else if (!delNode->right) replNode = delNode->left; else {
replParent = delNode; replNode = delNode-> right; while (replNode->left !=
NULL) { replParent = replNode; replNode = replNode->left; }
if (replParent != delNode) { replParent->left = replNode->right;
replNode->right = delNode->right; } replNode->left = delNode->left; }
if (delParent == NULL) root = replNode; else { if (delParent->left ==
delNode) delParent->left = replNode; else delParent->right = replNode;
} delete delNode; return T_OK; } else return T_NOT_FOUND; }
template int BSTree::size() const { return size(root); } template int BSTree::size(.
Similar to package DataStructures; public class HelloWorld AnyType extends.pdf (20)
Given the following codepackage data1;import java.util.;p.pdf
Given the following codepackage data1;import java.util.;p.pdf
I have a .java program that I need to modify so that it1) reads i.pdf
I have a .java program that I need to modify so that it1) reads i.pdf
mainpublic class AssignmentThree { public static void ma.pdf
mainpublic class AssignmentThree { public static void ma.pdf
Once you have all the structures working as intended- it is time to co.docx
Once you have all the structures working as intended- it is time to co.docx
( PLEASE SHOW HOW TO IMPLEMENT THE DELETION FUNCTION )SAMPLE OUTPU.pdf
( PLEASE SHOW HOW TO IMPLEMENT THE DELETION FUNCTION )SAMPLE OUTPU.pdf
1. Add a breadth-first (level-order) traversal function to the binar.pdf
1. Add a breadth-first (level-order) traversal function to the binar.pdf
I need help finishing this code in JavaYou will need to create t.pdf
I need help finishing this code in JavaYou will need to create t.pdf
Table.java Huffman code frequency tableimport java.io.;im.docx
Table.java Huffman code frequency tableimport java.io.;im.docx
ANSimport java.util.Scanner; class Bina_node { Bina_node .pdf
ANSimport java.util.Scanner; class Bina_node { Bina_node .pdf
This is to test a balanced tree. I need help testing an unbalanced t.pdf
This is to test a balanced tree. I need help testing an unbalanced t.pdf
Here is the code given in the instructionsclass AVL {.pdf
Here is the code given in the instructionsclass AVL {.pdf
Modify HuffmanTree.java and HuffmanNode.java to allow the user to se.pdf
Modify HuffmanTree.java and HuffmanNode.java to allow the user to se.pdf
Please help write BinaryTree-java Thank you! Create a class BinaryTr.pdf
Please help write BinaryTree-java Thank you! Create a class BinaryTr.pdf
You can list anything, it doesnt matter. I just want to see code f.pdf
You can list anything, it doesnt matter. I just want to see code f.pdf
Write a program that displays an AVL tree along with its balance fac.docx
Write a program that displays an AVL tree along with its balance fac.docx
Here is the following code mentioned in the instructions.pdf
Here is the following code mentioned in the instructions.pdf
Implement a function TNode copy_tree(TNode t) that creates a copy .pdf
Implement a function TNode copy_tree(TNode t) that creates a copy .pdf
More from apleathers
While a majority of the worlds current electricity supply is gener.pdf
While a majority of the world\'s current electricity supply is generated from fossil fuels such as
coal, oil and natural gas, these traditional energy sources face a number of challenges including
rising prices, security concerns over dependence on imports from a limited number of countries
which have significant fossil fuel supplies, and growing environmental concerns over the climate
change risks associated with power generation using fossil fuels. As a result of these and other
challenges facing traditional energy sources, governments, businesses and consumers are
increasingly supporting the development of alternative energy sources and new technologies for
electricity generation. Renewable energy sources such as solar, biomass, geothermal,
hydroelectric and windpower generation have emerged as potential alternatives which address
some of these concerns. As opposed to fossil fuels, which draw on finite resources that may
eventually become too expensive to retrieve, renewable energy sources are generally unlimited
in availability.
Solar power generation has emerged as one of the most rapidly growing renewable sources of
electricity. Solar power generation has several advantages over other forms of electricity
generation:
Reduced Dependence on Fossil Fuels. Solar energy production does not require fossil fuels and
is therefore less dependent on this limited and expensive natural resource. Although there is
variability in the amount and timing of sunlight over the day, season and year, a properly sized
and configured system can be designed to be highly reliable while providing long-term, fixed
price electricity supply.
Environmental Advantages. Solar power production generates electricity with a limited impact
on the environment as compared to other forms of electricity production.
Matching Peak Time Output with Peak Time Demand. Solar energy can effectively supplement
electricity supply from an electricity transmission grid, such as when electricity demand peaks in
the summer
Modularity and Scalability. As the size and generating capacity of a solar system are a function
of the number of solar modules installed, applications of solar technology are readily scalable
and versatile.
Flexible Locations. Solar power production facilities can be installed at the customer site
which reduces required investments in production and transportation infrastructure.
Government Incentives. A growing number of countries have established incentive programs
for the development of solar and other renewable energy sources, such as (i) net metering laws
that allow on-grid end users to sell electricity back to the grid at retail prices, (ii) direct subsidies
to end users to offset costs of photovoltaic equipment and installation charges, (iii) low interest
loans for financing solar power systems and tax incentives; and (iv) government standards that
mandate minimum usage levels of renewable energy sources.
Despite the cost, an advantage of photovoltaic systems is.
What is broadbandWhat is the potential for broadband wireless syste.pdf
What is broadband?What is the potential for broadband wireless systems?Do you think it will
ever really catch on here in the US?
sol:
Broadband is a transmission technique with high capcaticy using wide range of frequency for
data transmission
and communication.it has an capability of sending multiple singnals through different medium
like optical fiber,coaxial fiber.
potential for broadband wireless systems:
1)wireless broadband network has potencial of data rates which is equal to wired networks
2)it supports both symmetric (it means same data rates in both the direction)and asymmetric
3)it has also capable of sending high data rates and communicate with satellite systems
4)it has a wide range of signal strength upto 50 km
Do you think it will ever really catch on here in the US?:
no it will catch on here in the us also because as the techology increases the needs also increases
so broadband will play a major role in day today life.according to us analysis the wireless
broadband subscription is 46.9% of population in 2009 and it has increased to 89.8% of the
population in 2012 and coming to the broadband usage it was 2.5% in 2000 and as in 2012 it was
28.0% in the world.
so the above analysis is one of the proof for developing of wireless Broadband in us
Solution
What is broadband?What is the potential for broadband wireless systems?Do you think it will
ever really catch on here in the US?
sol:
Broadband is a transmission technique with high capcaticy using wide range of frequency for
data transmission
and communication.it has an capability of sending multiple singnals through different medium
like optical fiber,coaxial fiber.
potential for broadband wireless systems:
1)wireless broadband network has potencial of data rates which is equal to wired networks
2)it supports both symmetric (it means same data rates in both the direction)and asymmetric
3)it has also capable of sending high data rates and communicate with satellite systems
4)it has a wide range of signal strength upto 50 km
Do you think it will ever really catch on here in the US?:
no it will catch on here in the us also because as the techology increases the needs also increases
so broadband will play a major role in day today life.according to us analysis the wireless
broadband subscription is 46.9% of population in 2009 and it has increased to 89.8% of the
population in 2012 and coming to the broadband usage it was 2.5% in 2000 and as in 2012 it was
28.0% in the world.
so the above analysis is one of the proof for developing of wireless Broadband in us.
WaterSolutionWater.pdf
This very short document contains only one word repeated three times - "Water". It does not provide much context or information to summarize in 3 sentences or less. The document seems to focus on the subject of water but does not elaborate on any key details, topics, or ideas about water that could be condensed into a multi-sentence summary.
Thousands of repeating units called nephrons will form a kidney and .pdf
Thousands of repeating units called nephrons will form a kidney and these organs are useful in
extracting the waste from blood and provides a balance in body fluids and same basic design of
kidneys will be found in all vertebrate kidneys.
It is believed that it is the fresh water teleost or bony fish which had the kidneys first as to tackle
the problem of living in water as their body fluid is of high osmotic concentration. These kidneys
helped them to prevent water from outside to inside and to prevent the solutes leaving the body.
The nephrons in these animals use to absorb the ions across the nephron tubules.
The primitive form of vertebrate kidney (archinephros) was known to have a segmental series of
tubules which was restricted to the trunk region of their body and each tubule was found to be
opened medially into the mesomeral coelom and these will be joined the hypomeral coelom
using a short canal. Later on these tubules curved posteriorly so that they can be united into a
common duct called archinephric duct and it has opened in cloaca.
The bulging of spherical cluster of capillaries in the nephrocoel of each segment was seen, in
later stages the glomerulus, nephrocoel and tubule will joined together to from a functional unit
known as archinephron-this is known as primitive vertebrate kidney.
During the course of evolution the nephrocoel lost its connect with that of hypomeral coelom and
slowly it became specialized as Bowman\'s capsule and like this bowman’s capsule was able to
form a union between glomerulus and renal tubule-it formed a functional unit called nephron.
Malpighian body was formed by the combination of glomerulus and Bowman\'s capsule and in
vertebrates the excretory organs are derived from mesoderm and vertebrates got unique
adaptation by having glomerulus which is water permeable capillaries and its suitability for free
water clearance gave them extra advantage for vertebrates for the evolution radiation in the
physiologically fresh water hostile environment.
Solution
Thousands of repeating units called nephrons will form a kidney and these organs are useful in
extracting the waste from blood and provides a balance in body fluids and same basic design of
kidneys will be found in all vertebrate kidneys.
It is believed that it is the fresh water teleost or bony fish which had the kidneys first as to tackle
the problem of living in water as their body fluid is of high osmotic concentration. These kidneys
helped them to prevent water from outside to inside and to prevent the solutes leaving the body.
The nephrons in these animals use to absorb the ions across the nephron tubules.
The primitive form of vertebrate kidney (archinephros) was known to have a segmental series of
tubules which was restricted to the trunk region of their body and each tubule was found to be
opened medially into the mesomeral coelom and these will be joined the hypomeral coelom
using a short canal. Later on these tubules curved posteriorly so tha.
To understand the complexicities of the issue at hand we must first .pdf
To understand the complexicities of the issue at hand we must first look at what cause inland
seas. According to the geographic descrptions,it was more than likely a result of tectonic plates
shifting during the developement of our current landmass positions. When they shift,the land can
either sinkor have its ocean basins fill with water from flooding.This is called
Transgression.Either case causes a developement of a salty body of water with aquatic animals
trapped inside.Being that is surrounded by a desert-like biome,itis more likely to be the result of
the tectonic plates spreading, causing the land to sink and fill in with salt water.As this occurs,
prey animals will thrive through a lack of predators, such as smaller fish.This enables the fishing
industry to boom as it did. The fishing trade in this area is at risk of falling.when humans alter
systems such as this one,their stabilty declines.For a while this was more than likely a self-
sustaining environment.The implementation of irrigation systemshave first,affected the wildlife
surrounding the inland sea, which was assisting its survival. Every animal plays a role in the
ecosystem.When the industries were built around the body of water, the land ecosystem
suffered.As a result, the fish in the corresponding water will eventually suffer.Being a self-
sustaining system, it will keep water cycling by itself. When the system was built for local
farmers, water supplies were being pulled from the natural made sea and into other locations. this
is normally fine for areas,but in one such as this,without any natural made filtering system, it will
begin losing water. the process will takea while due to the water cycle consistently adding some
back,but will occur. As the water levels decrease,so will the fish.This is the cause of research
number two. With an increasing salinity count,the pHof the water and soil will change as well.
Adding salt to the soil as it is doing through wind patterns, slowly crops, which once thrived in
the surrounding land,will begin todeplete.Not all plants require the same nutrient levels..If the
farmer \'s crops are thriving now, with lower salinity counts and lower pH\'s then the same crops
will not grow as well in higher salt concentrations and higher pH\'values .Another factor
affecting local farmers as well as the fishermen is the pesticides and chemicals.These will not
only affect the water\'s pH ,it will also affect the stability of the water for the fish to live in.As
more chemicals and sewage are added to a body of water , the fish have no choice but to take in
those hazardous wastes. At first, humans will grow sick of ill- prepared fish. Second,the fish will
slowly begin to die off causing the fishermen to lose a source of income. The future of this
environment is devasting. Local animals , which do use the sea as a source of food ,will
inadvertently be affected as well . While these animals may be capable of migrating , they cannot
move far into a desert w.
The P is the present value of the cash flow streamP = 100 (1+10.pdf
The P is the present value of the cash flow stream
P = 100 / (1+10%)^1 + 50 / (1+10%)^2 + 100 / (1+10%)^3
= 207.36
Solution
The P is the present value of the cash flow stream
P = 100 / (1+10%)^1 + 50 / (1+10%)^2 + 100 / (1+10%)^3
= 207.36.
Ribose sugar puckers adopt for both Deoxy nucleotides and ribonucleo.pdf
Ribose sugar puckers adopt for both Deoxy nucleotides and ribonucleotides in case of DNA and
RNA structures respectively. C3\' endo sugar pucker is exclusively seen. D Ribose structure
which varies at C2 deoxy form in DNA, Ribo form in RNA. The C1 of the ribose forms the
glycosidic linkage with the N 1 of the nitrogenous base.
14) MONO NUCLEOTIDES are Adenine, Guanine, Cytosine and Thymidine are linked by the
diphosphopyridine molecules, which having significant function in the cell.
Functions of Mono nucleotides:
Other functions used in molecular research studies like :
Solution
Ribose sugar puckers adopt for both Deoxy nucleotides and ribonucleotides in case of DNA and
RNA structures respectively. C3\' endo sugar pucker is exclusively seen. D Ribose structure
which varies at C2 deoxy form in DNA, Ribo form in RNA. The C1 of the ribose forms the
glycosidic linkage with the N 1 of the nitrogenous base.
14) MONO NUCLEOTIDES are Adenine, Guanine, Cytosine and Thymidine are linked by the
diphosphopyridine molecules, which having significant function in the cell.
Functions of Mono nucleotides:
Other functions used in molecular research studies like :.
Ques-1 Prenatal diagnosis has both positive and potentially negativ.pdf
Ques-1: Prenatal diagnosis has both positive and potentially negative consequences. While it is
most often used to detect serious problems with the fetus, the technology can also be used
potentially to select embryos based on sex, appearance, Where do you think we should draw the
line in allowing parents to use prenatal diagnosis
Answer:
Genetic testing is performed for prenatal diagnosis to know any chromosomal or genetical -
inherited abnormalities of implanted human embryo. It has positive consequence, as some
couples would like to avoid getting a baby with genetic abnormalities. However, there are
negative consequences such as various \"ethical and moral issues of prenatal diagnosis as
explained below. Therefore, it is crucial to draw a line when conducting prenatal diagnosis
finally a couple musty get legal permissions to undergo prenatal diagnosis.
Screening tests for genetic issues can be performed in the first trimester, second trimester or both
trimesters. Carrier testing is also an option performed prior to or during pregnancy. Carrier
testing provides information as to whether one or both parents are carriers for certain inherited
disorders. The results of these tests are used to determine an appropriate plan of care for the
patient. Genetic testing of the fetus and the parents offers both opportunities and ethical
challenges. As a Registered Nurse, you need to be aware of your own feelings in order to provide
non-biased professional support.
Implications of genetic testing:
Genetic testing is the pre-implantation technology is now currently using in detecting and
screening embryo in order to assess whether the resultant embryos from fertilization are normal
or abnormal genotypically. A registered nurse must advice & support to a couple seeking
guidance about the genetic testing because genetic screening has various ethical and moral
aspects. The major rising ethical challenge is the connection between the pre-selection of
embryos based on meticulous genetic analysis followed by rising discrimination of disabled
people. This ethical problem is associated with selection of future children based on their low
levels of disabilities and abnormalities.
Ethical challenges with preimplantation of genetic testing or diagnosis (PGD):
1. PGD allows embryo selection after pregnancy or even before initiation of pregnancy.
However, this procedure is very controversial and faces a variety of moral ethics that are
completely relies upon moral status of embryo and prenatal diagnosis in selecting progeny
without the use of abortion (medical issue).
2. The major rising ethical challenge is the connection between the pre-selection of embryos
based on meticulous genetic analysis followed by rising discrimination of disabled people, a
psychological moral issue. This ethical problem is associated with selection of future children
based on their low levels of disabilities and abnormalities. A clinic should have license primarily
to perform preimplantatio.
QuestionWhat are the elements of safe drinking water act What ar.pdf
Question:
What are the elements of safe drinking water act? What are the aspect & provision for safe
drinking water act?
Solution
:
This act was passed in 2002. The main elements imposes in the act are providing the permissible
limit of contaminants in drinking water i.e. drinking water standard, establishes the rule for
operators of facilities, for drinking water systems, for laboratories that dealt with the drinking
water parameter testing, training & certification to operators & there are many other elements
that require for safe drinking purpose.
Its main aspect is to ensure the safety of consumers by drinking the potable water (the water
contain the contaminants up to prescribed limit given in the act. By consuming the potable water,
the diseases associated due to drinking of polluted water are minimized.
There are three parameters are described in the act. These are physical parameters, chemical
parameters, & biological parameters. Physical parameter includes suspended solid, turbidity,
dissolved solid, pH, hardness, acidity, alkanity etc. The chemical parameters include BOD,
COD, ThOD, DO, etc. The biological parameter includes E.coli, B.Coli bacteria, pathogenic
bacteria, disease causing bacteria. Amongst, three bacteria, it’s the biological parameters which
are very objectionable. The upper limit of this parameters are prescribed in the act upto which
the water are drinkable.
Note: All pollutant water are contaminants but its not necessary that all contaminant are
pollutant..
Programimport java.util.; import java.io.; class FoodTruck.pdf
Program:
import java.util.*;
import java.io.*;
class FoodTruck
{
String truckName;
double fuelintruck;
int numberofemplyees;
String menuItems[]=new String[5];
public void getData()
{
Scanner s=new Scanner(System.in);
System.out.print(\"Enter TruckName\");
truckName=s.next();
System.out.print(\"Enter Fuel in Tank \");
fuelintruck=s.nextDouble();
System.out.print(\"Enter number of employess in truck\");
numberofemplyees=s.nextInt();
System.out.print(\"Enter Menu Items\");
for(int i=0;i<5;i++)
menuItems[i]=s.next();
}
public void ckeckfuel()
{
if(fuelintruck<2.5)
System.out.println(\"Please refill your truck\");
else
System.out.println(\"Fuel is enough\");
}
public void displayMenu()
{
try
{
FileOutputStream fout=new FileOutputStream(\"Menu.txt\");
for(int i=0;i<5;i++)
{
byte b[]=menuItems[i].getBytes();
fout.write(b);
System.out.println(menuItems[i]);
}
}
catch(IOException e)
{
System.out.println(e.getMessage());
}
}
}
public class MyTruck1
{
public static void main(String ar[])
{
FoodTruck ft=new FoodTruck();
ft.getData();
ft.ckeckfuel();
ft.displayMenu();
}
}
Output:
Enter TruckNameFoodpanda
Enter Fuel in Tank 25.4
Enter number of employess in truck5
Enter Menu Itemssabji dal papad noodels paneer
Fuel is enough
sabji
dal
papad
noodels
paneer
Solution
Program:
import java.util.*;
import java.io.*;
class FoodTruck
{
String truckName;
double fuelintruck;
int numberofemplyees;
String menuItems[]=new String[5];
public void getData()
{
Scanner s=new Scanner(System.in);
System.out.print(\"Enter TruckName\");
truckName=s.next();
System.out.print(\"Enter Fuel in Tank \");
fuelintruck=s.nextDouble();
System.out.print(\"Enter number of employess in truck\");
numberofemplyees=s.nextInt();
System.out.print(\"Enter Menu Items\");
for(int i=0;i<5;i++)
menuItems[i]=s.next();
}
public void ckeckfuel()
{
if(fuelintruck<2.5)
System.out.println(\"Please refill your truck\");
else
System.out.println(\"Fuel is enough\");
}
public void displayMenu()
{
try
{
FileOutputStream fout=new FileOutputStream(\"Menu.txt\");
for(int i=0;i<5;i++)
{
byte b[]=menuItems[i].getBytes();
fout.write(b);
System.out.println(menuItems[i]);
}
}
catch(IOException e)
{
System.out.println(e.getMessage());
}
}
}
public class MyTruck1
{
public static void main(String ar[])
{
FoodTruck ft=new FoodTruck();
ft.getData();
ft.ckeckfuel();
ft.displayMenu();
}
}
Output:
Enter TruckNameFoodpanda
Enter Fuel in Tank 25.4
Enter number of employess in truck5
Enter Menu Itemssabji dal papad noodels paneer
Fuel is enough
sabji
dal
papad
noodels
paneer.
Please follow the data and description Active Directory In gen.pdf
Please follow the data and description :
Active Directory :
In general the Active Directory is abbrevated as AD and is a directory service that Microsoft
developed for Windows domain networks. It is included in most of the available Windows
Server operating systems as a set of processes and services.
Considerations for designing a Active Directory :
Before moving on directly to the planning ang implementation of the Active Directory we just
need to get some major factors and their considerations into account so as to handle them
perfectly. When we are designing the Active Directory network, it is important to use the four
divisions (forests, domains, organizational units, and sites) to their maximum potential. Some of
the important factors/considerations are described below :
a) Active Directory elements :
When designing an Active Directory, we need to be completely clear of what each element or
part actually means and how it fits into the overall design.
b) Active Directory forest :
In general, the forest, in terms of Active Directory, basically means every domain, organizational
unit, and any other object stored within its database. The forest is the absolute top level of the
Active Directory infrastructure. We can have more than one forest in a company, which actually
represent the high level security boundaries, and can therefore improve security between
different business units or companies belonging to a single organization. The point behind the
forest is that we have all our domains and domain tree within the organization itself contained
within it. It is designed so that we can have a transitive links between all of the trees within one
forest.
c) Active Directory tree :
A tree with reference to the Active Directory basically refers to a domain and all of its objects
that merge into a single DNS name.
d) Organizational Units and the Leaf Objects :
In an Active Directory, Organizational Units abbrevated as OUs, which are also called as the
Containers, and the Leaf Objects, which are of non-containing objects such as computer accounts
and user accounts, are directly related. We can access the OUs and other objects through the
Microsoft Management Console (MMC) or through the Users and Computers tool in the
Administrative Tools.
e) Active Directory Sites :
The Sites and Services of the MMC is a utility that a lot of Windows administrators, particularly
in smaller organizations, completely overlook. This part of Active Directory, however, is one of
the most crucial parts to understand and implement correctly. These Sites give us a very unique
and well-designed approach to separate specific locations within the Active Directory. As the
principle of an Active Directory domain is global-meaning that it is meant to be the same
anywhere-it could present a problem for users who move from office to office, or for offices with
network connections that are slow. Active Directory sites allow one to specify the IP address
spaces or subnets used with.
it always attacks oxygen.the image doesnot workSolutionit alwa.pdf
it always attacks oxygen.the image doesnot work
Solution
it always attacks oxygen.the image doesnot work.
import java.util.Scanner;public class Fraction { instan.pdf
The document defines a Fraction class with methods to represent fractions, multiply fractions, and reduce fractions to their lowest terms. It includes constructors to initialize fractions to default or custom values, getter and setter methods, and a main method that demonstrates creating and manipulating Fraction objects.
Hi,Please find the Ansswer below.PLAYLIST.h#include iostrea.pdf
Hi,
Please find the Ansswer below.
//PLAYLIST.h
#include
#include
#include
#include
using namespace std;
class Playlist
{
private:
string uniqueID;
string songName;
string artistName;
int songLength;
public:
Playlist() { uniqueID = \"\", songName = \"\", artistName = \"\", songLength = 0; };
Playlist(string auniqueId, string asongName, string aArtistName, int aSongLength);
void InsertAfter();
void SetNext();
string GetID();
string GetSongName();
string GetArtistName();
int GetSongLength();
string GetNext();
void PrintPlaylistNode();
};
//PLAYLIST.CPP
#include \"Playlist.h\"
Playlist::Playlist(string auniqueId, string asongName, string aArtistName, int aSongLength)
{
uniqueID = auniqueId;
songName = asongName;
artistName = aArtistName;
songLength = aSongLength;
}
string Playlist::GetArtistName()
{
return artistName;
}
string Playlist::GetID()
{
return uniqueID;
}
string Playlist::GetSongName()
{
return songName;
}
int Playlist::GetSongLength()
{
return songLength;
}
void Playlist::SetNext()
{
}
string Playlist::GetNext()
{
return \"\";
}
void Playlist::InsertAfter() {
}
void Playlist::PrintPlaylistNode()
{
cout << \"Unique ID:\" << uniqueID << endl ;
cout << \"Song Name:\" << songName << endl;
cout << \"Artist Name:\" << artistName << endl;
cout << \"Song Length (in seconds):\" << songLength << endl;
}
//PLAYSLITSNODE.h
#pragma once
#include \"Playlist.h\"
#include
class PlaylistNode
{
private:
std::list library;
Playlist get(list _list, int _i);
void PrintPlaylist(Playlist aPlayList);
public:
void Addsong(Playlist aPlayslist);
void Removesong(string aUnwiid);
void Changeposition(int oldPostion, int anewPostion);
void PrintSongByartist(string aAstist);
void PrintSongtotalLen();
void PrintFullPlayList();
};
//PLAYLIST.CPP
#include \"PlaylistNode.h\"
void PlaylistNode::Addsong(Playlist aPlaylist)
{
library.push_back(aPlaylist);
}
void PlaylistNode::Removesong(string aUnwiid)
{
if (library.size > 0)
{
for (it = library.begin(); it != library.end(); ++it)
{
if (it->GetID() == aUnwiid)
{
cout << it->GetSongName() << endl;
library.remove(*it);
break;
}
}
}
}
Playlist PlaylistNode::get(list _list, int _i) {
list::iterator it = _list.begin();
for (int i = 0; i<_i; i++) {
++it;
}
return *it;
}
std::list::iterator it;
void PlaylistNode::PrintFullPlayList()
{
for (it = library.begin(); it != library.end(); ++it)
{
PrintPlaylist(*it);
}
}
void PlaylistNode::PrintSongByartist(string aartiename)
{
for (it = library.begin(); it != library.end(); ++it)
{
if(it->GetArtistName() == aartiename)
PrintPlaylist(*it);
}
}
void PlaylistNode::PrintSongtotalLen()
{
int TotalSonglengst = 0;
for (it = library.begin(); it != library.end(); ++it)
{
TotalSonglengst += it->GetSongLength();
}
cout << \"Total songs Length (in seconds):\" << TotalSonglengst << endl;
}
void PlaylistNode::PrintPlaylist(Playlist aPlayList)
{
cout << \"Unique ID:\" << aPlayList.GetID() << endl;
cout << \"Song Name:\" << aPlayList.GetSongName() << endl;
cout << \"Artist Name:\" << aPlayList.GetArtis.
Family as a Social Institution A family can be defined as group of .pdf
Family as a Social Institution: A family can be defined as group of two or more people living in
a household and connected to each other by blood or adoption or marriage. Family as social
constitution serves to create and maintain the family life in correct ways which are considered
good by a society. It is not an objective institution as it serves to give shape to feeling and
emotions of family memberns in fundamental ways.
Predominance of nuclear families: Smaller sized nuclear families indulge individualism in its
members. These small families are supported by increasingly reducing sized homes and are
easier to relocate. Further, small sized nuclear families can support the expensive education,
medication and other services to their children in a much better way as compared to the large
sized joint families.
Existence and characteristics of family structures: Some of the common family structures with
their characteristic features are as follows:
1: Nuclear family: The family with two generations i.e. parents and their children
2: Extended family: The family with three generations i.e. grandparents, parents and their
children constitutes an extended family.
3: Single parent family: The family in which one parent and children are residing in same
household is called as single parent family.
4: Reconstituted family: The family in which either or both of the parents have children from
their previous marriage living together are called as reconstituted family.
Characters of a family: A family is established by mating relation between man and woman
through marriage institution. Marriage is foundation of family irrespetive of mating relationship
without marriage. A family always resides in a common household wherein each family member
has his own name. Hence, marriage, common household, nomenclature of family members,
mode of interaction and communication and an economic provision are some of the
characteristics of a family.
Solution
Family as a Social Institution: A family can be defined as group of two or more people living in
a household and connected to each other by blood or adoption or marriage. Family as social
constitution serves to create and maintain the family life in correct ways which are considered
good by a society. It is not an objective institution as it serves to give shape to feeling and
emotions of family memberns in fundamental ways.
Predominance of nuclear families: Smaller sized nuclear families indulge individualism in its
members. These small families are supported by increasingly reducing sized homes and are
easier to relocate. Further, small sized nuclear families can support the expensive education,
medication and other services to their children in a much better way as compared to the large
sized joint families.
Existence and characteristics of family structures: Some of the common family structures with
their characteristic features are as follows:
1: Nuclear family: The family with two generations i.e. parents and t.
D. The actual development of new standards and protocols for the Int.pdf
D. The actual development of new standards and protocols for the Internet is carried out by
working groups chartered by the IETF. Answers A, B, and C are incorrect.
Solution
D. The actual development of new standards and protocols for the Internet is carried out by
working groups chartered by the IETF. Answers A, B, and C are incorrect..
Dependent Variable. A variable that depends on one or more other var.pdf
Dependent Variable. A variable that depends on one or more other variables The dependent
variable responds to the independent variable. It is called dependent because it \"depends\" on
the independent variable. So Answer Is D
Solution
Dependent Variable. A variable that depends on one or more other variables The dependent
variable responds to the independent variable. It is called dependent because it \"depends\" on
the independent variable. So Answer Is D.
C is correct. While all Layer 2 devices split collision domains, swi.pdf
C is correct. While all Layer 2 devices split collision domains, switches create a separate
collision domain for each port.
A, B, and D are incorrect. A is incorrect because hubs are Layer 1 devices and extend collision
domains. B is incorrect because a bridge is a Layer 2 device, but can split the network only into
two collision domains. D is incorrect.
Solution
C is correct. While all Layer 2 devices split collision domains, switches create a separate
collision domain for each port.
A, B, and D are incorrect. A is incorrect because hubs are Layer 1 devices and extend collision
domains. B is incorrect because a bridge is a Layer 2 device, but can split the network only into
two collision domains. D is incorrect..
Answer.The following organisms are present in pod.1. Prokaryotes.pdf
Answer.
The following organisms are present in pod.
1. Prokaryotes, eg. Bacteria
2. Eukaryotes
a. Algae (plants)
b. Protozoans
3. Protists (unicellular eukaryotes)
Solution
Answer.
The following organisms are present in pod.
1. Prokaryotes, eg. Bacteria
2. Eukaryotes
a. Algae (plants)
b. Protozoans
3. Protists (unicellular eukaryotes).
AnswerThe mobile elements are the elerments move form one place t.pdf
Answer:
The mobile elements are the elerments move form one place to other place, where the particular
element is deficient.
The deficiency of mobile elements first appear in older leave whereas the deficency of the
immobile elements first appear in the younger leaves
The immobile elements are iron, calcium, manganese, zinc, copper and boron
Solution
Answer:
The mobile elements are the elerments move form one place to other place, where the particular
element is deficient.
The deficiency of mobile elements first appear in older leave whereas the deficency of the
immobile elements first appear in the younger leaves
The immobile elements are iron, calcium, manganese, zinc, copper and boron.
More from apleathers (20)
While a majority of the worlds current electricity supply is gener.pdf
While a majority of the worlds current electricity supply is gener.pdf
What is broadbandWhat is the potential for broadband wireless syste.pdf
What is broadbandWhat is the potential for broadband wireless syste.pdf
Thousands of repeating units called nephrons will form a kidney and .pdf
Thousands of repeating units called nephrons will form a kidney and .pdf
To understand the complexicities of the issue at hand we must first .pdf
To understand the complexicities of the issue at hand we must first .pdf
The P is the present value of the cash flow streamP = 100 (1+10.pdf
The P is the present value of the cash flow streamP = 100 (1+10.pdf
Ribose sugar puckers adopt for both Deoxy nucleotides and ribonucleo.pdf
Ribose sugar puckers adopt for both Deoxy nucleotides and ribonucleo.pdf
Ques-1 Prenatal diagnosis has both positive and potentially negativ.pdf
Ques-1 Prenatal diagnosis has both positive and potentially negativ.pdf
QuestionWhat are the elements of safe drinking water act What ar.pdf
QuestionWhat are the elements of safe drinking water act What ar.pdf
Programimport java.util.; import java.io.; class FoodTruck.pdf
Programimport java.util.; import java.io.; class FoodTruck.pdf
Please follow the data and description Active Directory In gen.pdf
Please follow the data and description Active Directory In gen.pdf
it always attacks oxygen.the image doesnot workSolutionit alwa.pdf
it always attacks oxygen.the image doesnot workSolutionit alwa.pdf
import java.util.Scanner;public class Fraction { instan.pdf
import java.util.Scanner;public class Fraction { instan.pdf
Hi,Please find the Ansswer below.PLAYLIST.h#include iostrea.pdf
Hi,Please find the Ansswer below.PLAYLIST.h#include iostrea.pdf
Family as a Social Institution A family can be defined as group of .pdf
Family as a Social Institution A family can be defined as group of .pdf
D. The actual development of new standards and protocols for the Int.pdf
D. The actual development of new standards and protocols for the Int.pdf
Dependent Variable. A variable that depends on one or more other var.pdf
Dependent Variable. A variable that depends on one or more other var.pdf
C is correct. While all Layer 2 devices split collision domains, swi.pdf
C is correct. While all Layer 2 devices split collision domains, swi.pdf
Answer.The following organisms are present in pod.1. Prokaryotes.pdf
Answer.The following organisms are present in pod.1. Prokaryotes.pdf
AnswerThe mobile elements are the elerments move form one place t.pdf
AnswerThe mobile elements are the elerments move form one place t.pdf
Recently uploaded
How to Add Chatter in the odoo 17 ERP Module
In Odoo, the chatter is like a chat tool that helps you work together on records. You can leave notes and track things, making it easier to talk with your team and partners. Inside chatter, all communication history, activity, and changes will be displayed.
Assessment and Planning in Educational technology.pptx
In an education system, it is understood that assessment is only for the students, but on the other hand, the Assessment of teachers is also an important aspect of the education system that ensures teachers are providing high-quality instruction to students. The assessment process can be used to provide feedback and support for professional development, to inform decisions about teacher retention or promotion, or to evaluate teacher effectiveness for accountability purposes.
A Strategic Approach: GenAI in Education
Artificial Intelligence (AI) technologies such as Generative AI, Image Generators and Large Language Models have had a dramatic impact on teaching, learning and assessment over the past 18 months. The most immediate threat AI posed was to Academic Integrity with Higher Education Institutes (HEIs) focusing their efforts on combating the use of GenAI in assessment. Guidelines were developed for staff and students, policies put in place too. Innovative educators have forged paths in the use of Generative AI for teaching, learning and assessments leading to pockets of transformation springing up across HEIs, often with little or no top-down guidance, support or direction.
This Gasta posits a strategic approach to integrating AI into HEIs to prepare staff, students and the curriculum for an evolving world and workplace. We will highlight the advantages of working with these technologies beyond the realm of teaching, learning and assessment by considering prompt engineering skills, industry impact, curriculum changes, and the need for staff upskilling. In contrast, not engaging strategically with Generative AI poses risks, including falling behind peers, missed opportunities and failing to ensure our graduates remain employable. The rapid evolution of AI technologies necessitates a proactive and strategic approach if we are to remain relevant.
Digital Artifact 1 - 10VCD Environments Unit
Digital Artifact 1 - 10VCD Environments Unit - NGV Pavilion Concept Design
A Survey of Techniques for Maximizing LLM Performance.pptx
A Survey of Techniques for Maximizing LLM Performance
Executive Directors Chat Leveraging AI for Diversity, Equity, and Inclusion
Let’s explore the intersection of technology and equity in the final session of our DEI series. Discover how AI tools, like ChatGPT, can be used to support and enhance your nonprofit's DEI initiatives. Participants will gain insights into practical AI applications and get tips for leveraging technology to advance their DEI goals.
Main Java[All of the Base Concepts}.docx
This is part 1 of my Java Learning Journey. This Contains Custom methods, classes, constructors, packages, multithreading , try- catch block, finally block and more.
Advanced Java[Extra Concepts, Not Difficult].docx
This is part 2 of my Java Learning Journey. This contains Hashing, ArrayList, LinkedList, Date and Time Classes, Calendar Class and more.
Natural birth techniques - Mrs.Akanksha Trivedi Rama University
Natural birth techniques - Mrs.Akanksha Trivedi Rama UniversityAkanksha trivedi rama nursing college kanpur.
Natural birth techniques are various type such as/ water birth , alexender method, hypnosis, bradley method, lamaze method etcRPMS TEMPLATE FOR SCHOOL YEAR 2023-2024 FOR TEACHER 1 TO TEACHER 3
RPMS Template 2023-2024 by: Irene S. Rueco
How to Manage Your Lost Opportunities in Odoo 17 CRM
Odoo 17 CRM allows us to track why we lose sales opportunities with "Lost Reasons." This helps analyze our sales process and identify areas for improvement. Here's how to configure lost reasons in Odoo 17 CRM
South African Journal of Science: Writing with integrity workshop (2024)
South African Journal of Science: Writing with integrity workshop (2024)Academy of Science of South Africa
A workshop hosted by the South African Journal of Science aimed at postgraduate students and early career researchers with little or no experience in writing and publishing journal articles.Recently uploaded (20)
Assessment and Planning in Educational technology.pptx
Assessment and Planning in Educational technology.pptx
A Survey of Techniques for Maximizing LLM Performance.pptx
A Survey of Techniques for Maximizing LLM Performance.pptx
Executive Directors Chat Leveraging AI for Diversity, Equity, and Inclusion
Executive Directors Chat Leveraging AI for Diversity, Equity, and Inclusion
Digital Artefact 1 - Tiny Home Environmental Design
Digital Artefact 1 - Tiny Home Environmental Design
Natural birth techniques - Mrs.Akanksha Trivedi Rama University
Natural birth techniques - Mrs.Akanksha Trivedi Rama University
RPMS TEMPLATE FOR SCHOOL YEAR 2023-2024 FOR TEACHER 1 TO TEACHER 3
RPMS TEMPLATE FOR SCHOOL YEAR 2023-2024 FOR TEACHER 1 TO TEACHER 3
Pride Month Slides 2024 David Douglas School District
Pride Month Slides 2024 David Douglas School District
How to Manage Your Lost Opportunities in Odoo 17 CRM
How to Manage Your Lost Opportunities in Odoo 17 CRM
South African Journal of Science: Writing with integrity workshop (2024)
South African Journal of Science: Writing with integrity workshop (2024)
package DataStructures; public class HelloWorld AnyType extends.pdf
- 1. package DataStructures; public class HelloWorld > { public HelloWorld( ) { root = null; } public void insert( AnyType x ) { root = insert( x, root ); } public void remove( AnyType x ) { root = remove( x, root ); } public AnyType findMin( ) { if( isEmpty( ) ) System.out.println("tree is empty"); return findMin( root ).element; } public AnyType findMax( ) { if( isEmpty( ) ) System.out.println("tree is empty"); return findMax( root ).element; } public boolean contains( AnyType x ) { return contains( x, root ); } public void makeEmpty( ) { root = null;
- 2. } public boolean isEmpty( ) { return root == null; } public void printTree( ) { if( isEmpty( ) ) System.out.println( "Empty tree" ); else printTree( root ); } private BinaryNode insert( AnyType x, BinaryNode t ) { if( t == null ) return new BinaryNode( x, null, null ); int compareResult = x.compareTo( t.element ); if( compareResult < 0 ) t.left = insert( x, t.left ); else if( compareResult > 0 ) t.right = insert( x, t.right ); else ; // Duplicate; do nothing return t; } private BinaryNode remove( AnyType x, BinaryNode t ) { if( t == null ) return t; // Item not found; do nothing int compareResult = x.compareTo( t.element ); if( compareResult < 0 ) t.left = remove( x, t.left );
- 3. else if( compareResult > 0 ) t.right = remove( x, t.right ); else if( t.left != null && t.right != null ) // Two children { t.element = findMin( t.right ).element; t.right = remove( t.element, t.right ); } else t = ( t.left != null ) ? t.left : t.right; return t; } private BinaryNode findMin( BinaryNode t ) { if( t == null ) return null; else if( t.left == null ) return t; return findMin( t.left ); } private BinaryNode findMax( BinaryNode t ) { if( t != null ) while( t.right != null ) t = t.right; return t; } private boolean contains( AnyType x, BinaryNode t ) { if( t == null ) return false; int compareResult = x.compareTo( t.element ); if( compareResult < 0 ) return contains( x, t.left ); else if( compareResult > 0 )
- 4. return contains( x, t.right ); else return true; // Match } private void printTree( BinaryNode t ) { if( t != null ) { printTree( t.left ); System.out.println( t.element ); printTree( t.right ); } } private int height( BinaryNode t ) { if( t == null ) return -1; else return 1 + Math.max( height( t.left ), height( t.right ) ); } // Basic node stored in unbalanced binary search trees private static class BinaryNode { // Constructors BinaryNode( AnyType theElement ) { this( theElement, null, null ); } BinaryNode( AnyType theElement, BinaryNode lt, BinaryNode rt ) { element = theElement; left = lt; right = rt; } AnyType element; // The data in the node
- 5. BinaryNode left; // Left child BinaryNode right; // Right child } /** The tree root. */ private BinaryNode root; public static void main( String [ ] args ) { HelloWorld t = new HelloWorld( ); final int NUMS = 4000; final int GAP = 37; System.out.println( "Checking... (no more output means success)" ); for( int i = GAP; i != 0; i = ( i + GAP ) % NUMS ) t.insert( i ); for( int i = 1; i < NUMS; i+= 2 ) t.remove( i ); if( NUMS < 40 ) t.printTree( ); if( t.findMin( ) != 2 || t.findMax( ) != NUMS - 2 ) System.out.println( "FindMin or FindMax error!" ); for( int i = 2; i < NUMS; i+=2 ) if( !t.contains( i ) ) System.out.println( "Find error1!" ); for( int i = 1; i < NUMS; i+=2 ) { if( t.contains( i ) ) System.out.println( "Find error2!" ); } } } Solution package DataStructures; public class HelloWorld >
- 6. { public HelloWorld( ) { root = null; } public void insert( AnyType x ) { root = insert( x, root ); } public void remove( AnyType x ) { root = remove( x, root ); } public AnyType findMin( ) { if( isEmpty( ) ) System.out.println("tree is empty"); return findMin( root ).element; } public AnyType findMax( ) { if( isEmpty( ) ) System.out.println("tree is empty"); return findMax( root ).element; } public boolean contains( AnyType x ) { return contains( x, root ); } public void makeEmpty( ) { root = null; } public boolean isEmpty( ) { return root == null;
- 7. } public void printTree( ) { if( isEmpty( ) ) System.out.println( "Empty tree" ); else printTree( root ); } private BinaryNode insert( AnyType x, BinaryNode t ) { if( t == null ) return new BinaryNode( x, null, null ); int compareResult = x.compareTo( t.element ); if( compareResult < 0 ) t.left = insert( x, t.left ); else if( compareResult > 0 ) t.right = insert( x, t.right ); else ; // Duplicate; do nothing return t; } private BinaryNode remove( AnyType x, BinaryNode t ) { if( t == null ) return t; // Item not found; do nothing int compareResult = x.compareTo( t.element ); if( compareResult < 0 ) t.left = remove( x, t.left ); else if( compareResult > 0 ) t.right = remove( x, t.right ); else if( t.left != null && t.right != null ) // Two children {
- 8. t.element = findMin( t.right ).element; t.right = remove( t.element, t.right ); } else t = ( t.left != null ) ? t.left : t.right; return t; } private BinaryNode findMin( BinaryNode t ) { if( t == null ) return null; else if( t.left == null ) return t; return findMin( t.left ); } private BinaryNode findMax( BinaryNode t ) { if( t != null ) while( t.right != null ) t = t.right; return t; } private boolean contains( AnyType x, BinaryNode t ) { if( t == null ) return false; int compareResult = x.compareTo( t.element ); if( compareResult < 0 ) return contains( x, t.left ); else if( compareResult > 0 ) return contains( x, t.right ); else return true; // Match }
- 9. private void printTree( BinaryNode t ) { if( t != null ) { printTree( t.left ); System.out.println( t.element ); printTree( t.right ); } } private int height( BinaryNode t ) { if( t == null ) return -1; else return 1 + Math.max( height( t.left ), height( t.right ) ); } // Basic node stored in unbalanced binary search trees private static class BinaryNode { // Constructors BinaryNode( AnyType theElement ) { this( theElement, null, null ); } BinaryNode( AnyType theElement, BinaryNode lt, BinaryNode rt ) { element = theElement; left = lt; right = rt; } AnyType element; // The data in the node BinaryNode left; // Left child BinaryNode right; // Right child }
- 10. /** The tree root. */ private BinaryNode root; public static void main( String [ ] args ) { HelloWorld t = new HelloWorld( ); final int NUMS = 4000; final int GAP = 37; System.out.println( "Checking... (no more output means success)" ); for( int i = GAP; i != 0; i = ( i + GAP ) % NUMS ) t.insert( i ); for( int i = 1; i < NUMS; i+= 2 ) t.remove( i ); if( NUMS < 40 ) t.printTree( ); if( t.findMin( ) != 2 || t.findMax( ) != NUMS - 2 ) System.out.println( "FindMin or FindMax error!" ); for( int i = 2; i < NUMS; i+=2 ) if( !t.contains( i ) ) System.out.println( "Find error1!" ); for( int i = 1; i < NUMS; i+=2 ) { if( t.contains( i ) ) System.out.println( "Find error2!" ); } } }