Java : Need Some Help WIth The Driver Class I am Getting a Few Errors public cla
ID: 3695071 • Letter: J
Question
Java : Need Some Help WIth The Driver Class I am Getting a Few Errors
public class TreeNode
{
/******** Instance Data *************/
int item; //Data field
TreeNode leftChild; //Left Pointer
TreeNode rightChild; //Right Pointer
/******** Constructors **************/
public TreeNode()
{
//Initializes an empty node
item = 0;
leftChild = null;
rightChild = null;
} // end constructor
public TreeNode(int newItem)
{
//Initializes tree node with item and no children.
item = newItem;
leftChild = null;
rightChild = null;
} // end constructor
public TreeNode(int newItem,
TreeNode left, TreeNode right)
{
// Initializes tree node with item and
// the left and right children references.
item = newItem;
leftChild = left;
rightChild = right;
} // end constructor
/************ Methods *******************/
public int getItem()
{
// Returns the item field.
return item;
} // end getItem
public void setItem(int newItem)
{
// Sets the item field to the new value newItem.
item = newItem;
} // end setItem
public TreeNode getLeft()
{
// Returns the reference to the left child.
return leftChild;
} // end getLeft
public void setLeft(TreeNode left)
{
// Sets the left child reference to left.
leftChild = left;
} // end setLeft
public TreeNode getRight()
{
// Returns the reference to the right child.
return rightChild;
} // end getRight
public void setRight(TreeNode right)
{
// Sets the right child reference to right.
rightChild = right;
} // end setRight
} // end TreeNode
import java.io.*;
public class BinaryTree
{
TreeNode node; //new nodes
TreeNode root; //root of Tree
boolean isEmpty; //is the tree empty?
/*********** Constructors *******************/
public BinaryTree()
{//create an empty tree
isEmpty = true; //the tree starts out empty
root = null; //root of tree is null
}// end constructor
/*************** Methods ********************/
public void insertValue(int data)
{
//initiate call to recursive insert function
root = insert(root, data); //updates root if tree is empty
}
private TreeNode insert(TreeNode newNode, int data)
{
//recursive insert function
if (newNode == null) //base case - reached null pointer
{
newNode = new TreeNode(data); //insert node
}
else //general case - find position
{
if (data <= newNode.getItem())
{
//if data is less than current node - move to left
newNode.setLeft(insert(newNode.getLeft(), data));
}
else
{
//if data is greater than current node - move to right
newNode.setRight(insert(newNode.getRight(), data));
}
}
return(newNode); // in any case, return the new pointer to the caller
}
public void display()
{
if(root == null) //don't print if tree is empty
{
System.out.println("The tree is empty.");
}
else //initiate call to recursive print function
{
node = root; //get root of tree
displayInOrder(node); //starting with root, display tree
}
}//end display
public void displayInOrder(TreeNode node)
{
//recursive display in order
//if there is data to the left
if (node.getLeft() != null)
{
//keep moving to the left until no more data
displayInOrder(node.getLeft());
}
//print out node
System.out.println(node.getItem());
//now move to the right
if (node.getRight() != null)
{
//keep traveling right until no more data
displayInOrder(node.getRight());
}
}//end display Node
public void inorder()
{
inorder(root);
}
private void inorder(TreeNode node)
{
if (node != null)
{
inorder(node.leftChild);
System.out.print(node.item +" ");
inorder(node.rightChild);
}
}
public void preorder()
{
preorder(root);
}
private void preorder(TreeNode node)
{
if (node != null)
{
System.out.print(node.item +" ");
preorder(node.leftChild);
preorder(node.rightChild);
}
}
public void postorder()
{
postorder(root);
}
private void postorder(TreeNode node)
{
if (node != null)
{
postorder(node.leftChild);
postorder(node.rightChild);
System.out.print(node.item +" ");
}
}
} // end BinaryTree
import java.util.Scanner;
import java.io.*;
public class BSTTreeTest
{
public static void main(String[] args)
{
Scanner scan = new Scanner(System.in);
BinaryTree bst = new BinaryTree();
System.out.println("AVLTree Tree Test ");
char ch;
do
{
System.out.println(" Menu ");
System.out.println("1. Read data from external file and inserts into a tree");
System.out.println("2. Insert data from keyboard into a tree");
System.out.println("3. Searches through tree to find a data element");
System.out.println("4. save tree to a separate external file");
System.out.println("5. Display data in both files");
int[]item = null;
int choice = scan.nextInt();
switch (choice)
{
case 1 :{
item = getFromFile("input.txt");
for(int d : item)
bst.insert(d);
}
break;
case 2 :
while(true) {
System.out.println("Enter integer element to insert; enter -1 to end");
int d = scan.nextInt();
if(d==-1)
break;
bst.insert(d);
}
break;
case 3 :
System.out.println("Enter integer element to search");
System.out.println("Search result : "+ bst.search( scan.nextInt() ));
break;
case 4 :
saveToFile(item);
break;
case 5 :
System.out.println("Input file data: "+getFromFile("input.txt"));
System.out.println("Output file data: "+getFromFile("output.txt"));
break;
default :
System.out.println("Wrong Entry ");
break;
}
System.out.print(" Post order : ");
bst.postorder();
System.out.print(" Pre order : ");
bst.preorder();
System.out.print(" In order : ");
bst.inorder();
System.out.println(" Do you want to continue (Type y or n) ");
ch = scan.next().charAt(0);
} while (ch == 'Y'|| ch == 'y');
}
public static int[] getFromFile(String fileName){
int[] item = null;
BufferedReader br = null;
try {
String line;
br = new BufferedReader(new FileReader(fileName));
line = br.readLine();
String nums[] = line.split(",");
item = new int[nums.length];
int i=0;
for(String s : nums){
item[i++] = Integer.parseInt(s);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (br != null)br.close();
} catch (IOException ex) {
ex.printStackTrace();
}
}
return item;
}
public static void saveToFile(int[] item){
try {
File file = new File("output.txt");
if (!file.exists()) {
file.createNewFile();
}
FileWriter fw = new FileWriter(file.getAbsoluteFile());
BufferedWriter bw = new BufferedWriter(fw);
for(int i : item)
bw.write(i+",");
bw.close();
System.out.println("Saved..");
} catch (IOException e) {
e.printStackTrace();
}
}
}
Explanation / Answer
The code has been corrected for errors
The modified code is given below.
Code for search is added and methods of insert from file and insert from keyboard have been modified
Modified Code
import java.util.Scanner;
import java.io.*;
class TreeNode
{
/******** Instance Data *************/
int item; //Data field
TreeNode leftChild; //Left Pointer
TreeNode rightChild; //Right Pointer
/******** Constructors **************/
public TreeNode()
{
//Initializes an empty node
item = 0;
leftChild = null;
rightChild = null;
} // end constructor
public TreeNode(int newItem)
{
//Initializes tree node with item and no children.
item = newItem;
leftChild = null;
rightChild = null;
} // end constructor
public TreeNode(int newItem,
TreeNode left, TreeNode right)
{
// Initializes tree node with item and
// the left and right children references.
item = newItem;
leftChild = left;
rightChild = right;
} // end constructor
/************ Methods *******************/
public int getItem()
{
// Returns the item field.
return item;
} // end getItem
public void setItem(int newItem)
{
// Sets the item field to the new value newItem.
item = newItem;
} // end setItem
public TreeNode getLeft()
{
// Returns the reference to the left child.
return leftChild;
} // end getLeft
public void setLeft(TreeNode left)
{
// Sets the left child reference to left.
leftChild = left;
} // end setLeft
public TreeNode getRight()
{
// Returns the reference to the right child.
return rightChild;
} // end getRight
public void setRight(TreeNode right)
{
// Sets the right child reference to right.
rightChild = right;
} // end setRight
} // end TreeNode
class BinaryTree
{
TreeNode node; //new nodes
TreeNode root; //root of Tree
boolean isEmpty; //is the tree empty?
/*********** Constructors *******************/
public BinaryTree()
{//create an empty tree
isEmpty = true; //the tree starts out empty
root = null; //root of tree is null
}// end constructor
/*************** Methods ********************/
public void insertValue(int data)
{
//initiate call to recursive insert function
root = insert(root, data); //updates root if tree is empty
}
public TreeNode insert(TreeNode newNode, int data)
{
//recursive insert function
if (newNode == null) //base case - reached null pointer
{
newNode = new TreeNode(data); //insert node
}
else //general case - find position
{
if (data <= newNode.getItem())
{
//if data is less than current node - move to left
newNode.setLeft(insert(newNode.getLeft(), data));
}
else
{
//if data is greater than current node - move to right
newNode.setRight(insert(newNode.getRight(), data));
}
}
return(newNode); // in any case, return the new pointer to the caller
}
public void display()
{
if(root == null) //don't print if tree is empty
{
System.out.println("The tree is empty.");
}
else //initiate call to recursive print function
{
node = root; //get root of tree
displayInOrder(node); //starting with root, display tree
}
}//end display
public void displayInOrder(TreeNode node)
{
//recursive display in order
//if there is data to the left
if (node.getLeft() != null)
{
//keep moving to the left until no more data
displayInOrder(node.getLeft());
}
//print out node
System.out.println(node.getItem());
//now move to the right
if (node.getRight() != null)
{
//keep traveling right until no more data
displayInOrder(node.getRight());
}
}//end display Node
public void inorder()
{
inorder(root);
}
private void inorder(TreeNode node)
{
if (node != null)
{
inorder(node.leftChild);
System.out.print(node.item +" ");
inorder(node.rightChild);
}
}
public void preorder()
{
preorder(root);
}
private void preorder(TreeNode node)
{
if (node != null)
{
System.out.print(node.item +" ");
preorder(node.leftChild);
preorder(node.rightChild);
}
}
public void postorder()
{
postorder(root);
}
private void postorder(TreeNode node)
{
if (node != null)
{
postorder(node.leftChild);
postorder(node.rightChild);
System.out.print(node.item +" ");
}
}
public boolean search(int val)
{
return search(root, val);
}
/* Function to search for an element recursively */
private boolean search(TreeNode r, int val)
{
boolean found = false;
while ((r != null) && !found)
{
int rval = r.getItem();
if (val < rval)
r = r.getLeft();
else if (val > rval)
r = r.getRight();
else
{
found = true;
break;
}
found = search(r, val);
}
return found;
}
} // end BinaryTree
public class BSTTreeTest
{
public static void main(String[] args)
{
Scanner scan = new Scanner(System.in);
BinaryTree bst = new BinaryTree();
System.out.println("AVLTree Tree Test ");
char ch;
do
{
System.out.println(" Menu ");
System.out.println("1. Read data from external file and inserts into a tree");
System.out.println("2. Insert data from keyboard into a tree");
System.out.println("3. Searches through tree to find a data element");
System.out.println("4. save tree to a separate external file");
System.out.println("5. Display data in both files");
int[]item = null;
int choice = scan.nextInt();
switch (choice)
{
case 1 :
item = getFromFile("input.txt");
TreeNode node = null;
for(int d : item)
bst.insert(node, d);
break;
case 2 :
while(true) {
System.out.println("Enter integer element to insert; enter -1 to end");
int d = scan.nextInt();
TreeNode node1 = null;
if(d==-1)
break;
bst.insert(node1, d);
}
break;
case 3 :
System.out.println("Enter integer element to search");
System.out.println("Search result : "+ bst.search( scan.nextInt() ));
break;
case 4 :
saveToFile(item);
break;
case 5 :
System.out.println("Input file data: "+getFromFile("input.txt"));
System.out.println("Output file data: "+getFromFile("output.txt"));
break;
default :
System.out.println("Wrong Entry ");
break;
}
System.out.print(" Post order : ");
bst.postorder();
System.out.print(" Pre order : ");
bst.preorder();
System.out.print(" In order : ");
bst.inorder();
System.out.println(" Do you want to continue (Type y or n) ");
ch = scan.next().charAt(0);
} while (ch == 'Y'|| ch == 'y');
}
public static int[] getFromFile(String fileName){
int[] item = null;
BufferedReader br = null;
try {
String line;
br = new BufferedReader(new FileReader(fileName));
line = br.readLine();
String nums[] = line.split(",");
item = new int[nums.length];
int i=0;
for(String s : nums){
item[i++] = Integer.parseInt(s);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (br != null)br.close();
} catch (IOException ex) {
ex.printStackTrace();
}
}
return item;
}
public static void saveToFile(int[] item){
try {
File file = new File("output.txt");
if (!file.exists()) {
file.createNewFile();
}
FileWriter fw = new FileWriter(file.getAbsoluteFile());
BufferedWriter bw = new BufferedWriter(fw);
for(int i : item)
bw.write(i+",");
bw.close();
System.out.println("Saved..");
} catch (IOException e) {
e.printStackTrace();
}
}
}
Related Questions
drjack9650@gmail.com
Navigate
Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.