Question

Write an implementation of a generic java BinaryTree class that fits any primitive data type. your class at minimum should have the following.

Node class with a minimum of three fields and 3 constructor.

BinaryTree class should include the following at least 3 Fields, at least 2 constructors, add, remove, find, getSize method (which returns the amount nods in the tree), getHeight (should return the height), countLeftNode (Should return the mount of left node found in the tree), countRightNode (Should return the mount of right node found in the tree), a preorder , inorder, and postorder print method.

Answer 1

package jan18;

class TreeNode<E> {
        private E data;
        private TreeNode<E> left;
        private TreeNode<E> right;

        public TreeNode(E d, TreeNode<E> l, TreeNode<E> r) {
                this.data = d;
                this.left = l;
                this.right = r;
        }

        public TreeNode(E d) {
                this.data = d;
        }

        public E getData() {
                return this.data;
        }

        public TreeNode<E> getLeft() {
                return this.left;
        }

        public TreeNode<E> getRight() {
                return this.right;
        }

        public void setData(E newData) {
                this.data = newData;
        }

        public void setLeft(TreeNode<E> newLeft) {
                this.left = newLeft;
        }

        public void setRight(TreeNode<E> newRight) {
                this.right = newRight;
        }
}

public class BinaryTree<E> {
        protected TreeNode<E> root;

        /**
         * Constructs an empty binary tree.
         */
        public BinaryTree() {
                this.root = null;
        }
        
        /**
         * Constructs an empty binary tree.
         */
        public BinaryTree(E value) {
                this.root = new TreeNode<E>(value);
        }

        /**
         * Adds a value to the binary tree (at the shallowest possible location)
         * 
         * @param value
         *            the value to be added
         */
        public void add(E value) {
                this.root = this.add(this.root, value);
        }

        private TreeNode<E> add(TreeNode<E> current, E value) {
                if (current == null) {
                        current = new TreeNode<E>(value, null, null);
                } else if (this.size(current.getLeft()) <= this.size(current.getRight())) {
                        current.setLeft(this.add(current.getLeft(), value));
                } else {
                        current.setRight(this.add(current.getRight(), value));
                }
                return current;
        }

        /**
         * Determines the size of the binary tree
         * 
         * @return the size (number of nodes in the tree)
         */
        public int size() {
                return this.size(this.root);
        }

        private int size(TreeNode<E> current) {
                if (current == null) {
                        return 0;
                } else {
                        return this.size(current.getLeft()) + this.size(current.getRight()) + 1;
                }
        }
        

        public int height() {
                return height(this.root);
        }

        private int height(TreeNode<E> node) {
                if (node == null)
                        return 0;

                /*
                 * If tree is not empty then height = 1 + max of left height and right
                 * heights
                 */
                return 1 + Math.max(height(node.getLeft()), height(node.getRight()));
        }
        
        
        

        /**
         * Determines whether the tree contains a particular value.
         * 
         * @param value
         *            the value to be searched for
         * @return true if value is in the tree, otherwise false
         */
        public boolean find(E value) {
                return this.find(this.root, value);
        }

        private boolean find(TreeNode<E> current, E value) {
                if (current == null) {
                        return false;
                } else {
                        return value.equals(current.getData()) || this.find(current.getLeft(), value)
                                        || this.find(current.getRight(), value);
                }
        }

        /**
         * Removes one occurrence of the specified value.
         * 
         * @param value
         *            the value to be removed
         * @return true if the value was found and removed, else false
         */
        public boolean remove(E value) {
                if (!this.find(value)) {
                        return false;
                } else {
                        this.root = this.remove(this.root, value);
                        return true;
                }
        }

        private TreeNode<E> remove(TreeNode<E> current, E value) {
                if (value.equals(current.getData())) {
                        if (current.getLeft() == null) {
                                current = current.getRight();
                        } else {
                                TreeNode<E> righty = current.getLeft();
                                while (righty.getRight() != null) {
                                        righty = righty.getRight();
                                }
                                current.setData(righty.getData());
                                current.setLeft(this.remove(current.getLeft(), current.getData()));
                        }
                } else if (this.find(current.getLeft(), value)) {
                        current.setLeft(this.remove(current.getLeft(), value));
                } else {
                        current.setRight(this.remove(current.getRight(), value));
                }
                return current;
        }
        
        public int countLeftNode() {
                return countLeftNode(root);
        }

        private int countLeftNode(TreeNode<E> start) {
                if(start == null) {
                        return 0;
                }
                int count = 0;
                if(start.getLeft() != null) {
                        count++;
                }
                count += countLeftNode(start.getLeft());
                count += countLeftNode(start.getRight());
                return count;
        }
        
        public int countRightNode () {
                return countRightNode (root);
        }

        private int countRightNode (TreeNode<E> start) {
                if(start == null) {
                        return 0;
                }
                int count = 0;
                if(start.getRight() != null) {
                        count++;
                }
                count += countRightNode (start.getLeft());
                count += countRightNode (start.getRight());
                return count;
        }

        /**
         * Converts the tree to a String using an inorder traversal.
         * 
         * @return the String representation of the tree.
         */
        public String toString() {
                if (this.root == null) {
                        return "[]";
                }

                String recStr = this.toString(this.root);
                return "[" + recStr.substring(0, recStr.length() - 1) + "]";
        }

        private String toString(TreeNode<E> current) {
                if (current == null) {
                        return "";
                }

                return this.toString(current.getLeft()) + current.getData().toString() + ","
                                + this.toString(current.getRight());
        }
        
        public void preOrder() {
                preOrder(root);
        }

        private void preOrder(TreeNode<E> start) {
                if(start != null) {
                        System.out.println(start.getData());
                        preOrder(start.getLeft());
                        preOrder(start.getRight());
                }
        }
        
        public void postOrder() {
                postOrder(root);
        }

        private void postOrder(TreeNode<E> start) {
                if(start != null) {
                        postOrder(start.getLeft());
                        postOrder(start.getRight());
                        System.out.println(start.getData());
                }
        }
        
        public void inOrder() {
                inOrder(root);
        }

        private void inOrder(TreeNode<E> start) {
                if(start != null) {
                        inOrder(start.getLeft());
                        System.out.println(start.getData());
                        inOrder(start.getRight());
                }
        }
}

please upvote. Thanks!