{"id":26652722,"url":"https://github.com/subraatakumar/binary-search-tree-java","last_synced_at":"2025-09-07T01:35:55.116Z","repository":{"id":101512073,"uuid":"457808783","full_name":"subraatakumar/Binary-Search-Tree-Java","owner":"subraatakumar","description":"Different binary search tree operations are tried to explain in this repository","archived":false,"fork":false,"pushed_at":"2022-02-11T02:12:41.000Z","size":28,"stargazers_count":2,"open_issues_count":0,"forks_count":0,"subscribers_count":1,"default_branch":"main","last_synced_at":"2025-03-25T03:57:49.645Z","etag":null,"topics":[],"latest_commit_sha":null,"homepage":null,"language":"Java","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":null,"status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/subraatakumar.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":null,"code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null}},"created_at":"2022-02-10T14:15:55.000Z","updated_at":"2022-06-29T13:01:24.000Z","dependencies_parsed_at":null,"dependency_job_id":"1c3eabee-1800-46b6-8360-f94d81182b5c","html_url":"https://github.com/subraatakumar/Binary-Search-Tree-Java","commit_stats":null,"previous_names":["subraatakumar/binary-search-tree-java"],"tags_count":0,"template":false,"template_full_name":null,"purl":"pkg:github/subraatakumar/Binary-Search-Tree-Java","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/subraatakumar%2FBinary-Search-Tree-Java","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/subraatakumar%2FBinary-Search-Tree-Java/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/subraatakumar%2FBinary-Search-Tree-Java/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/subraatakumar%2FBinary-Search-Tree-Java/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/subraatakumar","download_url":"https://codeload.github.com/subraatakumar/Binary-Search-Tree-Java/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/subraatakumar%2FBinary-Search-Tree-Java/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":273986613,"owners_count":25202704,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","status":"online","status_checked_at":"2025-09-06T02:00:13.247Z","response_time":2576,"last_error":null,"robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":true,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":[],"created_at":"2025-03-25T03:57:52.554Z","updated_at":"2025-09-07T01:35:55.077Z","avatar_url":"https://github.com/subraatakumar.png","language":"Java","funding_links":[],"categories":[],"sub_categories":[],"readme":"# Binary-Search-Tree-Java\nDifferent binary search tree operations are tried to explain in this repository\n\n## Traversal : visiting each element of a tree.\n\nFour types of traversal are :\n- Preorder Traversal : process root node, then its left/right subtrees\n- Inorder Traversal : process left subtree, then root node, then right\n- Postorder Traversal : process left/right subtrees, then root node\n- Level Order Traversal : Process level wise\n\n## Check if a binary tree is a BST or not\n~~~java\nboolean isBST(Node node)\n{\n    if (node == null)\n        return true;\n     \n    /* False if left is \u003e than node */\n    if (node.left != null \u0026\u0026 node.left.data \u003e node.data)\n        return false;\n     \n    /* False if right is \u003c than node */\n    if (node.right != null \u0026\u0026 node.right.data \u003c node.data)\n        return false;\n     \n    /* False if, recursively, the left or right is not a BST */\n    if (!isBST(node.left) || !isBST(node.right))\n        return false;\n     \n    /* Passing all that, it's a BST */\n    return true;\n}\n~~~\n\n## Preorder Traversal Method\n~~~java\n  public void preorder(Node node) {\n    if(node == null) {\n      return;\n    }\n    \n    System.out.print(node.data + \" \");\n    preorder(node.left);\n    preorder(node.right);\n  }\n~~~\n\n## Inorder Traversal Method\n~~~java\n  public void inorder(Node node) {\n    if(node == null) {\n      return;\n    }\n    \n    inorder(node.left);\n    System.out.print(node.data + \" \");\n    inorder(node.right);\n  }\n~~~\n\n## Postorder Traversal Method\n~~~java\n  public void postorder(Node node) {\n    if(node == null) {\n      return;\n    }\n    \n    postorder(node.left);\n    postorder(node.right);\n    System.out.print(node.data+ \" \");\n  }\n~~~  \n\n## Level Order Traversal Method\n~~~java\npublic static void levelOrder(Node root) {\n       if(root == null) {\n           return;\n       }\n       Queue\u003cNode\u003e q = new LinkedList\u003c\u003e();\n       q.add(root);\n       q.add(null);\n       while(!q.isEmpty()) {\n           Node curr = q.remove();\n           if(curr == null) {\n               System.out.println();\n               //queue empty\n               if(q.isEmpty()) {\n                   break;\n               } else {\n                   q.add(null);\n               }\n           } else {\n               System.out.print(curr.data+\" \");\n               if(curr.left != null) {\n                   q.add(curr.left);\n               }\n               if(curr.right != null) {\n                   q.add(curr.right);\n               }\n           }\n       }\n   }\n~~~\n\n## Delete a Node Method\n\n~~~java\n  public Node delete(Node node, int val) {\n    if(node == null) {\n      return node;\n    }\n    \n    if(val \u003c node.data) {\n      node.left = delete(node.left, val);\n    } else if(val \u003e node.data) {\n      node.right = delete(node.right, val);\n    } else {\n      if(node.left == null || node.right == null) {\n        Node temp = node.left != null ? node.left : node.right;\n\n        if(temp == null) {\n          return null;\n        } else {\n          return temp;\n        }\n      } else {\n        Node successor = getSuccessor(node);\n        node.data = successor.data;\n        \n        node.right = delete(node.right, successor.data);\n        return node;\n      }\n    }\n    \n    return node;\n  }\n   public Node getSuccessor(Node node) {\n\t    if(node == null) {\n\t      return null;\n\t    }\n\t    \n\t    Node temp = node.right;\n\t    \n\t    while(temp.left != null) {\n\t      temp = temp.left;\n\t    }\n\t    \n\t    return temp;\n\t}   \n~~~\n\n## Check if a value exists in Binary Search Tree\n~~~java\n  public boolean ifNodePresent(Node node, int val) {\n    if(node == null) {\n      return false;\n    }\n    \n    boolean isPresent = false;\n    \n    while(node != null) {\n      if(val \u003c node.data) {\n        node = node.left;\n      } else if(val \u003e node.data) {\n        node = node.right;\n      } else {\n        isPresent = true;\n        break;\n      }\n    }\n    \n    return isPresent;\n  }\n~~~\n\n## Get parent node of a given value in Binary Search Tree\n~~~java\n  public Node getParentNode(Node node, int val) {\n    if(node == null) {\n      return null;\n    }\n    \n    Node getParent = null;\n    \n    while(node != null) {\n      if(val \u003c node.data) {\n        getParent = node;\n        node = node.left;\n      } else if (val \u003e node.data) {\n        getParent = node;\n        node = node.right;\n      } else {\n        break;\n      }\n    }\n\n    return getParent;\n  }\n~~~\n\n## Get Sibling Node of given value in Binary Search Tree\n~~~java\n  public Node getSiblingNode(Node node, int val) {\n    if(node == null || node.data == val) {\n      return null;\n    }\n    \n    Node parentNode = null;\n    \n    while(node != null) {\n      if(val \u003c node.data) {\n        parentNode = node;\n        node = node.left;\n      } else if(val \u003e node.data) {\n        parentNode = node;\n        node = node.right;\n      } else {\n        break;\n      }\n    }\n    \n    if(parentNode.left != null \u0026\u0026 val == parentNode.left.data) {\n      return parentNode.right;\n    }\n    \n    if(parentNode.right != null \u0026\u0026 val == parentNode.right.data) {\n      return parentNode.left;\n    }\n    \n    return null;\n  }\n~~~\n\n## Get Inorder Parent for a given value in Binary Search Tree\n\nvalue of parent should be greater then the child\n~~~java\n  public Node getInorderParent(Node node, int val) {\n    if(node == null) {\n      return null;\n    }\n    \n    Node inorderParent = null;\n    \n    while(node != null) {\n      if(val \u003c node.data) {\n        inorderParent = node;\n        node = node.left;\n      } else if (val \u003e node.data) {\n        node = node.right;\n      } else {\n        break;\n      }\n    }\n    \n    return node != null ? inorderParent : null;\n  }\n~~~\n\n## Get Inorder Successor of a given value in Binary Search Tree\n\nFind bigger number of the given node\n~~~java\n  public Node getInorderSuccessor(Node node, int val) {\n    if(node == null) {\n      return null;\n    }\n    \n    Node inorderSuccessor = null;\n    \n    while(node != null) {\n      if(val \u003c node.data) {\n        inorderSuccessor = node;\n        node = node.left;\n      } else if (val \u003e node.data) {\n        node = node.right;\n      } else {\n        if(node.right != null) {\n          inorderSuccessor = getSuccessor(node);\n        }\n        break;\n      }\n    }\n    return node != null ? inorderSuccessor : null;\n  }\n~~~\n\n## Get Difference of Even \u0026 Odd level values\n\nFind sum of values at Even level then find sum of values in odd level and then find their difference\n~~~java\n  public int getDifferenceEvenOddLevel(Node node) {\n    if(node == null) {\n      return 0;\n    }\n    \n    return node.data - getDifferenceEvenOddLevel(node.left) - getDifferenceEvenOddLevel(node.right);\n  }\n~~~\n\n## Get Max value element in Binary Search Tree\n\nFind the rightmost element. Because rightmost element of a Binary search tree is the Max.\n~~~java\n  public int getMax(Node node) {\n    if(node == null) {\n      System.out.println(\"Tree is EMpty\");\n      return -1;\n    }\n    \n    while(node.right != null) {\n      node = node.right;\n    }\n    \n    return node.data;\n  }\n~~~\n\n## Get Min value element in Binary Search Tree\n\nFind the leftmost element. Because the leftmost element of a binary search tree is the minimum.\n~~~java\n  public int getMin(Node node) {\n    if(node == null) {\n      System.out.println(\"Tree is EMpty\");\n      return -1;\n    }\n    \n    while(node.left != null) {\n      node = node.left;\n    }\n    \n    return node.data;\n  }\n~~~\n\n## Height of tree\n~~~java\npublic static int height(Node root) {\n       if(root == null) {\n           return 0;\n       }\n \n       int leftHeight = height(root.left);\n       int rightHeight = height(root.right);\n       return Math.max(leftHeight, rightHeight) + 1;\n}\n~~~\n\n## Count of Nodes\n~~~java\npublic static int countOfNodes(Node root) {\n       if(root == null) {\n           return 0;\n       }\n \n       int leftNodes = countOfNodes(root.left);\n       int rightNodes = countOfNodes(root.right);\n       return leftNodes + rightNodes + 1;\n   }\n~~~\n\n## Sum of Nodes\n~~~java\npublic static int sumOfNodes(Node root) {\n       if(root == null) {\n           return 0;\n       }\n \n       int leftSum = sumOfNodes(root.left);\n       int rightSum = sumOfNodes(root.right);\n       return leftSum + rightSum + root.data;\n   }\n~~~\n\n## Diameter/Width of Tree - Approach1 O(N)\n~~~java\npublic static TreeInfo diameter(Node root) {\n       if(root == null) {\n           return new TreeInfo(0, 0);\n       }\n \n       TreeInfo leftTI = diameter(root.left);\n       TreeInfo rightTI = diameter(root.right);\n \n       int myHeight = Math.max(leftTI.height, rightTI.height) + 1;\n \n       int diam1 = leftTI.height + rightTI.height + 1;\n       int diam2 = leftTI.diam;\n       int diam3 = rightTI.diam;\n \n       int myDiam = Math.max(diam1, Math.max(diam2, diam3));\n \n       return new TreeInfo(myHeight, myDiam);\n   }\n~~~\n\n## Diameter of Tree - Approach2 O(N^2)\n~~~java\npublic static int diameter(Node root) {\n       if(root == null) {\n           return 0;\n       }\n \n       int diam1 = height(root.left) + height(root.right) + 1;\n       int diam2 = diameter(root.left);\n       int diam3 = diameter(root.right);\n \n       return Math.max(diam1, Math.max(diam2, diam3));\n   }\n~~~\n\n## get Maximum Width\n~~~java\n    /* Function to get the maximum width of a binary tree*/\n    int getMaxWidth(Node node)\n    {\n        int maxWidth = 0;\n        int width;\n        int h = height(node);\n        int i;\n \n        /* Get width of each level and compare\n           the width with maximum width so far */\n        for (i = 1; i \u003c= h; i++) {\n            width = getWidth(node, i);\n            if (width \u003e maxWidth)\n                maxWidth = width;\n        }\n \n        return maxWidth;\n    }\n \n    /* Get width of a given level */\n    int getWidth(Node node, int level)\n    {\n        if (node == null)\n            return 0;\n \n        if (level == 1)\n            return 1;\n        else if (level \u003e 1)\n            return getWidth(node.left, level - 1)\n                + getWidth(node.right, level - 1);\n        return 0;\n    }\n~~~\n\n## Full Binary Tree\n\n-If a binary tree node is NULL then it is a full binary tree.\n-If a binary tree node does have empty left and right sub-trees, then it is a full binary tree by definition.\n\n~~~java\n    /* this function checks if a binary tree is full or not */\n    boolean isFullTree(Node node)\n    {\n        // if empty tree\n        if(node == null)\n        return true;\n          \n        // if leaf node\n        if(node.left == null \u0026\u0026 node.right == null )\n            return true;\n          \n        // if both left and right subtrees are not null\n        // the are full\n        if((node.left!=null) \u0026\u0026 (node.right!=null))\n            return (isFullTree(node.left) \u0026\u0026 isFullTree(node.right));\n          \n        // if none work\n        return false;\n    }\n~~~\n\n## Check isComplete\n\nA complete binary tree is a binary tree in which every level, except possibly the last, is completely filled, and all nodes are as far left as possible. \n\nExample:\n~~~\n                1\n              /   \\\n             2     3\n            / \\     \\\n           4   5     6\n~~~           \n~~~java\n /* Given a binary tree, return true if the tree is complete\n       else false */\n    static boolean isCompleteBT(Node root)\n    {\n        // Base Case: An empty tree is complete Binary Tree\n        if(root == null)\n            return true;\n         \n        // Create an empty queue\n        Queue\u003cNode\u003e queue =new LinkedList\u003c\u003e();\n         \n        // Create a flag variable which will be set true\n        // when a non full node is seen\n        boolean flag = false;\n         \n        // Do level order traversal using queue.\n        queue.add(root);\n        while(!queue.isEmpty())\n        {\n            Node temp_node = queue.remove();\n             \n            /* Check if left child is present*/\n            if(temp_node.left != null)\n            {\n                 // If we have seen a non full node, and we see a node\n                 // with non-empty left child, then the given tree is not\n                 // a complete Binary Tree\n                if(flag == true)\n                    return false;\n                 \n                 // Enqueue Left Child\n                queue.add(temp_node.left);\n            }\n            // If this a non-full node, set the flag as true\n            else\n                flag = true;\n             \n            /* Check if right child is present*/\n            if(temp_node.right != null)\n            {\n                // If we have seen a non full node, and we see a node\n                // with non-empty right child, then the given tree is not\n                // a complete Binary Tree\n                if(flag == true)\n                    return false;\n                 \n                // Enqueue Right Child\n                queue.add(temp_node.right);\n                 \n            }\n            // If this a non-full node, set the flag as true\n            else\n                flag = true;\n        }\n         // If we reach here, then the tree is complete Binary Tree\n        return true;\n    }\n~~~\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fsubraatakumar%2Fbinary-search-tree-java","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fsubraatakumar%2Fbinary-search-tree-java","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fsubraatakumar%2Fbinary-search-tree-java/lists"}