Feedback

assignment-2-Gopal868484.iml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

src/problem1/main/MyMain.java

@@ -1,11 +1,25 @@
-/*
- *  Created by IntelliJ IDEA.
- *  User: Vaibhav
- *  Date: 23-Mar-20
- *  Time: 7:17 PM
- */
 package problem1.main;
-// executable class
+
+import problem1.mybst.MyBinarySearchTree;
 
 public class MyMain {
+    public static void main(String[] args) {
+        MyBinarySearchTree mytree = new MyBinarySearchTree();
+        mytree.insert(50);
+        mytree.insert(30);
+        mytree.insert(20);
+        mytree.insert(40);
+        mytree.insert(70);
+        mytree.insert(60);
+        mytree.insert(80);
+        mytree.insert(90);
+        mytree.insert(10);
+        System.out.println("PreOrder Traversal : ");
+        mytree.traversePreOrder();
+        System.out.println("Left children Only : ");
+        //traverseLeft() methods prints all left children as well as returns the no of nodes not having left a child
+        System.out.println("No of nodes not having Left Subchild: " + mytree.traverseLeft());
+
+    }
 }
+

src/problem1/mybst/MyBinarySearchTree.java

@@ -1,10 +1,139 @@
-/*
- *  Created by IntelliJ IDEA.
- *  User: Vaibhav
- *  Date: 23-Mar-20
- *  Time: 7:17 PM
- */
 package problem1.mybst;
-// to implement BinarySearchTree
+
+import problem1.node.TreeNode;
+
 public class MyBinarySearchTree {
-}
+    private TreeNode root;
+
+    public MyBinarySearchTree() {
+        root = null;
+    }
+
+    public TreeNode getRoot() {
+        return root;
+    }
+
+
+    public void insert(int data) {
+        root = insertRecursive(root, data);
+    }
+
+    TreeNode insertRecursive(TreeNode root, int data) {
+        if (root == null) {
+            root = new TreeNode(data);
+            return root;
+        } else {
+            if (root.getData() > data) {
+                root.setLeft(insertRecursive(root.getLeft(), data));
+            } else if (root.getData() < data) {
+                root.setRight(insertRecursive(root.getRight(), data));
+            }
+            return root;
+        }
+    }
+
+
+    public void traverseInOrder() {
+        traverseInOrderRec(root);
+        System.out.println();
+    }
+
+    // A recursive function to do inorder traversal of BST
+    void traverseInOrderRec(TreeNode root) {
+        if (root != null) {
+            traverseInOrderRec(root.getLeft());
+            System.out.print(root.getData() + " ");
+            traverseInOrderRec(root.getRight());
+        }
+    }
+
+    //prints only left nodes
+    public int traverseLeft() {
+        int noOfNodesNotHavingLeftChild = traverseLeftNodesRec(root, false);
+        System.out.println();
+        return noOfNodesNotHavingLeftChild;
+
+    }
+
+    // A recursive function to do left traversal of BST
+    //Also returns no of nodes not having left subchild
+    int traverseLeftNodesRec(TreeNode root, boolean fromLeft) {
+        int count = 0;
+        if (root != null) {
+            if (fromLeft == true)
+                System.out.print(root.getData() + " ");
+            if (root.getLeft() == null) {
+                count++;
+            }
+            return count = count + traverseLeftNodesRec(root.getLeft(), true) + traverseLeftNodesRec(root.getRight(), false);
+        }
+        return count;
+    }
+
+    public void traversePreOrder() {
+        traversePreOrderRec(root);
+        System.out.println();
+    }
+
+    // A recursive function to do preorder traversal of BST
+    void traversePreOrderRec(TreeNode root) {
+        if (root != null) {
+            System.out.print(root.getData() + " ");
+            traversePreOrderRec(root.getLeft());
+            traversePreOrderRec(root.getRight());
+        }
+    }
+
+    public void traversePostOrder() {
+        traversePostOrderRec(root);
+        System.out.println();
+    }
+
+    // A recursive function to do preorder traversal of BST
+    void traversePostOrderRec(TreeNode root) {
+        if (root != null) {
+            traversePostOrderRec(root.getLeft());
+            traversePostOrderRec(root.getRight());
+            System.out.print(root.getData() + " ");
+        }
+    }
+
+    //Searches Element
+    public boolean search(int data) {
+        TreeNode node = searchRec(root, data);
+        if (node == null) {
+            return false;
+        } else if (node.getData() == data) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    public TreeNode searchRec(TreeNode root, int data) {
+        // Base Cases: root is null or key is present at root
+        if (root == null || root.getData() == data)
+            return root;
+
+        // val is greater than root's key
+        if (root.getData() > data)
+            return searchRec(root.getLeft(), data);
+
+        // val is less than root's key
+        return searchRec(root.getRight(), data);
+    }
+
+    public int count() {
+        return countRec(root);
+    }
+
+    // A recursive function to count total no of nodes of BST
+    public int countRec(TreeNode root) {
+        if (root == null)
+            return 0;
+        int count = 0;
+        count++;
+        count += (countRec(root.getLeft()) + countRec(root.getRight()));
+        return count;
+    }
+}

src/problem1/node/TreeNode.java

@@ -1,10 +1,37 @@
-/*
- *  Created by IntelliJ IDEA.
- *  User: Vaibhav
- *  Date: 23-Mar-20
- *  Time: 7:17 PM
- */
 package problem1.node;
 
 public class TreeNode {
-}
+    private int data;
+    private TreeNode left;
+    private TreeNode right;
+
+    public TreeNode(int data) {
+        this.data = data;
+        this.left = null;
+        this.right = null;
+    }
+
+    public int getData() {
+        return data;
+    }
+
+    public void setData(int data) {
+        this.data = data;
+    }
+
+    public TreeNode getLeft() {
+        return left;
+    }
+
+    public void setLeft(TreeNode left) {
+        this.left = left;
+    }
+
+    public TreeNode getRight() {
+        return right;
+    }
+
+    public void setRight(TreeNode right) {
+        this.right = right;
+    }
+}

src/problem2/main/MyMain.java

@@ -1,11 +1,26 @@
-/*
- *  Created by IntelliJ IDEA.
- *  User: Vaibhav
- *  Date: 23-Mar-20
- *  Time: 7:15 PM
- */
 package problem2.main;
+import problem2.mybst.MyBinarySearchTree;
 // executable class
-// use problem1.mybst.MyBinarySearchTree class for creating binary tree
+
 public class MyMain {
+    public static void main(String[] args) {
+        MyBinarySearchTree mytree = new MyBinarySearchTree();
+        mytree.insert(100);
+        mytree.insert(20);
+        mytree.insert(200);
+        mytree.insert(300);
+        mytree.insert(150);
+        mytree.insert(30);
+        mytree.insert(10);
+        System.out.println("PreOrder Traversal : ");
+        mytree.traversePreOrder();
+        System.out.println("InOrder Traversal : ");
+        mytree.traverseInOrder();
+        System.out.println("PostOrder Traversal : ");
+        mytree.traversePostOrder();
+        System.out.println("Condition A : Root element is placed at opposite end," + "\n" +
+                "i.e. in pre order root is the first element where as in post order root is the last element. is TRUE");
+        System.out.println("Condition B :They have common mid point,\n" +
+                "i.e. both the traversal will give same element at the mid position for odd number of nodes. is TRUE");
+    }
 }