Question

in java ..write all complete program from a- e

1. Given the two binary trees below: 14 16 Write a method called swapSubtrees, which swaps all of the left and right subtrees in the above binary trees. Add this method to the class BinaryTree and create a program to test this method for these 2 trees. Show the original trees and the resulting trees. Note: To test your algorithm, first create a binary search tree. Write a method called singleParent, which returns the number of nodes in a binary tree that have only one child for the 2 trees given in the above. Add this method to the class BinaryTree and create a program to test this method. Note: To test your algorithm, first create a binary search tree. 2. Start with an empty heap, and enter ten items with priorities 1 through 10. Draw the resulting heap. Now remove three entries from the heap that you created in the above exercise. Draw the resulting heap. ree lem# a) Create a TreeNode class with the following methods: default constructor, two overloaded constructors, copy constructor, getValue, getLeft, getRight, setValue, setLeft, setRight b) Create a BTInterface with the following abstract methods: getRoot, setRoot, isEmpty, swapSubtrees, singleParent, preorder, postOrder, inOrder, insert c) Create an abstract BinaryTree class that implements the interface. Include the default constructor, a private helper method called checkNode for singleParent) and toString. Make insert an abstract method d) Derive a BinarySearchTree class from Binary Tree with the following methods: default constructor, overloaded constructor (use a variable length parameter), insert, e) Create a TreeDemo class that creates two BinarySearch Tree objects. Use default and overloaded constructors. For tree one: call the methods make Tree (makes a complete tree), printTree, swapSubtrees, printTree. Simliar for tree two. Also, print out the number of single parents in each tree. Define make Tree and printTree in this class

Answer 1

1.

import java.util.Queue;
import java.util.LinkedList;
class Node
{
int data;
Node left, right;
  
public Node(int item)
{
data = item;
left = right = null;
}
}
class BinaryTree
{
Node root;
  
void swapSubtrees()
{
root = swapSubtrees(root);
}
  
Node swapSubtrees(Node node)
{
if (node == null)
return node;
  
/* do the subtrees */
Node left = swapSubtrees(node.left);
Node right = swapSubtrees(node.right);
  
/* swap the left and right pointers */
node.left = right;
node.right = left;
  
return node;
}
  
void inOrder()
{
inOrder(root);
}
  
/* Helper function to test mirror(). Given a binary
search tree, print out its data elements in
increasing sorted order.*/
void inOrder(Node node)
{
if (node == null)
return;
  
inOrder(node.left);
System.out.print(node.data + " ");
  
inOrder(node.right);
}
int singleParent()
{
// If tree is empty
if (root==null)
return 0;
  
// Do level order traversal starting from root
Queue<Node> queue = new LinkedList<Node>();
queue.add(root);
  
int count=0; // Initialize count of half nodes
while (!queue.isEmpty())
{
  
Node temp = queue.poll();
if (temp.left!=null && temp.right==null ||
temp.left==null && temp.right!=null)
count++;
  
// Enqueue left child
if (temp.left != null)
queue.add(temp.left);
  
// Enqueue right child
if (temp.right != null)
queue.add(temp.right);
}
return count;
}
}
public class Main
{
   public static void main(String[] args) {
       BinaryTree tree = new BinaryTree();
tree.root = new Node(1);
tree.root.left = new Node(2);
tree.root.right = new Node(3);
tree.root.left.left = new Node(4);
tree.root.left.right = new Node(5);
tree.root.right.left = new Node(6);
  
/* print inorder traversal of the input tree */
System.out.println("Inorder traversal of input tree is :");
tree.inOrder();
System.out.println("");
  
/* convert tree to its mirror */
tree.swapSubtrees();
  
/* print inorder traversal of the minor tree */
System.out.println("Inorder traversal of binary tree is : ");
tree.inOrder();
  
/* second tree*/
BinaryTree tree1=new BinaryTree();
tree1.root=new Node(14);
tree1.root.left=new Node(4);
tree1.root.right=new Node(15);
tree1.root.left.left=new Node(3);
tree1.root.left.right=new Node(9);
tree1.root.left.right.left=new Node(7);
tree1.root.left.right.left.left=new Node(5);
tree1.root.right.right=new Node(18);
tree1.root.right.right.left=new Node(16);
tree1.root.right.right.right=new Node(20);
tree1.root.right.right.left.right=new Node(17);
  
System.out.println("Inorder traversal of input tree1 is :");
tree1.inOrder();
System.out.println("");
  
/* convert tree to its mirror */
tree1.swapSubtrees();
  
/* print inorder traversal of the minor tree */
System.out.println("Inorder traversal of binary tree is : ");
tree1.inOrder();
System.out.println("Count of Single Child node of Tree:"+tree.singleParent());
System.out.println("Count of Single Child node of Tree1:"+tree1.singleParent());
   
   }
}

2.

import java.util.*;

public class Main
{
   public static void main(String[] args) {
  
PriorityQueue<Integer> heapQueue = new PriorityQueue<Integer>();
  
// Adding items to the heapQueue using add()
heapQueue.add(1);
heapQueue.add(2);
heapQueue.add(3);
heapQueue.add(4);
heapQueue.add(5);
heapQueue.add(6);
heapQueue.add(7);
heapQueue.add(8);
heapQueue.add(9);
heapQueue.add(10);
System.out.println("The queue elements:");
Iterator itr = heapQueue.iterator();
while (itr.hasNext())
System.out.println(itr.next());
heapQueue.remove(4);heapQueue.remove(6);heapQueue.remove(3);
System.out.println("after removing 4 ,6,3 from heap:");
Iterator<Integer> itr1 = heapQueue.iterator();
while (itr1.hasNext())
System.out.println(itr1.next());
   }
}